Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <stdlib.h>
21 :
22 : #include <tools/shl.hxx>
23 : #include <tools/urlobj.hxx>
24 : #include <sfx2/app.hxx>
25 : #include <sfx2/module.hxx>
26 : #include <svx/dialogs.hrc>
27 :
28 : #include "svx/xattr.hxx"
29 : #include <svx/xpool.hxx>
30 : #include <cuires.hrc>
31 : #include <svx/xflbckit.hxx>
32 : #include <svx/svdattr.hxx>
33 : #include <svx/xtable.hxx>
34 : #include <svx/xlineit0.hxx>
35 : #include "svx/drawitem.hxx"
36 : #include "cuitabarea.hxx"
37 : #include "dlgname.hxx"
38 : #include <dialmgr.hxx>
39 : #include "svx/dlgutil.hxx"
40 : #include <svl/intitem.hxx>
41 : #include <sfx2/request.hxx>
42 : #include "paragrph.hrc"
43 :
44 : //UUUU
45 : #include "sfx2/opengrf.hxx"
46 : #include <vcl/msgbox.hxx>
47 :
48 : // static ----------------------------------------------------------------
49 :
50 : static sal_uInt16 pAreaRanges[] =
51 : {
52 : XATTR_GRADIENTSTEPCOUNT,
53 : XATTR_GRADIENTSTEPCOUNT,
54 : SID_ATTR_FILL_STYLE,
55 : SID_ATTR_FILL_BITMAP,
56 : 0
57 : };
58 :
59 : static sal_uInt16 pTransparenceRanges[] =
60 : {
61 : XATTR_FILLTRANSPARENCE,
62 : XATTR_FILLTRANSPARENCE,
63 : SDRATTR_SHADOWTRANSPARENCE,
64 : SDRATTR_SHADOWTRANSPARENCE,
65 : XATTR_FILLFLOATTRANSPARENCE,
66 : XATTR_FILLFLOATTRANSPARENCE,
67 : 0
68 : };
69 :
70 : /*************************************************************************
71 : |*
72 : |* Dialog for transparence
73 : |*
74 : \************************************************************************/
75 :
76 0 : IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransOffHdl_Impl)
77 : {
78 : // disable all other controls
79 0 : ActivateLinear(sal_False);
80 0 : ActivateGradient(sal_False);
81 :
82 : // Preview
83 0 : rXFSet.ClearItem (XATTR_FILLTRANSPARENCE);
84 0 : rXFSet.ClearItem (XATTR_FILLFLOATTRANSPARENCE);
85 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
86 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
87 :
88 0 : InvalidatePreview( sal_False );
89 :
90 0 : return( 0L );
91 : }
92 :
93 0 : IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransLinearHdl_Impl)
94 : {
95 : // enable linear, disable other
96 0 : ActivateLinear(sal_True);
97 0 : ActivateGradient(sal_False);
98 :
99 : // preview
100 0 : rXFSet.ClearItem (XATTR_FILLFLOATTRANSPARENCE);
101 0 : ModifyTransparentHdl_Impl (NULL);
102 :
103 0 : return( 0L );
104 : }
105 :
106 0 : IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransGradientHdl_Impl)
107 : {
108 : // enable gradient, disable other
109 0 : ActivateLinear(sal_False);
110 0 : ActivateGradient(sal_True);
111 :
112 : // preview
113 0 : rXFSet.ClearItem (XATTR_FILLTRANSPARENCE);
114 0 : ModifiedTrgrHdl_Impl (NULL);
115 :
116 0 : return( 0L );
117 : }
118 :
119 0 : void SvxTransparenceTabPage::ActivateLinear(sal_Bool bActivate)
120 : {
121 0 : m_pMtrTransparent->Enable(bActivate);
122 0 : }
123 :
124 0 : IMPL_LINK_NOARG(SvxTransparenceTabPage, ModifyTransparentHdl_Impl)
125 : {
126 0 : sal_uInt16 nPos = (sal_uInt16)m_pMtrTransparent->GetValue();
127 0 : XFillTransparenceItem aItem(nPos);
128 0 : rXFSet.Put(XFillTransparenceItem(aItem));
129 :
130 : // preview
131 0 : InvalidatePreview();
132 :
133 0 : return 0L;
134 : }
135 :
136 0 : IMPL_LINK(SvxTransparenceTabPage, ModifiedTrgrHdl_Impl, void *, pControl)
137 : {
138 0 : if(pControl == m_pLbTrgrGradientType || pControl == this)
139 : {
140 0 : XGradientStyle eXGS = (XGradientStyle)m_pLbTrgrGradientType->GetSelectEntryPos();
141 0 : SetControlState_Impl( eXGS );
142 : }
143 :
144 : // preview
145 0 : sal_uInt8 nStartCol = (sal_uInt8)(((sal_uInt16)m_pMtrTrgrStartValue->GetValue() * 255) / 100);
146 0 : sal_uInt8 nEndCol = (sal_uInt8)(((sal_uInt16)m_pMtrTrgrEndValue->GetValue() * 255) / 100);
147 : XGradient aTmpGradient(
148 : Color(nStartCol, nStartCol, nStartCol),
149 : Color(nEndCol, nEndCol, nEndCol),
150 0 : (XGradientStyle)m_pLbTrgrGradientType->GetSelectEntryPos(),
151 0 : (sal_uInt16)m_pMtrTrgrAngle->GetValue() * 10,
152 0 : (sal_uInt16)m_pMtrTrgrCenterX->GetValue(),
153 0 : (sal_uInt16)m_pMtrTrgrCenterY->GetValue(),
154 0 : (sal_uInt16)m_pMtrTrgrBorder->GetValue(),
155 0 : 100, 100);
156 :
157 0 : XFillFloatTransparenceItem aItem( rXFSet.GetPool()/*aString*/, aTmpGradient);
158 0 : rXFSet.Put ( aItem );
159 :
160 0 : InvalidatePreview();
161 :
162 0 : return( 0L );
163 : }
164 :
165 0 : void SvxTransparenceTabPage::ActivateGradient(sal_Bool bActivate)
166 : {
167 0 : m_pGridGradient->Enable(bActivate);
168 :
169 0 : if(bActivate)
170 : {
171 0 : XGradientStyle eXGS = (XGradientStyle)m_pLbTrgrGradientType->GetSelectEntryPos();
172 0 : SetControlState_Impl( eXGS );
173 : }
174 0 : }
175 :
176 0 : IMPL_LINK_NOARG(SvxTransparenceTabPage, ChangeTrgrTypeHdl_Impl)
177 : {
178 0 : return( 0L );
179 : }
180 :
181 0 : void SvxTransparenceTabPage::SetControlState_Impl(XGradientStyle eXGS)
182 : {
183 0 : switch(eXGS)
184 : {
185 : case XGRAD_LINEAR:
186 : case XGRAD_AXIAL:
187 0 : m_pFtTrgrCenterX->Disable();
188 0 : m_pMtrTrgrCenterX->Disable();
189 0 : m_pFtTrgrCenterY->Disable();
190 0 : m_pMtrTrgrCenterY->Disable();
191 0 : m_pFtTrgrAngle->Enable();
192 0 : m_pMtrTrgrAngle->Enable();
193 0 : break;
194 :
195 : case XGRAD_RADIAL:
196 0 : m_pFtTrgrCenterX->Enable();
197 0 : m_pMtrTrgrCenterX->Enable();
198 0 : m_pFtTrgrCenterY->Enable();
199 0 : m_pMtrTrgrCenterY->Enable();
200 0 : m_pFtTrgrAngle->Disable();
201 0 : m_pMtrTrgrAngle->Disable();
202 0 : break;
203 :
204 : case XGRAD_ELLIPTICAL:
205 0 : m_pFtTrgrCenterX->Enable();
206 0 : m_pMtrTrgrCenterX->Enable();
207 0 : m_pFtTrgrCenterY->Enable();
208 0 : m_pMtrTrgrCenterY->Enable();
209 0 : m_pFtTrgrAngle->Enable();
210 0 : m_pMtrTrgrAngle->Enable();
211 0 : break;
212 :
213 : case XGRAD_SQUARE:
214 : case XGRAD_RECT:
215 0 : m_pFtTrgrCenterX->Enable();
216 0 : m_pMtrTrgrCenterX->Enable();
217 0 : m_pFtTrgrCenterY->Enable();
218 0 : m_pMtrTrgrCenterY->Enable();
219 0 : m_pFtTrgrAngle->Enable();
220 0 : m_pMtrTrgrAngle->Enable();
221 0 : break;
222 : }
223 0 : }
224 :
225 0 : SvxTransparenceTabPage::SvxTransparenceTabPage(Window* pParent, const SfxItemSet& rInAttrs)
226 : : SvxTabPage ( pParent,
227 : "TransparencyTabPage",
228 : "cui/ui/transparencytabpage.ui",
229 : rInAttrs),
230 : rOutAttrs ( rInAttrs ),
231 : eRP ( RP_LT ),
232 : nPageType (0),
233 : nDlgType (0),
234 : bBitmap ( sal_False ),
235 0 : pXPool ( (XOutdevItemPool*) rInAttrs.GetPool() ),
236 : aXFillAttr ( pXPool ),
237 0 : rXFSet ( aXFillAttr.GetItemSet() )
238 : {
239 0 : get(m_pRbtTransOff,"RBT_TRANS_OFF");
240 0 : get(m_pRbtTransLinear,"RBT_TRANS_LINEAR");
241 0 : get(m_pRbtTransGradient,"RBT_TRANS_GRADIENT");
242 :
243 0 : get(m_pMtrTransparent,"MTR_TRANSPARENT");
244 :
245 0 : get(m_pGridGradient,"gridGradient");
246 0 : get(m_pLbTrgrGradientType,"LB_TRGR_GRADIENT_TYPES");
247 0 : get(m_pFtTrgrCenterX,"FT_TRGR_CENTER_X");
248 0 : get(m_pMtrTrgrCenterX,"MTR_TRGR_CENTER_X");
249 0 : get(m_pFtTrgrCenterY,"FT_TRGR_CENTER_Y");
250 0 : get(m_pMtrTrgrCenterY,"MTR_TRGR_CENTER_Y");
251 0 : get(m_pFtTrgrAngle,"FT_TRGR_ANGLE"),
252 0 : get(m_pMtrTrgrAngle,"MTR_TRGR_ANGLE");
253 0 : get(m_pMtrTrgrBorder,"MTR_TRGR_BORDER");
254 0 : get(m_pMtrTrgrStartValue,"MTR_TRGR_START_VALUE");
255 0 : get(m_pMtrTrgrEndValue,"MTR_TRGR_END_VALUE");
256 :
257 0 : get(m_pCtlBitmapPreview,"CTL_BITMAP_PREVIEW");
258 0 : get(m_pCtlXRectPreview,"CTL_TRANS_PREVIEW");
259 :
260 : // main selection
261 0 : m_pRbtTransOff->SetClickHdl(LINK(this, SvxTransparenceTabPage, ClickTransOffHdl_Impl));
262 0 : m_pRbtTransLinear->SetClickHdl(LINK(this, SvxTransparenceTabPage, ClickTransLinearHdl_Impl));
263 0 : m_pRbtTransGradient->SetClickHdl(LINK(this, SvxTransparenceTabPage, ClickTransGradientHdl_Impl));
264 :
265 : // linear transparency
266 0 : m_pMtrTransparent->SetValue( 50 );
267 0 : m_pMtrTransparent->SetModifyHdl(LINK(this, SvxTransparenceTabPage, ModifyTransparentHdl_Impl));
268 :
269 : // gradient transparency
270 0 : m_pMtrTrgrEndValue->SetValue( 100 );
271 0 : m_pMtrTrgrStartValue->SetValue( 0 );
272 0 : m_pLbTrgrGradientType->SetSelectHdl(LINK(this, SvxTransparenceTabPage, ChangeTrgrTypeHdl_Impl));
273 0 : Link aLink = LINK( this, SvxTransparenceTabPage, ModifiedTrgrHdl_Impl);
274 0 : m_pLbTrgrGradientType->SetSelectHdl( aLink );
275 0 : m_pMtrTrgrCenterX->SetModifyHdl( aLink );
276 0 : m_pMtrTrgrCenterY->SetModifyHdl( aLink );
277 0 : m_pMtrTrgrAngle->SetModifyHdl( aLink );
278 0 : m_pMtrTrgrBorder->SetModifyHdl( aLink );
279 0 : m_pMtrTrgrStartValue->SetModifyHdl( aLink );
280 0 : m_pMtrTrgrEndValue->SetModifyHdl( aLink );
281 :
282 : // this page needs ExchangeSupport
283 0 : SetExchangeSupport();
284 0 : }
285 :
286 0 : void SvxTransparenceTabPage::Construct()
287 : {
288 0 : }
289 :
290 0 : SfxTabPage* SvxTransparenceTabPage::Create(Window* pWindow, const SfxItemSet& rAttrs)
291 : {
292 0 : return(new SvxTransparenceTabPage(pWindow, rAttrs));
293 : }
294 :
295 0 : sal_uInt16* SvxTransparenceTabPage::GetRanges()
296 : {
297 0 : return(pTransparenceRanges);
298 : }
299 :
300 0 : bool SvxTransparenceTabPage::FillItemSet(SfxItemSet& rAttrs)
301 : {
302 0 : const SfxPoolItem* pGradientItem = NULL;
303 0 : const SfxPoolItem* pLinearItem = NULL;
304 0 : SfxItemState eStateGradient(rOutAttrs.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem));
305 0 : SfxItemState eStateLinear(rOutAttrs.GetItemState(XATTR_FILLTRANSPARENCE, true, &pLinearItem));
306 0 : sal_Bool bGradActive = (eStateGradient == SFX_ITEM_SET && ((XFillFloatTransparenceItem*)pGradientItem)->IsEnabled());
307 0 : sal_Bool bLinearActive = (eStateLinear == SFX_ITEM_SET && ((XFillTransparenceItem*)pLinearItem)->GetValue() != 0);
308 :
309 : // #103765#
310 0 : sal_Bool bGradUsed = (eStateGradient == SFX_ITEM_DONTCARE);
311 0 : sal_Bool bLinearUsed = (eStateLinear == SFX_ITEM_DONTCARE);
312 :
313 0 : sal_Bool bModified(sal_False);
314 0 : sal_Bool bSwitchOffLinear(sal_False);
315 0 : sal_Bool bSwitchOffGradient(sal_False);
316 :
317 0 : if(m_pMtrTransparent->IsEnabled())
318 : {
319 : // linear transparence
320 0 : sal_uInt16 nPos = (sal_uInt16)m_pMtrTransparent->GetValue();
321 0 : if(nPos != (sal_uInt16)m_pMtrTransparent->GetSavedValue().toInt32() || !bLinearActive)
322 : {
323 0 : XFillTransparenceItem aItem(nPos);
324 0 : SdrShadowTransparenceItem aShadowItem(nPos);
325 0 : const SfxPoolItem* pOld = GetOldItem(rAttrs, XATTR_FILLTRANSPARENCE);
326 0 : if(!pOld || !(*(const XFillTransparenceItem*)pOld == aItem) || !bLinearActive)
327 : {
328 0 : rAttrs.Put(aItem);
329 0 : rAttrs.Put(aShadowItem);
330 0 : bModified = sal_True;
331 0 : bSwitchOffGradient = sal_True;
332 0 : }
333 : }
334 : }
335 0 : else if(m_pLbTrgrGradientType->IsEnabled())
336 : {
337 : // transparence gradient, fill ItemSet from values
338 0 : if(!bGradActive
339 0 : || (XGradientStyle)m_pLbTrgrGradientType->GetSelectEntryPos() != (XGradientStyle)m_pLbTrgrGradientType->GetSavedValue()
340 0 : || (sal_uInt16)m_pMtrTrgrAngle->GetValue() != (sal_uInt16)m_pMtrTrgrAngle->GetSavedValue().toInt32()
341 0 : || (sal_uInt16)m_pMtrTrgrCenterX->GetValue() != (sal_uInt16)m_pMtrTrgrCenterX->GetSavedValue().toInt32()
342 0 : || (sal_uInt16)m_pMtrTrgrCenterY->GetValue() != (sal_uInt16)m_pMtrTrgrCenterY->GetSavedValue().toInt32()
343 0 : || (sal_uInt16)m_pMtrTrgrBorder->GetValue() != (sal_uInt16)m_pMtrTrgrBorder->GetSavedValue().toInt32()
344 0 : || (sal_uInt16)m_pMtrTrgrStartValue->GetValue() != (sal_uInt16)m_pMtrTrgrStartValue->GetSavedValue().toInt32()
345 0 : || (sal_uInt16)m_pMtrTrgrEndValue->GetValue() != (sal_uInt16)m_pMtrTrgrEndValue->GetSavedValue().toInt32() )
346 : {
347 0 : sal_uInt8 nStartCol = (sal_uInt8)(((sal_uInt16)m_pMtrTrgrStartValue->GetValue() * 255) / 100);
348 0 : sal_uInt8 nEndCol = (sal_uInt8)(((sal_uInt16)m_pMtrTrgrEndValue->GetValue() * 255) / 100);
349 : XGradient aTmpGradient(
350 : Color(nStartCol, nStartCol, nStartCol),
351 : Color(nEndCol, nEndCol, nEndCol),
352 0 : (XGradientStyle)m_pLbTrgrGradientType->GetSelectEntryPos(),
353 0 : (sal_uInt16)m_pMtrTrgrAngle->GetValue() * 10,
354 0 : (sal_uInt16)m_pMtrTrgrCenterX->GetValue(),
355 0 : (sal_uInt16)m_pMtrTrgrCenterY->GetValue(),
356 0 : (sal_uInt16)m_pMtrTrgrBorder->GetValue(),
357 0 : 100, 100);
358 :
359 0 : XFillFloatTransparenceItem aItem( rXFSet.GetPool()/*aString*/, aTmpGradient);
360 0 : const SfxPoolItem* pOld = GetOldItem(rAttrs, XATTR_FILLFLOATTRANSPARENCE);
361 :
362 0 : if(!pOld || !(*(const XFillFloatTransparenceItem*)pOld == aItem) || !bGradActive)
363 : {
364 0 : rAttrs.Put(aItem);
365 0 : bModified = sal_True;
366 0 : bSwitchOffLinear = sal_True;
367 0 : }
368 : }
369 : }
370 : else
371 : {
372 : // no transparence
373 0 : bSwitchOffGradient = sal_True;
374 0 : bSwitchOffLinear = sal_True;
375 : }
376 :
377 : // disable unused XFillFloatTransparenceItem
378 0 : if(bSwitchOffGradient && (bGradActive || bGradUsed))
379 : {
380 0 : Color aColor(COL_BLACK);
381 0 : XGradient aGrad(aColor, Color(COL_WHITE));
382 0 : aGrad.SetStartIntens(100);
383 0 : aGrad.SetEndIntens(100);
384 0 : XFillFloatTransparenceItem aItem( rXFSet.GetPool()/*aString*/, aGrad);
385 0 : aItem.SetEnabled(false);
386 0 : rAttrs.Put(aItem);
387 0 : bModified = sal_True;
388 : }
389 :
390 : // disable unused XFillFloatTransparenceItem
391 0 : if(bSwitchOffLinear && (bLinearActive || bLinearUsed))
392 : {
393 0 : XFillTransparenceItem aItem(0);
394 0 : SdrShadowTransparenceItem aShadowItem(0);
395 0 : rAttrs.Put(aItem);
396 0 : rAttrs.Put(aShadowItem);
397 0 : bModified = sal_True;
398 : }
399 0 : rAttrs.Put (CntUInt16Item(SID_PAGE_TYPE,nPageType));
400 0 : return bModified;
401 : }
402 :
403 0 : void SvxTransparenceTabPage::Reset(const SfxItemSet& rAttrs)
404 : {
405 0 : const SfxPoolItem* pGradientItem = NULL;
406 0 : SfxItemState eStateGradient(rAttrs.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem));
407 0 : if(!pGradientItem)
408 0 : pGradientItem = &rAttrs.Get(XATTR_FILLFLOATTRANSPARENCE);
409 0 : sal_Bool bGradActive = (eStateGradient == SFX_ITEM_SET && ((XFillFloatTransparenceItem*)pGradientItem)->IsEnabled());
410 :
411 0 : const SfxPoolItem* pLinearItem = NULL;
412 0 : SfxItemState eStateLinear(rAttrs.GetItemState(XATTR_FILLTRANSPARENCE, true, &pLinearItem));
413 0 : if(!pLinearItem)
414 0 : pLinearItem = &rAttrs.Get(XATTR_FILLTRANSPARENCE);
415 0 : sal_Bool bLinearActive = (eStateLinear == SFX_ITEM_SET && ((XFillTransparenceItem*)pLinearItem)->GetValue() != 0);
416 :
417 : // transparence gradient
418 0 : const XGradient& rGradient = ((XFillFloatTransparenceItem*)pGradientItem)->GetGradientValue();
419 0 : XGradientStyle eXGS(rGradient.GetGradientStyle());
420 0 : m_pLbTrgrGradientType->SelectEntryPos(sal::static_int_cast< sal_Int32 >(eXGS));
421 0 : m_pMtrTrgrAngle->SetValue(rGradient.GetAngle() / 10);
422 0 : m_pMtrTrgrBorder->SetValue(rGradient.GetBorder());
423 0 : m_pMtrTrgrCenterX->SetValue(rGradient.GetXOffset());
424 0 : m_pMtrTrgrCenterY->SetValue(rGradient.GetYOffset());
425 0 : m_pMtrTrgrStartValue->SetValue((sal_uInt16)((((sal_uInt16)rGradient.GetStartColor().GetRed() + 1) * 100) / 255));
426 0 : m_pMtrTrgrEndValue->SetValue((sal_uInt16)((((sal_uInt16)rGradient.GetEndColor().GetRed() + 1) * 100) / 255));
427 :
428 : // linear transparence
429 0 : sal_uInt16 nTransp = ((XFillTransparenceItem*)pLinearItem)->GetValue();
430 0 : m_pMtrTransparent->SetValue(bLinearActive ? nTransp : 50);
431 0 : ModifyTransparentHdl_Impl(NULL);
432 :
433 : // select the correct radio button
434 0 : if(bGradActive)
435 : {
436 : // transparence gradient, set controls appropriate to item
437 0 : m_pRbtTransGradient->Check();
438 0 : ClickTransGradientHdl_Impl(NULL);
439 : }
440 0 : else if(bLinearActive)
441 : {
442 : // linear transparence
443 0 : m_pRbtTransLinear->Check();
444 0 : ClickTransLinearHdl_Impl(NULL);
445 : }
446 : else
447 : {
448 : // no transparence
449 0 : m_pRbtTransOff->Check();
450 0 : ClickTransOffHdl_Impl(NULL);
451 0 : ModifiedTrgrHdl_Impl(NULL);
452 : }
453 :
454 : // save values
455 0 : m_pMtrTransparent->SaveValue();
456 0 : m_pLbTrgrGradientType->SaveValue();
457 0 : m_pMtrTrgrCenterX->SaveValue();
458 0 : m_pMtrTrgrCenterY->SaveValue();
459 0 : m_pMtrTrgrAngle->SaveValue();
460 0 : m_pMtrTrgrBorder->SaveValue();
461 0 : m_pMtrTrgrStartValue->SaveValue();
462 0 : m_pMtrTrgrEndValue->SaveValue();
463 :
464 0 : sal_Bool bActive = InitPreview ( rAttrs );
465 0 : InvalidatePreview ( bActive );
466 0 : }
467 :
468 0 : void SvxTransparenceTabPage::ActivatePage(const SfxItemSet& rSet)
469 : {
470 0 : SFX_ITEMSET_ARG (&rSet,pPageTypeItem,CntUInt16Item,SID_PAGE_TYPE,false);
471 0 : if (pPageTypeItem)
472 0 : SetPageType(pPageTypeItem->GetValue());
473 :
474 0 : if(nDlgType == 0) // area dialog
475 0 : nPageType = PT_TRANSPARENCE;
476 :
477 0 : InitPreview ( rSet );
478 0 : }
479 :
480 0 : int SvxTransparenceTabPage::DeactivatePage(SfxItemSet* _pSet)
481 : {
482 0 : if( _pSet )
483 0 : FillItemSet( *_pSet );
484 0 : return(LEAVE_PAGE);
485 : }
486 :
487 0 : void SvxTransparenceTabPage::PointChanged(Window* , RECT_POINT eRcPt)
488 : {
489 0 : eRP = eRcPt;
490 0 : }
491 :
492 :
493 : // Preview-Methods
494 :
495 0 : sal_Bool SvxTransparenceTabPage::InitPreview ( const SfxItemSet& rSet )
496 : {
497 : // set transparencetyp for preview
498 0 : if ( m_pRbtTransOff->IsChecked() )
499 : {
500 0 : ClickTransOffHdl_Impl(NULL);
501 0 : } else if ( m_pRbtTransLinear->IsChecked() )
502 : {
503 0 : ClickTransLinearHdl_Impl(NULL);
504 0 : } else if ( m_pRbtTransGradient->IsChecked() )
505 : {
506 0 : ClickTransGradientHdl_Impl(NULL);
507 : }
508 :
509 : // Get fillstyle for preview
510 0 : rXFSet.Put ( ( XFillStyleItem& ) rSet.Get(XATTR_FILLSTYLE) );
511 0 : rXFSet.Put ( ( XFillColorItem& ) rSet.Get(XATTR_FILLCOLOR) );
512 0 : rXFSet.Put ( ( XFillGradientItem& ) rSet.Get(XATTR_FILLGRADIENT) );
513 0 : rXFSet.Put ( ( XFillHatchItem& ) rSet.Get(XATTR_FILLHATCH) );
514 0 : rXFSet.Put ( ( XFillBackgroundItem&)rSet.Get(XATTR_FILLBACKGROUND) );
515 0 : rXFSet.Put ( ( XFillBitmapItem& ) rSet.Get(XATTR_FILLBITMAP) );
516 :
517 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
518 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
519 :
520 0 : bBitmap = ( ( ( XFillStyleItem& )rSet.Get(XATTR_FILLSTYLE) ).GetValue() == XFILL_BITMAP );
521 :
522 : // show the right preview window
523 0 : if ( bBitmap )
524 : {
525 0 : m_pCtlBitmapPreview->Show();
526 0 : m_pCtlXRectPreview->Hide();
527 : }
528 : else
529 : {
530 0 : m_pCtlBitmapPreview->Hide();
531 0 : m_pCtlXRectPreview->Show();
532 : }
533 :
534 0 : return !m_pRbtTransOff->IsChecked();
535 : }
536 :
537 0 : void SvxTransparenceTabPage::InvalidatePreview (sal_Bool bEnable)
538 : {
539 0 : if ( bBitmap )
540 : {
541 0 : if ( bEnable )
542 : {
543 0 : m_pCtlBitmapPreview->Enable();
544 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
545 : }
546 : else
547 0 : m_pCtlBitmapPreview->Disable();
548 0 : m_pCtlBitmapPreview->Invalidate();
549 : }
550 : else
551 : {
552 0 : if ( bEnable )
553 : {
554 0 : m_pCtlXRectPreview->Enable();
555 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
556 : }
557 : else
558 0 : m_pCtlXRectPreview->Disable();
559 0 : m_pCtlXRectPreview->Invalidate();
560 : }
561 0 : }
562 :
563 0 : void SvxTransparenceTabPage::PageCreated (SfxAllItemSet aSet)
564 : {
565 0 : SFX_ITEMSET_ARG (&aSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,false);
566 0 : SFX_ITEMSET_ARG (&aSet,pDlgTypeItem,SfxUInt16Item,SID_DLG_TYPE,false);
567 :
568 0 : if (pPageTypeItem)
569 0 : SetPageType(pPageTypeItem->GetValue());
570 0 : if (pDlgTypeItem)
571 0 : SetDlgType(pDlgTypeItem->GetValue());
572 0 : Construct();
573 0 : }
574 : /*************************************************************************
575 : |*
576 : |* Dialog to modify fill-attributes
577 : |*
578 : \************************************************************************/
579 :
580 0 : SvxAreaTabPage::SvxAreaTabPage( Window* pParent, const SfxItemSet& rInAttrs ) :
581 :
582 : SvxTabPage( pParent,
583 : "AreaTabPage",
584 : "cui/ui/areatabpage.ui",
585 : rInAttrs ),
586 : rOutAttrs (rInAttrs ),
587 : eRP( RP_LT ),
588 :
589 : pColorList( NULL ),
590 : pGradientList( NULL ),
591 : pHatchingList( NULL ),
592 : pBitmapList( NULL ),
593 :
594 : // local fixed not o be changed values for local pointers
595 : maFixed_ChangeType(CT_NONE),
596 : maFixed_sal_Bool(false),
597 :
598 : // init with pointers to fixed ChangeType
599 : pnColorListState(&maFixed_ChangeType),
600 : pnBitmapListState(&maFixed_ChangeType),
601 : pnGradientListState(&maFixed_ChangeType),
602 : pnHatchingListState(&maFixed_ChangeType),
603 :
604 : nPageType(0),
605 : nDlgType(0),
606 : nPos(0),
607 :
608 : // init with pointer to fixed bool
609 : pbAreaTP(&maFixed_sal_Bool),
610 :
611 0 : pXPool ( (XOutdevItemPool*) rInAttrs.GetPool() ),
612 : aXFillAttr ( pXPool ),
613 0 : rXFSet ( aXFillAttr.GetItemSet() ),
614 :
615 : ePoolUnit(SFX_MAPUNIT_100TH_MM),
616 : eFUnit(FUNIT_NONE),
617 :
618 : //UUUU
619 : mbOfferImportButton(false),
620 : mbDirectGraphicSet(false),
621 0 : maDirectGraphic()
622 : {
623 0 : get(m_pTypeLB,"LB_AREA_TYPE");
624 0 : get(m_pFillLB,"boxLB_FILL");
625 0 : get(m_pLbColor,"LB_COLOR");
626 0 : get(m_pLbGradient,"LB_GRADIENT");
627 0 : get(m_pLbHatching,"LB_HATCHING");
628 0 : get(m_pLbBitmap,"LB_BITMAP");
629 0 : get(m_pCtlBitmapPreview,"CTL_BITMAP_PREVIEW");
630 :
631 0 : get(m_pTsbStepCount,"TSB_STEPCOUNT");
632 0 : get(m_pFlStepCount,"FL_STEPCOUNT");
633 0 : get(m_pNumFldStepCount,"NUM_FLD_STEPCOUNT");
634 :
635 0 : get(m_pFlHatchBckgrd,"FL_HATCHCOLORS");
636 0 : get(m_pLbHatchBckgrdColor,"LB_HATCHBCKGRDCOLOR");
637 0 : get(m_pCbxHatchBckgrd,"CB_HATCHBCKGRD");
638 :
639 0 : get(m_pBxBitmap,"boxBITMAP");
640 :
641 0 : get(m_pFlSize,"FL_SIZE");
642 0 : get(m_pGridX_Y,"gridX_Y");
643 0 : get(m_pTsbOriginal,"TSB_ORIGINAL");
644 0 : get(m_pTsbScale,"TSB_SCALE");
645 0 : get(m_pFtXSize,"FT_X_SIZE");
646 0 : get(m_pMtrFldXSize,"MTR_FLD_X_SIZE");
647 0 : get(m_pFtYSize,"FT_Y_SIZE");
648 0 : get(m_pMtrFldYSize,"MTR_FLD_Y_SIZE");
649 :
650 0 : get(m_pFlPosition,"framePOSITION");
651 0 : get(m_pCtlPosition,"CTL_POSITION");
652 0 : get(m_pGridOffset,"gridOFFSET");
653 0 : get(m_pMtrFldXOffset,"MTR_FLD_X_OFFSET");
654 0 : get(m_pMtrFldYOffset,"MTR_FLD_Y_OFFSET");
655 0 : get(m_pBxTile,"boxTILE");
656 0 : get(m_pTsbTile,"TSB_TILE");
657 0 : get(m_pTsbStretch,"TSB_STRETCH");
658 :
659 0 : get(m_pFlOffset,"FL_OFFSET");
660 0 : get(m_pRbtRow,"RBT_ROW");
661 0 : get(m_pRbtColumn,"RBT_COLUMN");
662 0 : get(m_pBtnImport, "btnimport");
663 0 : get(m_pMtrFldOffset,"MTR_FLD_OFFSET");
664 :
665 0 : get(m_pCtlXRectPreview,"CTL_COLOR_PREVIEW");
666 :
667 : //so that even for "none" the size requested is the largest
668 : //size required for any of the areas which might be selected
669 : //later, so that there's sufficient space
670 0 : VclContainer *pMainFrame = get<VclContainer>("mainframe");
671 0 : Size aIncrementsSize(m_pFlStepCount->get_preferred_size());
672 0 : Size aHatchSize(m_pFlHatchBckgrd->get_preferred_size());
673 0 : Size aBitmapSize(m_pBxBitmap->get_preferred_size());
674 : Size aMainFrame(
675 0 : std::max(std::max(aIncrementsSize.Width(), aHatchSize.Width()), aBitmapSize.Width()),
676 0 : std::max(std::max(aIncrementsSize.Height(), aHatchSize.Height()), aBitmapSize.Height()));
677 0 : pMainFrame->set_width_request(aMainFrame.Width());
678 0 : pMainFrame->set_height_request(aMainFrame.Height());
679 :
680 :
681 :
682 : // groups that overlay each other
683 0 : m_pLbBitmap->Hide();
684 0 : m_pCtlBitmapPreview->Hide();
685 :
686 0 : m_pFlStepCount->Hide();
687 :
688 0 : m_pBxBitmap->Hide();
689 :
690 : // Controls for Hatch-Background
691 0 : m_pFlHatchBckgrd->Hide();
692 :
693 0 : m_pTsbOriginal->EnableTriState( false );
694 :
695 : // this page needs ExchangeSupport
696 0 : SetExchangeSupport();
697 :
698 : // set Metrics
699 0 : eFUnit = GetModuleFieldUnit( rInAttrs );
700 :
701 0 : switch ( eFUnit )
702 : {
703 : case FUNIT_M:
704 : case FUNIT_KM:
705 0 : eFUnit = FUNIT_MM;
706 0 : break;
707 : default: ;//prevent warning
708 : }
709 0 : SetFieldUnit( *m_pMtrFldXSize, eFUnit, true );
710 0 : SetFieldUnit( *m_pMtrFldYSize, eFUnit, true );
711 :
712 : // get PoolUnit
713 0 : SfxItemPool* pPool = rOutAttrs.GetPool();
714 : DBG_ASSERT( pPool, "Wo ist der Pool?" );
715 0 : ePoolUnit = pPool->GetMetric( XATTR_FILLBMP_SIZEX );
716 :
717 : // setting the output device
718 0 : rXFSet.Put( XFillStyleItem( XFILL_SOLID ) );
719 0 : rXFSet.Put( XFillColorItem( OUString(), COL_BLACK ) );
720 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
721 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
722 :
723 0 : m_pLbColor->SetSelectHdl( LINK( this, SvxAreaTabPage, ModifyColorHdl_Impl ) );
724 0 : m_pLbHatchBckgrdColor->SetSelectHdl( LINK( this, SvxAreaTabPage, ModifyHatchBckgrdColorHdl_Impl ) );
725 0 : m_pCbxHatchBckgrd->SetToggleHdl( LINK( this, SvxAreaTabPage, ToggleHatchBckgrdColorHdl_Impl ) );
726 : //UUUU
727 0 : m_pBtnImport->SetClickHdl(LINK(this, SvxAreaTabPage, ClickImportHdl_Impl));
728 :
729 0 : m_pLbGradient->SetSelectHdl( LINK( this, SvxAreaTabPage, ModifyGradientHdl_Impl ) );
730 0 : m_pLbHatching->SetSelectHdl( LINK( this, SvxAreaTabPage, ModifyHatchingHdl_Impl ) );
731 0 : m_pLbBitmap->SetSelectHdl( LINK( this, SvxAreaTabPage, ModifyBitmapHdl_Impl ) );
732 :
733 0 : m_pTsbStepCount->SetClickHdl( LINK( this, SvxAreaTabPage, ModifyStepCountHdl_Impl ) );
734 0 : m_pNumFldStepCount->SetModifyHdl( LINK( this, SvxAreaTabPage, ModifyStepCountHdl_Impl ) );
735 :
736 0 : Link aLink( LINK( this, SvxAreaTabPage, ModifyTileHdl_Impl ) );
737 0 : m_pTsbTile->SetClickHdl( aLink );
738 0 : m_pTsbStretch->SetClickHdl( aLink );
739 0 : m_pTsbOriginal->SetClickHdl( aLink );
740 0 : m_pMtrFldXSize->SetModifyHdl( aLink );
741 0 : m_pMtrFldYSize->SetModifyHdl( aLink );
742 0 : m_pRbtRow->SetClickHdl( aLink );
743 0 : m_pRbtColumn->SetClickHdl( aLink );
744 0 : m_pMtrFldOffset->SetModifyHdl( aLink );
745 0 : m_pMtrFldXOffset->SetModifyHdl( aLink );
746 0 : m_pMtrFldYOffset->SetModifyHdl( aLink );
747 0 : m_pTsbScale->SetClickHdl( LINK( this, SvxAreaTabPage, ClickScaleHdl_Impl ) );
748 :
749 0 : m_pTypeLB->SetSelectHdl( LINK( this, SvxAreaTabPage, SelectDialogTypeHdl_Impl ) );
750 :
751 : // #i76307# always paint the preview in LTR, because this is what the document does
752 0 : m_pCtlXRectPreview->EnableRTL(false);
753 :
754 : // Calcualte size of dropdown listboxes
755 0 : Size aSize = LogicToPixel(Size(108, 103), MAP_APPFONT);
756 :
757 0 : m_pLbColor->set_width_request(aSize.Width());
758 0 : m_pLbColor->set_height_request(aSize.Height());
759 : //m_pLbColor->
760 :
761 0 : m_pLbGradient->set_width_request(aSize.Width());
762 0 : m_pLbGradient->set_height_request(aSize.Height());
763 0 : m_pLbHatching->set_width_request(aSize.Width());
764 0 : m_pLbHatching->set_height_request(aSize.Height());
765 0 : m_pLbBitmap->set_width_request(aSize.Width());
766 0 : m_pLbBitmap->set_height_request(aSize.Height());
767 :
768 : // Calculate size of display boxes
769 0 : Size aSize2 = LogicToPixel(Size(110, 42), MAP_APPFONT);
770 0 : m_pCtlBitmapPreview->set_width_request(aSize2.Width());
771 0 : m_pCtlBitmapPreview->set_height_request(aSize2.Height());
772 0 : m_pCtlXRectPreview->set_width_request(aSize2.Width());
773 0 : m_pCtlXRectPreview->set_height_request(aSize2.Height());
774 0 : }
775 :
776 :
777 :
778 0 : void SvxAreaTabPage::Construct()
779 : {
780 : // fill colortables / lists
781 0 : m_pLbColor->Fill( pColorList );
782 0 : m_pLbHatchBckgrdColor->Fill ( pColorList );
783 :
784 0 : m_pLbGradient->Fill( pGradientList );
785 0 : m_pLbHatching->Fill( pHatchingList );
786 0 : m_pLbBitmap->Fill( pBitmapList );
787 0 : }
788 :
789 :
790 :
791 0 : void SvxAreaTabPage::ActivatePage( const SfxItemSet& rSet )
792 : {
793 : sal_Int32 nCount;
794 0 : SFX_ITEMSET_ARG (&rSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,false);
795 0 : SFX_ITEMSET_ARG (&rSet,pPosItem,SfxUInt16Item,SID_TABPAGE_POS,false);
796 0 : if (pPageTypeItem)
797 0 : SetPageType(pPageTypeItem->GetValue());
798 0 : if (pPosItem)
799 0 : SetPos(pPosItem->GetValue());
800 0 : if( nDlgType == 0 ) // area dialog
801 : {
802 0 : *pbAreaTP = sal_True;
803 :
804 0 : if( pColorList.is() )
805 : {
806 0 : sal_Int32 _nPos = 0;
807 :
808 0 : if( *pnBitmapListState )
809 : {
810 0 : if( *pnBitmapListState & CT_CHANGED )
811 0 : pBitmapList = ( (SvxAreaTabDialog*) GetParentDialog() )->GetNewBitmapList();
812 :
813 0 : _nPos = m_pLbBitmap->GetSelectEntryPos();
814 :
815 0 : m_pLbBitmap->Clear();
816 0 : m_pLbBitmap->Fill( pBitmapList );
817 0 : nCount = m_pLbBitmap->GetEntryCount();
818 0 : if( nCount == 0 )
819 : ; // This case should never occur
820 0 : else if( nCount <= _nPos )
821 0 : m_pLbBitmap->SelectEntryPos( 0 );
822 : else
823 0 : m_pLbBitmap->SelectEntryPos( _nPos );
824 0 : ModifyBitmapHdl_Impl( this );
825 : }
826 :
827 0 : if( *pnHatchingListState )
828 : {
829 0 : if( *pnHatchingListState & CT_CHANGED )
830 0 : pHatchingList = ( (SvxAreaTabDialog*) GetParentDialog() )->GetNewHatchingList();
831 :
832 0 : _nPos = m_pLbHatching->GetSelectEntryPos();
833 :
834 0 : m_pLbHatching->Clear();
835 0 : m_pLbHatching->Fill( pHatchingList );
836 0 : nCount = m_pLbHatching->GetEntryCount();
837 0 : if( nCount == 0 )
838 : ; // This case should never occur
839 0 : else if( nCount <= _nPos )
840 0 : m_pLbHatching->SelectEntryPos( 0 );
841 : else
842 0 : m_pLbHatching->SelectEntryPos( _nPos );
843 0 : ModifyHatchingHdl_Impl( this );
844 :
845 0 : ModifyHatchBckgrdColorHdl_Impl( this );
846 : }
847 :
848 0 : if( *pnGradientListState )
849 : {
850 0 : if( *pnGradientListState & CT_CHANGED )
851 0 : pGradientList = ( (SvxAreaTabDialog*) GetParentDialog() )->GetNewGradientList();
852 :
853 0 : _nPos = m_pLbGradient->GetSelectEntryPos();
854 :
855 0 : m_pLbGradient->Clear();
856 0 : m_pLbGradient->Fill( pGradientList );
857 0 : nCount = m_pLbGradient->GetEntryCount();
858 0 : if( nCount == 0 )
859 : ; // This case should never occur
860 0 : else if( nCount <= _nPos )
861 0 : m_pLbGradient->SelectEntryPos( 0 );
862 : else
863 0 : m_pLbGradient->SelectEntryPos( _nPos );
864 0 : ModifyGradientHdl_Impl( this );
865 : }
866 :
867 0 : if( *pnColorListState )
868 : {
869 0 : if( *pnColorListState & CT_CHANGED )
870 0 : pColorList = ( (SvxAreaTabDialog*) GetParentDialog() )->GetNewColorList();
871 : // aLbColor
872 0 : _nPos = m_pLbColor->GetSelectEntryPos();
873 0 : m_pLbColor->Clear();
874 0 : m_pLbColor->Fill( pColorList );
875 0 : nCount = m_pLbColor->GetEntryCount();
876 0 : if( nCount == 0 )
877 : ; // This case should never occur
878 0 : else if( nCount <= _nPos )
879 0 : m_pLbColor->SelectEntryPos( 0 );
880 : else
881 0 : m_pLbColor->SelectEntryPos( _nPos );
882 :
883 0 : ModifyColorHdl_Impl( this );
884 :
885 : // Backgroundcolor of hatch
886 0 : _nPos = m_pLbHatchBckgrdColor->GetSelectEntryPos();
887 0 : m_pLbHatchBckgrdColor->Clear();
888 0 : m_pLbHatchBckgrdColor->Fill( pColorList );
889 0 : nCount = m_pLbHatchBckgrdColor->GetEntryCount();
890 0 : if( nCount == 0 )
891 : ; // This case should never occur
892 0 : else if( nCount <= _nPos )
893 0 : m_pLbHatchBckgrdColor->SelectEntryPos( 0 );
894 : else
895 0 : m_pLbHatchBckgrdColor->SelectEntryPos( _nPos );
896 :
897 0 : ModifyHatchBckgrdColorHdl_Impl( this );
898 : }
899 :
900 : // evaluate if any other Tabpage set another filltype
901 0 : if( m_pTypeLB->GetSelectEntryPos() > XFILL_NONE)
902 : {
903 0 : switch( nPageType )
904 : {
905 : case PT_GRADIENT:
906 0 : m_pTypeLB->SelectEntryPos( XFILL_GRADIENT );
907 0 : m_pLbGradient->SelectEntryPos( _nPos );
908 0 : ClickGradientHdl_Impl();
909 0 : break;
910 :
911 : case PT_HATCH:
912 0 : m_pTypeLB->SelectEntryPos( XFILL_HATCH );
913 0 : m_pLbHatching->SelectEntryPos( _nPos );
914 0 : ClickHatchingHdl_Impl();
915 0 : break;
916 :
917 : case PT_BITMAP:
918 0 : m_pTypeLB->SelectEntryPos( XFILL_BITMAP );
919 0 : m_pLbBitmap->SelectEntryPos( _nPos );
920 0 : ClickBitmapHdl_Impl();
921 0 : break;
922 :
923 : case PT_COLOR:
924 0 : m_pTypeLB->SelectEntryPos( XFILL_SOLID );
925 0 : m_pLbColor->SelectEntryPos( _nPos );
926 0 : m_pLbHatchBckgrdColor->SelectEntryPos( _nPos );
927 0 : ClickColorHdl_Impl();
928 0 : break;
929 : }
930 : }
931 0 : nPageType = PT_AREA;
932 : }
933 : }
934 0 : }
935 :
936 :
937 :
938 0 : int SvxAreaTabPage::DeactivatePage( SfxItemSet* _pSet )
939 : {
940 0 : if( nDlgType == 0 ) // area dialog
941 : {
942 0 : sal_Int32 nPosOrig = nPos;
943 0 : XFillStyle eStyle = (XFillStyle) m_pTypeLB->GetSelectEntryPos();
944 0 : switch( eStyle )
945 : {
946 : case XFILL_GRADIENT:
947 : {
948 0 : nPageType = PT_GRADIENT;
949 0 : nPos = m_pLbGradient->GetSelectEntryPos();
950 0 : if( nPosOrig != nPos )
951 0 : *pnGradientListState |= CT_MODIFIED;
952 : }
953 0 : break;
954 : case XFILL_HATCH:
955 : {
956 0 : nPageType = PT_HATCH;
957 0 : nPos = m_pLbHatching->GetSelectEntryPos();
958 0 : if( nPosOrig != nPos )
959 0 : *pnHatchingListState |= CT_MODIFIED;
960 : }
961 0 : break;
962 : case XFILL_BITMAP:
963 : {
964 0 : nPageType = PT_BITMAP;
965 0 : nPos = m_pLbBitmap->GetSelectEntryPos();
966 0 : if( nPosOrig != nPos )
967 0 : *pnBitmapListState |= CT_MODIFIED;
968 : }
969 0 : break;
970 : case XFILL_SOLID:
971 : {
972 0 : nPageType = PT_COLOR;
973 0 : nPos = m_pLbColor->GetSelectEntryPos();
974 0 : if( nPosOrig != nPos )
975 0 : *pnColorListState |= CT_MODIFIED;
976 : }
977 0 : break;
978 : default: ;//prevent warning
979 : }
980 : }
981 :
982 0 : if( _pSet )
983 0 : FillItemSet( *_pSet );
984 :
985 0 : return( LEAVE_PAGE );
986 : }
987 :
988 :
989 :
990 0 : bool SvxAreaTabPage::FillItemSet( SfxItemSet& rAttrs )
991 : {
992 : sal_Int32 _nPos;
993 0 : sal_Bool bModified = sal_False;
994 :
995 0 : if( nDlgType != 0 || *pbAreaTP )
996 : {
997 0 : const SfxPoolItem* pOld = NULL;
998 0 : XFillStyle eStyle = (XFillStyle) m_pTypeLB->GetSelectEntryPos();
999 0 : XFillStyle eSavedStyle = (XFillStyle) m_pTypeLB->GetSavedValue();
1000 0 : switch( eStyle )
1001 : {
1002 : case XFILL_NONE:
1003 : {
1004 0 : if( eSavedStyle != eStyle )
1005 : {
1006 0 : XFillStyleItem aStyleItem( XFILL_NONE );
1007 0 : pOld = GetOldItem( rAttrs, XATTR_FILLSTYLE );
1008 0 : if ( !pOld || !( *(const XFillStyleItem*)pOld == aStyleItem ) )
1009 : {
1010 0 : rAttrs.Put( aStyleItem );
1011 0 : bModified = sal_True;
1012 0 : }
1013 : }
1014 : }
1015 0 : break;
1016 : case XFILL_SOLID:
1017 : {
1018 0 : _nPos = m_pLbColor->GetSelectEntryPos();
1019 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND &&
1020 0 : _nPos != m_pLbColor->GetSavedValue() )
1021 : {
1022 : XFillColorItem aItem( m_pLbColor->GetSelectEntry(),
1023 0 : m_pLbColor->GetSelectEntryColor() );
1024 0 : pOld = GetOldItem( rAttrs, XATTR_FILLCOLOR );
1025 0 : if ( !pOld || !( *(const XFillColorItem*)pOld == aItem ) )
1026 : {
1027 0 : rAttrs.Put( aItem );
1028 0 : bModified = sal_True;
1029 0 : }
1030 : }
1031 : // NEW
1032 0 : if( (eSavedStyle != eStyle) &&
1033 0 : ( bModified ||
1034 0 : SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLCOLOR ), true ) ) )
1035 : {
1036 0 : XFillStyleItem aStyleItem( XFILL_SOLID );
1037 0 : pOld = GetOldItem( rAttrs, XATTR_FILLSTYLE );
1038 0 : if ( !pOld || !( *(const XFillStyleItem*)pOld == aStyleItem ) )
1039 : {
1040 0 : rAttrs.Put( aStyleItem );
1041 0 : bModified = sal_True;
1042 0 : }
1043 : }
1044 : }
1045 0 : break;
1046 : case XFILL_GRADIENT:
1047 : {
1048 0 : _nPos = m_pLbGradient->GetSelectEntryPos();
1049 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND &&
1050 0 : _nPos != m_pLbGradient->GetSavedValue() )
1051 : {
1052 0 : XGradient aGradient = pGradientList->GetGradient( _nPos )->GetGradient();
1053 0 : OUString aString = m_pLbGradient->GetSelectEntry();
1054 0 : XFillGradientItem aItem( aString, aGradient );
1055 0 : pOld = GetOldItem( rAttrs, XATTR_FILLGRADIENT );
1056 0 : if ( !pOld || !( *(const XFillGradientItem*)pOld == aItem ) )
1057 : {
1058 0 : rAttrs.Put( aItem );
1059 0 : bModified = sal_True;
1060 0 : }
1061 : }
1062 : // NEW
1063 0 : if( (eSavedStyle != eStyle) &&
1064 0 : ( bModified ||
1065 0 : SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLGRADIENT ), true ) ) )
1066 : {
1067 0 : XFillStyleItem aStyleItem( XFILL_GRADIENT );
1068 0 : pOld = GetOldItem( rAttrs, XATTR_FILLSTYLE );
1069 0 : if ( !pOld || !( *(const XFillStyleItem*)pOld == aStyleItem ) )
1070 : {
1071 0 : rAttrs.Put( aStyleItem );
1072 0 : bModified = sal_True;
1073 0 : }
1074 : }
1075 : }
1076 0 : break;
1077 : case XFILL_HATCH:
1078 : {
1079 0 : _nPos = m_pLbHatching->GetSelectEntryPos();
1080 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND &&
1081 0 : _nPos != m_pLbHatching->GetSavedValue() )
1082 : {
1083 0 : XHatch aHatching = pHatchingList->GetHatch( _nPos )->GetHatch();
1084 0 : OUString aString = m_pLbHatching->GetSelectEntry();
1085 0 : XFillHatchItem aItem( aString, aHatching );
1086 0 : pOld = GetOldItem( rAttrs, XATTR_FILLHATCH );
1087 0 : if ( !pOld || !( *(const XFillHatchItem*)pOld == aItem ) )
1088 : {
1089 0 : rAttrs.Put( aItem );
1090 0 : bModified = sal_True;
1091 0 : }
1092 : }
1093 0 : XFillBackgroundItem aItem ( m_pCbxHatchBckgrd->IsChecked() );
1094 0 : rAttrs.Put( aItem );
1095 0 : nPos = m_pLbHatchBckgrdColor->GetSelectEntryPos();
1096 0 : if( nPos != LISTBOX_ENTRY_NOTFOUND &&
1097 0 : nPos != m_pLbHatchBckgrdColor->GetSavedValue() )
1098 : {
1099 : XFillColorItem aFillColorItem( m_pLbHatchBckgrdColor->GetSelectEntry(),
1100 0 : m_pLbHatchBckgrdColor->GetSelectEntryColor() );
1101 0 : pOld = GetOldItem( rAttrs, XATTR_FILLCOLOR );
1102 0 : if ( !pOld || !( *(const XFillColorItem*)pOld == aFillColorItem ) )
1103 : {
1104 0 : rAttrs.Put( aFillColorItem );
1105 0 : bModified = sal_True;
1106 0 : }
1107 : }
1108 : // NEW
1109 0 : if( (eSavedStyle != eStyle) &&
1110 0 : ( bModified ||
1111 0 : SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLHATCH ), true ) ) )
1112 : {
1113 0 : XFillStyleItem aStyleItem( XFILL_HATCH );
1114 0 : pOld = GetOldItem( rAttrs, XATTR_FILLSTYLE );
1115 0 : if ( !pOld || !( *(const XFillStyleItem*)pOld == aStyleItem ) )
1116 : {
1117 0 : rAttrs.Put( aStyleItem );
1118 0 : bModified = sal_True;
1119 0 : }
1120 0 : }
1121 : }
1122 0 : break;
1123 : case XFILL_BITMAP:
1124 : {
1125 : //UUUU
1126 0 : if(mbDirectGraphicSet && GRAPHIC_NONE != maDirectGraphic.GetType())
1127 : {
1128 0 : const XFillBitmapItem aXBmpItem(maDirectName, maDirectGraphic);
1129 0 : rAttrs.Put(XFillStyleItem(XFILL_BITMAP));
1130 0 : rAttrs.Put(aXBmpItem);
1131 0 : bModified = sal_True;
1132 : }
1133 : else
1134 : {
1135 0 : nPos = m_pLbBitmap->GetSelectEntryPos();
1136 0 : if( nPos != LISTBOX_ENTRY_NOTFOUND &&
1137 0 : nPos != m_pLbBitmap->GetSavedValue() )
1138 : {
1139 0 : const XBitmapEntry* pXBitmapEntry = pBitmapList->GetBitmap(nPos);
1140 0 : const OUString aString(m_pLbBitmap->GetSelectEntry());
1141 0 : const XFillBitmapItem aFillBitmapItem(aString, pXBitmapEntry->GetGraphicObject());
1142 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBITMAP );
1143 0 : if ( !pOld || !( *(const XFillBitmapItem*)pOld == aFillBitmapItem ) )
1144 : {
1145 0 : rAttrs.Put( aFillBitmapItem );
1146 0 : bModified = sal_True;
1147 0 : }
1148 : }
1149 : // NEW
1150 0 : if( (eSavedStyle != eStyle) &&
1151 0 : ( bModified ||
1152 0 : SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLBITMAP ), true ) ) )
1153 : {
1154 0 : XFillStyleItem aStyleItem( XFILL_BITMAP );
1155 0 : pOld = GetOldItem( rAttrs, XATTR_FILLSTYLE );
1156 0 : if ( !pOld || !( *(const XFillStyleItem*)pOld == aStyleItem ) )
1157 : {
1158 0 : rAttrs.Put( aStyleItem );
1159 0 : bModified = sal_True;
1160 0 : }
1161 : }
1162 : }
1163 : }
1164 0 : break;
1165 : }
1166 :
1167 : // step size
1168 0 : if( m_pTsbStepCount->IsEnabled() )
1169 : {
1170 0 : sal_uInt16 nValue = 0;
1171 0 : sal_Bool bValueModified = sal_False;
1172 0 : TriState eState = m_pTsbStepCount->GetState();
1173 0 : if( eState == TRISTATE_TRUE )
1174 : {
1175 0 : if( eState != m_pTsbStepCount->GetSavedValue() )
1176 0 : bValueModified = sal_True;
1177 : }
1178 : else
1179 : {
1180 : // condition != Disabled ?
1181 0 : if( !m_pNumFldStepCount->GetText().isEmpty() )
1182 : {
1183 0 : nValue = (sal_uInt16) m_pNumFldStepCount->GetValue();
1184 0 : if( nValue != (sal_uInt16) m_pNumFldStepCount->GetSavedValue().toInt32() )
1185 0 : bValueModified = sal_True;
1186 : }
1187 : }
1188 0 : if( bValueModified )
1189 : {
1190 0 : XGradientStepCountItem aFillBitmapItem( nValue );
1191 0 : pOld = GetOldItem( rAttrs, XATTR_GRADIENTSTEPCOUNT );
1192 0 : if ( !pOld || !( *(const XGradientStepCountItem*)pOld == aFillBitmapItem ) )
1193 : {
1194 0 : rAttrs.Put( aFillBitmapItem );
1195 0 : bModified = sal_True;
1196 0 : }
1197 : }
1198 : }
1199 :
1200 0 : if( m_pTsbTile->IsEnabled() )
1201 : {
1202 0 : TriState eState = m_pTsbTile->GetState();
1203 0 : if( eState != m_pTsbTile->GetSavedValue() )
1204 : {
1205 : XFillBmpTileItem aFillBmpTileItem(
1206 0 : sal::static_int_cast< sal_Bool >( eState ) );
1207 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_TILE );
1208 0 : if ( !pOld || !( *(const XFillBmpTileItem*)pOld == aFillBmpTileItem ) )
1209 : {
1210 0 : rAttrs.Put( aFillBmpTileItem );
1211 0 : bModified = sal_True;
1212 0 : }
1213 : }
1214 : }
1215 :
1216 0 : if( m_pTsbStretch->IsEnabled() )
1217 : {
1218 0 : TriState eState = m_pTsbStretch->GetState();
1219 0 : if( eState != m_pTsbStretch->GetSavedValue() )
1220 : {
1221 : XFillBmpStretchItem aFillBmpStretchItem(
1222 0 : sal::static_int_cast< sal_Bool >( eState ) );
1223 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_STRETCH );
1224 0 : if ( !pOld || !( *(const XFillBmpStretchItem*)pOld == aFillBmpStretchItem ) )
1225 : {
1226 0 : rAttrs.Put( aFillBmpStretchItem );
1227 0 : bModified = sal_True;
1228 0 : }
1229 : }
1230 : }
1231 :
1232 : // Original size (in the UI) is used as follows:
1233 : // Controls are disabled, but have to be set.
1234 : // SizeX = 0; SizeY = 0; Log = sal_True
1235 :
1236 : //aTsbScale
1237 0 : TriState eState = m_pTsbScale->GetState();
1238 0 : if( eState != m_pTsbScale->GetSavedValue() ||
1239 0 : ( !m_pTsbScale->IsEnabled() &&
1240 0 : m_pTsbOriginal->IsEnabled() &&
1241 0 : m_pTsbScale->GetSavedValue() != TRISTATE_TRUE ) )
1242 : {
1243 0 : XFillBmpSizeLogItem* pItem = NULL;
1244 0 : if( m_pTsbScale->IsEnabled() )
1245 0 : pItem = new XFillBmpSizeLogItem( eState == TRISTATE_FALSE );
1246 0 : else if( m_pTsbOriginal->IsEnabled() && m_pTsbOriginal->GetState() == TRISTATE_TRUE )
1247 0 : pItem = new XFillBmpSizeLogItem( true );
1248 :
1249 0 : if( pItem )
1250 : {
1251 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_SIZELOG );
1252 0 : if ( !pOld || !( *(const XFillBmpSizeLogItem*)pOld == *pItem ) )
1253 : {
1254 0 : rAttrs.Put( *pItem );
1255 0 : bModified = sal_True;
1256 : }
1257 0 : delete pItem;
1258 : }
1259 : }
1260 :
1261 : //aMtrFldXSize
1262 0 : OUString aStr = m_pMtrFldXSize->GetText();
1263 : {
1264 0 : XFillBmpSizeXItem* pItem = NULL;
1265 0 : TriState eScaleState = m_pTsbScale->GetState();
1266 :
1267 0 : if( m_pMtrFldXSize->IsEnabled() &&
1268 0 : !aStr.isEmpty() &&
1269 0 : aStr != m_pMtrFldXSize->GetSavedValue() )
1270 : {
1271 0 : if( eScaleState == TRISTATE_FALSE )
1272 0 : pItem = new XFillBmpSizeXItem( GetCoreValue( *m_pMtrFldXSize, ePoolUnit ) );
1273 : else
1274 : {
1275 : // Percentage values are set negatively, so that
1276 : // they aren't scaled; this is considered in the item.
1277 0 : pItem = new XFillBmpSizeXItem( -labs( static_cast<long>(m_pMtrFldXSize->GetValue()) ) );
1278 : }
1279 : }
1280 0 : else if( m_pTsbOriginal->IsEnabled() &&
1281 0 : m_pTsbOriginal->GetState() == TRISTATE_TRUE &&
1282 0 : !m_pMtrFldXSize->GetSavedValue().isEmpty() )
1283 0 : pItem = new XFillBmpSizeXItem( 0 );
1284 :
1285 0 : if( pItem )
1286 : {
1287 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_SIZEX );
1288 0 : if ( !pOld || !( *(const XFillBmpSizeXItem*)pOld == *pItem ) )
1289 : {
1290 0 : rAttrs.Put( *pItem );
1291 0 : bModified = sal_True;
1292 : }
1293 0 : delete pItem;
1294 : }
1295 : }
1296 :
1297 : //aMtrFldYSize
1298 0 : aStr = m_pMtrFldYSize->GetText();
1299 : {
1300 0 : XFillBmpSizeYItem* pItem = NULL;
1301 0 : TriState eScaleState = m_pTsbScale->GetState();
1302 :
1303 0 : if( m_pMtrFldYSize->IsEnabled() &&
1304 0 : !aStr.isEmpty() &&
1305 0 : aStr != m_pMtrFldYSize->GetSavedValue() )
1306 : {
1307 0 : if( eScaleState == TRISTATE_FALSE )
1308 0 : pItem = new XFillBmpSizeYItem( GetCoreValue( *m_pMtrFldYSize, ePoolUnit ) );
1309 : else
1310 : {
1311 : // Percentage values are set negatively, so that
1312 : // they aren't scaled by the MetricItem;
1313 : // this is considered in the item.
1314 0 : pItem = new XFillBmpSizeYItem( -labs( static_cast<long>(m_pMtrFldYSize->GetValue()) ) );
1315 : }
1316 : }
1317 0 : else if( m_pTsbOriginal->IsEnabled() &&
1318 0 : m_pTsbOriginal->GetState() == TRISTATE_TRUE &&
1319 0 : !m_pMtrFldYSize->GetSavedValue().isEmpty() )
1320 0 : pItem = new XFillBmpSizeYItem( 0 );
1321 :
1322 0 : if( pItem )
1323 : {
1324 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_SIZEY );
1325 0 : if ( !pOld || !( *(const XFillBmpSizeYItem*)pOld == *pItem ) )
1326 : {
1327 0 : rAttrs.Put( *pItem );
1328 0 : bModified = sal_True;
1329 : }
1330 0 : delete pItem;
1331 : }
1332 : }
1333 :
1334 : //aRbtRow
1335 : //aRbtColumn
1336 : //aMtrFldOffset
1337 0 : if( m_pMtrFldOffset->IsEnabled() )
1338 : {
1339 0 : OUString aMtrString = m_pMtrFldOffset->GetText();
1340 0 : if( ( !aMtrString.isEmpty() &&
1341 0 : aMtrString != m_pMtrFldOffset->GetSavedValue() ) ||
1342 0 : m_pRbtRow->GetSavedValue() != m_pRbtRow->IsChecked() ||
1343 0 : m_pRbtColumn->GetSavedValue() != m_pRbtColumn->IsChecked() )
1344 : {
1345 0 : if( m_pRbtRow->IsChecked() )
1346 : {
1347 0 : XFillBmpTileOffsetXItem aFillBmpTileOffsetXItem( (sal_uInt16) m_pMtrFldOffset->GetValue() );
1348 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_TILEOFFSETX );
1349 0 : if ( !pOld || !( *(const XFillBmpTileOffsetXItem*)pOld == aFillBmpTileOffsetXItem ) )
1350 : {
1351 0 : rAttrs.Put( aFillBmpTileOffsetXItem );
1352 0 : rAttrs.Put( XFillBmpTileOffsetYItem( 0 ) );
1353 0 : bModified = sal_True;
1354 0 : }
1355 : }
1356 0 : else if( m_pRbtColumn->IsChecked() )
1357 : {
1358 0 : XFillBmpTileOffsetYItem aFillBmpTileOffsetYItem( (sal_uInt16) m_pMtrFldOffset->GetValue() );
1359 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_TILEOFFSETY );
1360 0 : if ( !pOld || !( *(const XFillBmpTileOffsetYItem*)pOld == aFillBmpTileOffsetYItem ) )
1361 : {
1362 0 : rAttrs.Put( aFillBmpTileOffsetYItem );
1363 0 : rAttrs.Put( XFillBmpTileOffsetXItem( 0 ) );
1364 0 : bModified = sal_True;
1365 0 : }
1366 : }
1367 0 : }
1368 : }
1369 :
1370 : //aCtlPosition
1371 0 : if( m_pCtlPosition->IsEnabled() )
1372 : {
1373 0 : sal_Bool bPut = sal_False;
1374 0 : RECT_POINT _eRP = m_pCtlPosition->GetActualRP();
1375 :
1376 0 : if( SFX_ITEM_DONTCARE == rOutAttrs.GetItemState( XATTR_FILLBMP_POS ) )
1377 0 : bPut = sal_True;
1378 : else
1379 : {
1380 0 : RECT_POINT eValue = ( ( const XFillBmpPosItem& ) rOutAttrs.Get( XATTR_FILLBMP_POS ) ).GetValue();
1381 0 : if( eValue != _eRP )
1382 0 : bPut = sal_True;
1383 : }
1384 0 : if( bPut )
1385 : {
1386 0 : XFillBmpPosItem aFillBmpPosItem( _eRP );
1387 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_POS );
1388 0 : if ( !pOld || !( *(const XFillBmpPosItem*)pOld == aFillBmpPosItem ) )
1389 : {
1390 0 : rAttrs.Put( aFillBmpPosItem );
1391 0 : bModified = sal_True;
1392 0 : }
1393 : }
1394 : }
1395 :
1396 : //aMtrFldXOffset
1397 0 : if( m_pMtrFldXOffset->IsEnabled() )
1398 : {
1399 0 : OUString sMtrXOffset = m_pMtrFldXOffset->GetText();
1400 0 : if( !sMtrXOffset.isEmpty() &&
1401 0 : sMtrXOffset != m_pMtrFldXOffset->GetSavedValue() )
1402 : {
1403 0 : XFillBmpPosOffsetXItem aFillBmpPosOffsetXItem( (sal_uInt16) m_pMtrFldXOffset->GetValue() );
1404 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_POSOFFSETX );
1405 0 : if ( !pOld || !( *(const XFillBmpPosOffsetXItem*)pOld == aFillBmpPosOffsetXItem ) )
1406 : {
1407 0 : rAttrs.Put( aFillBmpPosOffsetXItem );
1408 0 : bModified = sal_True;
1409 0 : }
1410 0 : }
1411 : }
1412 :
1413 : //aMtrFldYOffset
1414 0 : if( m_pMtrFldYOffset->IsEnabled() )
1415 : {
1416 0 : OUString sMtrYOffset = m_pMtrFldYOffset->GetText();
1417 0 : if( !sMtrYOffset.isEmpty() &&
1418 0 : sMtrYOffset != m_pMtrFldYOffset->GetSavedValue() )
1419 : {
1420 0 : XFillBmpPosOffsetYItem aFillBmpPosOffsetYItem( (sal_uInt16) m_pMtrFldYOffset->GetValue() );
1421 0 : pOld = GetOldItem( rAttrs, XATTR_FILLBMP_POSOFFSETY );
1422 0 : if ( !pOld || !( *(const XFillBmpPosOffsetYItem*)pOld == aFillBmpPosOffsetYItem ) )
1423 : {
1424 0 : rAttrs.Put( aFillBmpPosOffsetYItem );
1425 0 : bModified = sal_True;
1426 0 : }
1427 0 : }
1428 : }
1429 0 : rAttrs.Put (SfxUInt16Item(SID_PAGE_TYPE,nPageType));
1430 0 : rAttrs.Put (SfxUInt16Item(SID_TABPAGE_POS,nPos));
1431 : }
1432 :
1433 0 : return( bModified );
1434 : }
1435 :
1436 :
1437 :
1438 0 : void SvxAreaTabPage::Reset( const SfxItemSet& rAttrs )
1439 : {
1440 0 : bool isMissingHatching(false);
1441 0 : bool isMissingGradient(false);
1442 0 : bool isMissingBitmap(false);
1443 : XFillStyle eXFS;
1444 0 : if( rAttrs.GetItemState( XATTR_FILLSTYLE ) != SFX_ITEM_DONTCARE )
1445 : {
1446 : eXFS = (XFillStyle) ( ( ( const XFillStyleItem& ) rAttrs.
1447 0 : Get( GetWhich( XATTR_FILLSTYLE ) ) ).GetValue() );
1448 0 : m_pTypeLB->SelectEntryPos( sal::static_int_cast< sal_Int32 >( eXFS ) );
1449 :
1450 0 : if (SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_FILLCOLOR))
1451 : {
1452 : XFillColorItem const& rColorItem(static_cast<const XFillColorItem&>(
1453 0 : rAttrs.Get(XATTR_FILLCOLOR)) );
1454 0 : m_pLbColor->SelectEntry( rColorItem.GetColorValue() );
1455 0 : m_pLbHatchBckgrdColor->SelectEntry( rColorItem.GetColorValue() );
1456 : }
1457 :
1458 0 : if (SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_FILLGRADIENT))
1459 : {
1460 : XFillGradientItem const& rGradientItem(
1461 : static_cast<const XFillGradientItem&>(
1462 0 : rAttrs.Get(XATTR_FILLGRADIENT)) );
1463 0 : OUString const aString( rGradientItem.GetName() );
1464 0 : XGradient const aGradient( rGradientItem.GetGradientValue() );
1465 :
1466 0 : m_pLbGradient->SelectEntryByList(pGradientList, aString, aGradient);
1467 : }
1468 0 : if (!m_pLbGradient->GetSelectEntryCount())
1469 : { // avoid relying on pool default - cannot export that
1470 0 : m_pLbGradient->SelectEntryPos(0); // anything better than nothing
1471 0 : isMissingGradient = true;
1472 : }
1473 :
1474 0 : if (SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_FILLHATCH))
1475 : {
1476 : m_pLbHatching->SelectEntry( static_cast<const XFillHatchItem&>(
1477 0 : rAttrs.Get(XATTR_FILLHATCH)).GetName() );
1478 : }
1479 0 : if (!m_pLbHatching->GetSelectEntryCount())
1480 : { // avoid relying on pool default - cannot export that
1481 0 : m_pLbHatching->SelectEntryPos(0); // anything better than nothing
1482 0 : isMissingHatching = true;
1483 : }
1484 0 : if (SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_FILLBACKGROUND))
1485 : {
1486 : m_pCbxHatchBckgrd->Check( static_cast<const XFillBackgroundItem&>(
1487 0 : rAttrs.Get(XATTR_FILLBACKGROUND)).GetValue() );
1488 : }
1489 :
1490 0 : if (SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_FILLBITMAP))
1491 : {
1492 : XFillBitmapItem const& rBitmapItem(
1493 : static_cast<const XFillBitmapItem&>(
1494 0 : rAttrs.Get(XATTR_FILLBITMAP)));
1495 0 : m_pLbBitmap->SelectEntry(rBitmapItem.GetName());
1496 : }
1497 0 : if (!m_pLbBitmap->GetSelectEntryCount())
1498 : { // avoid relying on pool default - cannot export that
1499 0 : m_pLbBitmap->SelectEntryPos(0); // anything better than nothing
1500 0 : isMissingBitmap = true;
1501 : }
1502 :
1503 0 : switch( eXFS )
1504 : {
1505 : case XFILL_NONE:
1506 0 : ClickInvisibleHdl_Impl();
1507 0 : break;
1508 :
1509 : case XFILL_SOLID:
1510 0 : ClickColorHdl_Impl();
1511 0 : break;
1512 :
1513 : case XFILL_GRADIENT:
1514 0 : ClickGradientHdl_Impl();
1515 0 : break;
1516 :
1517 : case XFILL_HATCH:
1518 0 : ClickHatchingHdl_Impl();
1519 0 : ToggleHatchBckgrdColorHdl_Impl( this );
1520 0 : break;
1521 :
1522 : case XFILL_BITMAP:
1523 : {
1524 0 : ClickBitmapHdl_Impl();
1525 : }
1526 0 : break;
1527 :
1528 : default:
1529 : assert(false);
1530 0 : break;
1531 : }
1532 : }
1533 : else
1534 : {
1535 : // make all LBs not accessible
1536 0 : m_pFillLB->Hide();
1537 :
1538 0 : m_pCtlBitmapPreview->Hide();
1539 0 : m_pLbColor->Disable();
1540 0 : m_pLbColor->Show();
1541 :
1542 : // so that Reset() also works correctly with Back
1543 0 : m_pTypeLB->SetNoSelection();
1544 : }
1545 :
1546 : // step size
1547 0 : if( ( rAttrs.GetItemState( XATTR_GRADIENTSTEPCOUNT ) != SFX_ITEM_DONTCARE ) ||
1548 0 : ( rAttrs.GetItemState( XATTR_FILLSTYLE ) != SFX_ITEM_DONTCARE ) )
1549 : {
1550 0 : m_pTsbStepCount->EnableTriState( false );
1551 0 : sal_uInt16 nValue = ( ( const XGradientStepCountItem& ) rAttrs.Get( XATTR_GRADIENTSTEPCOUNT ) ).GetValue();
1552 0 : if( nValue == 0 )
1553 : {
1554 0 : m_pTsbStepCount->SetState( TRISTATE_TRUE );
1555 0 : m_pNumFldStepCount->SetText( "" );
1556 : }
1557 : else
1558 : {
1559 0 : m_pTsbStepCount->SetState( TRISTATE_FALSE );
1560 0 : m_pNumFldStepCount->SetValue( nValue );
1561 : }
1562 0 : ModifyStepCountHdl_Impl( m_pTsbStepCount );
1563 : }
1564 : else
1565 : {
1566 0 : m_pTsbStepCount->SetState( TRISTATE_INDET );
1567 0 : m_pNumFldStepCount->SetText( "" );
1568 : }
1569 :
1570 : // attributes for the bitmap filling
1571 :
1572 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_TILE ) != SFX_ITEM_DONTCARE )
1573 : {
1574 0 : m_pTsbTile->EnableTriState( false );
1575 :
1576 0 : if( ( ( const XFillBmpTileItem& ) rAttrs.Get( XATTR_FILLBMP_TILE ) ).GetValue() )
1577 0 : m_pTsbTile->SetState( TRISTATE_TRUE );
1578 : else
1579 0 : m_pTsbTile->SetState( TRISTATE_FALSE );
1580 : }
1581 : else
1582 0 : m_pTsbTile->SetState( TRISTATE_INDET );
1583 :
1584 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_STRETCH ) != SFX_ITEM_DONTCARE )
1585 : {
1586 0 : m_pTsbStretch->EnableTriState( false );
1587 :
1588 0 : if( ( ( const XFillBmpStretchItem& ) rAttrs.Get( XATTR_FILLBMP_STRETCH ) ).GetValue() )
1589 0 : m_pTsbStretch->SetState( TRISTATE_TRUE );
1590 : else
1591 0 : m_pTsbStretch->SetState( TRISTATE_FALSE );
1592 : }
1593 : else
1594 0 : m_pTsbStretch->SetState( TRISTATE_INDET );
1595 :
1596 :
1597 : //aTsbScale
1598 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_SIZELOG ) != SFX_ITEM_DONTCARE )
1599 : {
1600 0 : m_pTsbScale->EnableTriState( false );
1601 :
1602 0 : if( ( ( const XFillBmpSizeLogItem& ) rAttrs.Get( XATTR_FILLBMP_SIZELOG ) ).GetValue() )
1603 0 : m_pTsbScale->SetState( TRISTATE_FALSE );
1604 : else
1605 0 : m_pTsbScale->SetState( TRISTATE_TRUE );
1606 :
1607 0 : ClickScaleHdl_Impl( NULL );
1608 : }
1609 : else
1610 0 : m_pTsbScale->SetState( TRISTATE_INDET );
1611 :
1612 :
1613 : // determine status for the original size
1614 0 : TriState eOriginal = TRISTATE_FALSE;
1615 :
1616 : //aMtrFldXSize
1617 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_SIZEX ) != SFX_ITEM_DONTCARE )
1618 : {
1619 0 : sal_Int32 nValue = ( ( const XFillBmpSizeXItem& ) rAttrs.Get( XATTR_FILLBMP_SIZEX ) ).GetValue();
1620 0 : if( m_pTsbScale->GetState() == TRISTATE_TRUE )
1621 : {
1622 : // If there's a percentage value in the item,
1623 : // it is negative because of the MetricItems.
1624 0 : m_pMtrFldXSize->SetValue( labs( nValue ) );
1625 : }
1626 : else
1627 0 : SetMetricValue( *m_pMtrFldXSize, nValue, ePoolUnit );
1628 0 : m_pMtrFldXSize->SaveValue();
1629 :
1630 0 : if( nValue == 0 )
1631 : {
1632 0 : eOriginal = TRISTATE_TRUE;
1633 : // value would be too small otherwise when turning off the original size
1634 : // (performance problem)
1635 0 : m_pMtrFldXSize->SetValue( 100 );
1636 : }
1637 : }
1638 : else
1639 : {
1640 0 : m_pMtrFldXSize->SetText( "" );
1641 0 : m_pMtrFldXSize->SaveValue();
1642 : }
1643 :
1644 : //aMtrFldYSize
1645 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_SIZEY ) != SFX_ITEM_DONTCARE )
1646 : {
1647 0 : sal_Int32 nValue = ( ( const XFillBmpSizeYItem& ) rAttrs.Get( XATTR_FILLBMP_SIZEY ) ).GetValue();
1648 0 : if( m_pTsbScale->GetState() == TRISTATE_TRUE )
1649 : {
1650 : // If there's a percentage value in the item,
1651 : // it is negative because of the MetricItems.
1652 0 : m_pMtrFldYSize->SetValue( labs( nValue ) );
1653 : }
1654 : else
1655 0 : SetMetricValue( *m_pMtrFldYSize, nValue, ePoolUnit );
1656 0 : m_pMtrFldYSize->SaveValue();
1657 :
1658 0 : if( nValue == 0 )
1659 0 : m_pMtrFldYSize->SetValue( 100 ); //s.o.
1660 : else
1661 0 : eOriginal = TRISTATE_FALSE;
1662 : }
1663 : else
1664 : {
1665 0 : m_pMtrFldYSize->SetText( "" );
1666 0 : m_pMtrFldYSize->SaveValue();
1667 0 : eOriginal = TRISTATE_FALSE;
1668 : }
1669 :
1670 : // aTsbOriginal
1671 0 : m_pTsbOriginal->SetState( eOriginal );
1672 :
1673 : // #93372# Setting proper state after changing button
1674 0 : ModifyTileHdl_Impl( NULL );
1675 :
1676 : //aRbtRow
1677 : //aRbtColumn
1678 : //aMtrFldOffset
1679 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_TILEOFFSETX ) != SFX_ITEM_DONTCARE )
1680 : {
1681 0 : sal_uInt16 nValue = ( ( const XFillBmpTileOffsetXItem& ) rAttrs.Get( XATTR_FILLBMP_TILEOFFSETX ) ).GetValue();
1682 0 : if( nValue > 0 )
1683 : {
1684 0 : m_pMtrFldOffset->SetValue( nValue );
1685 0 : m_pRbtRow->Check();
1686 : }
1687 0 : else if( rAttrs.GetItemState( XATTR_FILLBMP_TILEOFFSETY ) != SFX_ITEM_DONTCARE )
1688 : {
1689 0 : nValue = ( ( const XFillBmpTileOffsetYItem& ) rAttrs.Get( XATTR_FILLBMP_TILEOFFSETY ) ).GetValue();
1690 0 : if( nValue > 0 )
1691 : {
1692 0 : m_pMtrFldOffset->SetValue( nValue );
1693 0 : m_pRbtColumn->Check();
1694 : }
1695 : }
1696 : else
1697 0 : m_pMtrFldOffset->SetValue( 0 );
1698 : }
1699 : else
1700 0 : m_pMtrFldOffset->SetText( "" );
1701 :
1702 :
1703 : //aCtlPosition
1704 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_POS ) != SFX_ITEM_DONTCARE )
1705 : {
1706 0 : RECT_POINT eValue = ( ( const XFillBmpPosItem& ) rAttrs.Get( XATTR_FILLBMP_POS ) ).GetValue();
1707 0 : m_pCtlPosition->SetActualRP( eValue );
1708 : }
1709 : else
1710 0 : m_pCtlPosition->Reset();
1711 :
1712 : //aMtrFldXOffset
1713 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_POSOFFSETX ) != SFX_ITEM_DONTCARE )
1714 : {
1715 0 : sal_Int32 nValue = ( ( const XFillBmpPosOffsetXItem& ) rAttrs.Get( XATTR_FILLBMP_POSOFFSETX ) ).GetValue();
1716 0 : m_pMtrFldXOffset->SetValue( nValue );
1717 : }
1718 : else
1719 0 : m_pMtrFldXOffset->SetText( "" );
1720 :
1721 : //aMtrFldYOffset
1722 0 : if( rAttrs.GetItemState( XATTR_FILLBMP_POSOFFSETY ) != SFX_ITEM_DONTCARE )
1723 : {
1724 0 : sal_Int32 nValue = ( ( const XFillBmpPosOffsetYItem& ) rAttrs.Get( XATTR_FILLBMP_POSOFFSETY ) ).GetValue();
1725 0 : m_pMtrFldYOffset->SetValue( nValue );
1726 : }
1727 : else
1728 0 : m_pMtrFldYOffset->SetText( "" );
1729 :
1730 : // not earlier so that tile and stretch are considered
1731 0 : if( m_pTypeLB->GetSelectEntryPos() == XFILL_BITMAP )
1732 0 : ClickBitmapHdl_Impl();
1733 :
1734 0 : m_pTypeLB->SaveValue();
1735 0 : m_pLbColor->SaveValue();
1736 0 : if (!isMissingGradient)
1737 0 : m_pLbGradient->SaveValue();
1738 0 : if (!isMissingHatching)
1739 0 : m_pLbHatching->SaveValue();
1740 0 : m_pLbHatchBckgrdColor->SaveValue();
1741 0 : if (!isMissingBitmap)
1742 0 : m_pLbBitmap->SaveValue();
1743 0 : m_pTsbStepCount->SaveValue();
1744 0 : m_pNumFldStepCount->SaveValue();
1745 0 : m_pTsbTile->SaveValue();
1746 0 : m_pTsbStretch->SaveValue();
1747 0 : m_pTsbScale->SaveValue();
1748 0 : m_pRbtRow->SaveValue();
1749 0 : m_pRbtColumn->SaveValue();
1750 0 : m_pMtrFldOffset->SaveValue();
1751 0 : m_pMtrFldXOffset->SaveValue();
1752 0 : m_pMtrFldYOffset->SaveValue();
1753 0 : }
1754 :
1755 :
1756 :
1757 0 : SfxTabPage* SvxAreaTabPage::Create( Window* pWindow,
1758 : const SfxItemSet& rAttrs )
1759 : {
1760 0 : return( new SvxAreaTabPage( pWindow, rAttrs ) );
1761 : }
1762 :
1763 :
1764 :
1765 0 : sal_uInt16* SvxAreaTabPage::GetRanges()
1766 : {
1767 0 : return( pAreaRanges );
1768 : }
1769 :
1770 :
1771 0 : IMPL_LINK_NOARG(SvxAreaTabPage, SelectDialogTypeHdl_Impl)
1772 : {
1773 0 : switch( (XFillStyle)m_pTypeLB->GetSelectEntryPos() )
1774 : {
1775 0 : case XFILL_NONE: ClickInvisibleHdl_Impl(); break;
1776 0 : case XFILL_SOLID: ClickColorHdl_Impl(); break;
1777 0 : case XFILL_GRADIENT: ClickGradientHdl_Impl(); break;
1778 0 : case XFILL_HATCH: ClickHatchingHdl_Impl(); break;
1779 0 : case XFILL_BITMAP: ClickBitmapHdl_Impl(); break;
1780 : }
1781 :
1782 0 : return 0;
1783 : }
1784 :
1785 0 : void SvxAreaTabPage::ClickInvisibleHdl_Impl()
1786 : {
1787 0 : m_pBxBitmap->Hide();
1788 :
1789 0 : m_pFillLB->Hide();
1790 :
1791 0 : m_pCtlXRectPreview->Hide();
1792 0 : m_pCtlBitmapPreview->Hide();
1793 :
1794 0 : m_pFlStepCount->Hide();
1795 :
1796 : // Controls for Hatch-Background
1797 0 : m_pFlHatchBckgrd->Hide();
1798 :
1799 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
1800 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
1801 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
1802 :
1803 0 : m_pCtlXRectPreview->Invalidate();
1804 0 : m_pCtlBitmapPreview->Invalidate();
1805 0 : }
1806 :
1807 :
1808 :
1809 0 : void SvxAreaTabPage::ClickColorHdl_Impl()
1810 : {
1811 0 : m_pBxBitmap->Hide();
1812 :
1813 0 : m_pFillLB->Show();
1814 0 : m_pLbColor->Enable();
1815 0 : m_pLbColor->Show();
1816 0 : m_pLbGradient->Hide();
1817 0 : m_pLbHatching->Hide();
1818 0 : m_pLbBitmap->Hide();
1819 0 : m_pCtlXRectPreview->Enable();
1820 0 : m_pCtlXRectPreview->Show();
1821 0 : m_pCtlBitmapPreview->Hide();
1822 :
1823 0 : m_pFlStepCount->Hide();
1824 :
1825 : // Controls for Hatch-Background
1826 0 : m_pFlHatchBckgrd->Hide();
1827 :
1828 0 : ModifyColorHdl_Impl( this );
1829 0 : }
1830 :
1831 :
1832 :
1833 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyColorHdl_Impl)
1834 : {
1835 0 : const SfxPoolItem* pPoolItem = NULL;
1836 0 : sal_Int32 _nPos = m_pLbColor->GetSelectEntryPos();
1837 0 : m_pLbHatchBckgrdColor->SelectEntryPos( _nPos );
1838 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND )
1839 : {
1840 0 : rXFSet.Put( XFillStyleItem( XFILL_SOLID ) );
1841 0 : rXFSet.Put( XFillColorItem( OUString(), m_pLbColor->GetSelectEntryColor() ) );
1842 : }
1843 : // NEW
1844 0 : else if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLCOLOR ), true, &pPoolItem ) )
1845 : {
1846 0 : rXFSet.Put( XFillStyleItem( XFILL_SOLID ) );
1847 0 : Color aColor( ( ( const XFillColorItem* ) pPoolItem )->GetColorValue() );
1848 0 : rXFSet.Put( XFillColorItem( OUString(), aColor ) );
1849 : }
1850 : else
1851 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
1852 :
1853 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
1854 0 : m_pCtlXRectPreview->Invalidate();
1855 :
1856 0 : return( 0L );
1857 : }
1858 :
1859 :
1860 0 : void SvxAreaTabPage::ClickGradientHdl_Impl()
1861 : {
1862 0 : m_pBxBitmap->Hide();
1863 :
1864 0 : m_pFillLB->Show();
1865 0 : m_pLbColor->Hide();
1866 0 : m_pLbGradient->Enable();
1867 0 : m_pLbGradient->Show();
1868 0 : m_pLbHatching->Hide();
1869 0 : m_pLbBitmap->Hide();
1870 0 : m_pCtlXRectPreview->Enable();
1871 0 : m_pCtlXRectPreview->Show();
1872 0 : m_pCtlBitmapPreview->Hide();
1873 :
1874 0 : m_pFlStepCount->Enable();
1875 0 : m_pFlStepCount->Show();
1876 0 : m_pTsbStepCount->Enable();
1877 0 : m_pTsbStepCount->Show();
1878 0 : m_pNumFldStepCount->Show();
1879 :
1880 : // Controls for Hatch-Background
1881 0 : m_pFlHatchBckgrd->Hide();
1882 :
1883 0 : ModifyGradientHdl_Impl( this );
1884 0 : ModifyStepCountHdl_Impl( m_pTsbStepCount );
1885 0 : }
1886 :
1887 :
1888 :
1889 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyGradientHdl_Impl)
1890 : {
1891 0 : const SfxPoolItem* pPoolItem = NULL;
1892 0 : sal_Int32 _nPos = m_pLbGradient->GetSelectEntryPos();
1893 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND )
1894 : {
1895 : // fill ItemSet and pass it on to aCtlXRectPreview
1896 0 : XGradientEntry* pEntry = pGradientList->GetGradient( _nPos );
1897 :
1898 0 : rXFSet.Put( XFillStyleItem( XFILL_GRADIENT ) );
1899 0 : rXFSet.Put( XFillGradientItem( OUString(), pEntry->GetGradient() ) );
1900 : }
1901 0 : else if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLGRADIENT ), true, &pPoolItem ) )
1902 : {
1903 0 : rXFSet.Put( XFillStyleItem( XFILL_GRADIENT ) );
1904 0 : rXFSet.Put( XFillGradientItem( OUString(), ( ( const XFillGradientItem* ) pPoolItem )->GetGradientValue() ) );
1905 : }
1906 : else
1907 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
1908 :
1909 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
1910 0 : m_pCtlXRectPreview->Invalidate();
1911 :
1912 0 : return( 0L );
1913 : }
1914 :
1915 :
1916 :
1917 0 : void SvxAreaTabPage::ClickHatchingHdl_Impl()
1918 : {
1919 0 : m_pFillLB->Show();
1920 0 : m_pLbColor->Hide();
1921 0 : m_pLbGradient->Hide();
1922 0 : m_pLbHatching->Enable();
1923 0 : m_pLbHatching->Show();
1924 0 : m_pLbBitmap->Hide();
1925 0 : m_pCtlXRectPreview->Enable();
1926 0 : m_pCtlXRectPreview->Show();
1927 0 : m_pCtlBitmapPreview->Hide();
1928 :
1929 0 : m_pFlStepCount->Hide();
1930 :
1931 0 : m_pBxBitmap->Hide();
1932 :
1933 : // Controls for Hatch-Background
1934 0 : m_pFlHatchBckgrd->Show();
1935 0 : m_pCbxHatchBckgrd->Enable();
1936 0 : m_pLbHatchBckgrdColor->Enable();
1937 :
1938 0 : ModifyHatchingHdl_Impl( this );
1939 0 : ModifyHatchBckgrdColorHdl_Impl( this );
1940 0 : ToggleHatchBckgrdColorHdl_Impl( this );
1941 0 : }
1942 :
1943 :
1944 :
1945 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyHatchingHdl_Impl)
1946 : {
1947 0 : const SfxPoolItem* pPoolItem = NULL;
1948 0 : sal_Int32 _nPos = m_pLbHatching->GetSelectEntryPos();
1949 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND )
1950 : {
1951 : // fill ItemSet and pass it on to aCtlXRectPreview
1952 0 : XHatchEntry* pEntry = pHatchingList->GetHatch( _nPos );
1953 :
1954 0 : rXFSet.Put( XFillStyleItem( XFILL_HATCH ) );
1955 0 : rXFSet.Put( XFillHatchItem( OUString(), pEntry->GetHatch() ) );
1956 : }
1957 0 : else if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLHATCH ), true, &pPoolItem ) )
1958 : {
1959 0 : rXFSet.Put( XFillStyleItem( XFILL_HATCH ) );
1960 0 : rXFSet.Put( XFillHatchItem( OUString(), ( ( const XFillHatchItem* ) pPoolItem )->GetHatchValue() ) );
1961 : }
1962 : else
1963 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
1964 :
1965 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
1966 0 : m_pCtlXRectPreview->Invalidate();
1967 :
1968 0 : return( 0L );
1969 : }
1970 :
1971 :
1972 :
1973 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyHatchBckgrdColorHdl_Impl)
1974 : {
1975 0 : const SfxPoolItem* pPoolItem = NULL;
1976 0 : sal_Int32 _nPos = m_pLbHatchBckgrdColor->GetSelectEntryPos();
1977 0 : m_pLbColor->SelectEntryPos( _nPos );
1978 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND )
1979 : {
1980 0 : rXFSet.Put( XFillColorItem( OUString(), m_pLbHatchBckgrdColor->GetSelectEntryColor() ) );
1981 : }
1982 0 : else if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLCOLOR ), true, &pPoolItem ) )
1983 : {
1984 0 : Color aColor( ( ( const XFillColorItem* ) pPoolItem )->GetColorValue() );
1985 0 : rXFSet.Put( XFillColorItem( OUString(), aColor ) );
1986 : }
1987 : else
1988 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
1989 :
1990 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
1991 0 : m_pCtlXRectPreview->Invalidate();
1992 :
1993 0 : return( 0L );
1994 : }
1995 :
1996 :
1997 :
1998 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ToggleHatchBckgrdColorHdl_Impl)
1999 : {
2000 : // switch on/off backgroundcolor for hatches
2001 0 : m_pLbHatchBckgrdColor->Enable( m_pCbxHatchBckgrd->IsChecked() );
2002 :
2003 0 : XFillBackgroundItem aItem( m_pCbxHatchBckgrd->IsChecked() );
2004 0 : rXFSet.Put ( aItem, XATTR_FILLBACKGROUND );
2005 :
2006 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
2007 0 : m_pCtlXRectPreview->Invalidate();
2008 :
2009 0 : if( m_pLbHatchBckgrdColor->GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND )
2010 : {
2011 0 : if ( SFX_ITEM_SET == rOutAttrs.GetItemState( XATTR_FILLCOLOR ) )//>= SFX_ITEM_DEFAULT )
2012 : {
2013 0 : XFillColorItem aColorItem( (const XFillColorItem&)rOutAttrs.Get( XATTR_FILLCOLOR ) );
2014 0 : m_pLbHatchBckgrdColor->SelectEntry( aColorItem.GetColorValue() );
2015 : }
2016 : }
2017 :
2018 0 : return( 0L );
2019 : }
2020 :
2021 :
2022 :
2023 0 : void SvxAreaTabPage::ClickBitmapHdl_Impl()
2024 : {
2025 0 : m_pFillLB->Show();
2026 0 : m_pLbColor->Hide();
2027 0 : m_pLbGradient->Hide();
2028 0 : m_pLbHatching->Hide();
2029 :
2030 : //UUUU
2031 0 : if(mbOfferImportButton)
2032 : {
2033 0 : m_pBtnImport->Show();
2034 0 : m_pBtnImport->Enable();
2035 : }
2036 : else
2037 : {
2038 0 : m_pBtnImport->Hide();
2039 0 : m_pBtnImport->Disable();
2040 : }
2041 :
2042 0 : m_pLbBitmap->Enable();
2043 0 : m_pLbBitmap->Show();
2044 0 : m_pCtlBitmapPreview->Enable();
2045 0 : m_pCtlBitmapPreview->Show();
2046 0 : m_pCtlXRectPreview->Hide();
2047 :
2048 0 : m_pFlStepCount->Hide();
2049 :
2050 0 : m_pBxTile->Enable();
2051 :
2052 0 : m_pFlSize->Enable();
2053 0 : m_pFlPosition->Enable();
2054 0 : m_pFlOffset->Enable();
2055 :
2056 0 : if (!m_pRbtRow->IsChecked() && !m_pRbtColumn->IsChecked())
2057 0 : m_pRbtRow->Check();
2058 :
2059 : // Controls for Hatch-Background
2060 0 : m_pFlHatchBckgrd->Hide();
2061 :
2062 0 : m_pBxBitmap->Show();
2063 :
2064 0 : ModifyBitmapHdl_Impl( this );
2065 0 : ModifyTileHdl_Impl( m_pTsbOriginal );
2066 0 : }
2067 :
2068 :
2069 :
2070 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyBitmapHdl_Impl)
2071 : {
2072 : //UUUU
2073 0 : mbDirectGraphicSet = false;
2074 0 : maDirectGraphic.Clear();
2075 0 : maDirectName = "";
2076 :
2077 0 : const SfxPoolItem* pPoolItem = NULL;
2078 0 : sal_Int32 _nPos = m_pLbBitmap->GetSelectEntryPos();
2079 0 : if( _nPos != LISTBOX_ENTRY_NOTFOUND )
2080 : {
2081 : // fill ItemSet and pass it on to aCtlXRectPreview
2082 0 : const XBitmapEntry* pEntry = pBitmapList->GetBitmap(_nPos);
2083 :
2084 0 : rXFSet.Put(XFillStyleItem(XFILL_BITMAP));
2085 0 : rXFSet.Put(XFillBitmapItem(OUString(), pEntry->GetGraphicObject()));
2086 : }
2087 0 : else if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLBITMAP ), true, &pPoolItem ) )
2088 : {
2089 0 : rXFSet.Put(XFillStyleItem(XFILL_BITMAP));
2090 0 : rXFSet.Put(XFillBitmapItem(OUString(), ((const XFillBitmapItem*)pPoolItem)->GetGraphicObject()));
2091 : }
2092 : else
2093 0 : rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
2094 :
2095 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
2096 0 : m_pCtlBitmapPreview->Invalidate();
2097 :
2098 0 : return( 0L );
2099 : }
2100 :
2101 :
2102 :
2103 0 : IMPL_LINK( SvxAreaTabPage, ModifyStepCountHdl_Impl, void *, p )
2104 : {
2105 0 : if( p == m_pTsbStepCount )
2106 : {
2107 0 : if( m_pTsbStepCount->GetState() == TRISTATE_FALSE )
2108 : {
2109 0 : if( m_pNumFldStepCount->GetText().isEmpty() )
2110 0 : m_pNumFldStepCount->SetText("64");
2111 :
2112 0 : m_pNumFldStepCount->Enable();
2113 : }
2114 : else
2115 0 : m_pNumFldStepCount->Disable();
2116 : }
2117 :
2118 0 : sal_uInt16 nValue = 0;
2119 0 : if( m_pTsbStepCount->GetState() != TRISTATE_TRUE )
2120 : {
2121 : // condition != Disabled ?
2122 0 : if( !m_pNumFldStepCount->GetText().isEmpty() )
2123 0 : nValue = (sal_uInt16) m_pNumFldStepCount->GetValue();
2124 : }
2125 0 : rXFSet.Put( XGradientStepCountItem( nValue ) );
2126 0 : m_pCtlXRectPreview->SetAttributes( aXFillAttr.GetItemSet() );
2127 0 : m_pCtlXRectPreview->Invalidate();
2128 :
2129 0 : return( 0L );
2130 : }
2131 :
2132 0 : IMPL_LINK_NOARG( SvxAreaTabPage, ClickImportHdl_Impl )
2133 : {
2134 0 : ResMgr& rMgr = CUI_MGR();
2135 0 : SvxOpenGraphicDialog aDlg("Import");
2136 0 : aDlg.EnableLink(false);
2137 :
2138 0 : if(!aDlg.Execute())
2139 : {
2140 0 : EnterWait();
2141 0 : const int nError(aDlg.GetGraphic(maDirectGraphic));
2142 0 : LeaveWait();
2143 :
2144 0 : if(!nError && GRAPHIC_NONE != maDirectGraphic.GetType())
2145 : {
2146 : // extract name from filename
2147 0 : const INetURLObject aURL(aDlg.GetPath());
2148 0 : maDirectName = aURL.GetName().getToken( 0, '.' );
2149 :
2150 : // use loaded graphic
2151 0 : const XFillBitmapItem aXBmpItem(maDirectName, maDirectGraphic);
2152 0 : rXFSet.Put(XFillStyleItem(XFILL_BITMAP));
2153 0 : rXFSet.Put(aXBmpItem);
2154 :
2155 : // trigger state flag for directly loaded graphic
2156 0 : mbDirectGraphicSet = true;
2157 :
2158 : // preview
2159 0 : m_pCtlBitmapPreview->SetAttributes(aXFillAttr.GetItemSet());
2160 0 : m_pCtlBitmapPreview->Invalidate();
2161 : }
2162 : else
2163 : {
2164 : // graphic could not be loaded
2165 0 : ErrorBox(this, WB_OK, OUString(ResId(RID_SVXSTR_READ_DATA_ERROR, rMgr))).Execute();
2166 : }
2167 : }
2168 :
2169 0 : return 0L;
2170 : }
2171 :
2172 : //------------------------------------------------------------------------
2173 :
2174 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ModifyTileHdl_Impl)
2175 : {
2176 0 : TriState eState = m_pTsbTile->GetState();
2177 0 : if( eState == TRISTATE_TRUE )
2178 : {
2179 : // tiled
2180 : // disable stretched for tiled graphic
2181 0 : m_pTsbStretch->Disable();
2182 0 : m_pFlOffset->Enable();
2183 :
2184 : // allow positioning
2185 0 : m_pCtlPosition->Invalidate();
2186 : // allow 'Position" title
2187 0 : m_pFlPosition->Enable();
2188 :
2189 : // allow size definitions
2190 0 : m_pFlSize->Enable();
2191 : }
2192 0 : else if( eState == TRISTATE_FALSE )
2193 : {
2194 : // non-tiled
2195 : // enable stretch selection
2196 0 : m_pTsbStretch->Enable();
2197 : // no need for offsets, only position is supported in non-tiled
2198 0 : m_pFlOffset->Disable();
2199 :
2200 0 : if( m_pTsbStretch->GetState() != TRISTATE_FALSE )
2201 : {
2202 : // non-tiled, stretched
2203 : // no need for positioning
2204 0 : m_pCtlPosition->Invalidate();
2205 : // no need for 'Position" title, all deactivated
2206 0 : m_pFlPosition->Disable();
2207 :
2208 : // no need for size definitions
2209 0 : m_pFlSize->Disable();
2210 : }
2211 : else
2212 : {
2213 : // non-tiled, non-stretched
2214 : // allow positioning
2215 0 : m_pCtlPosition->Enable();
2216 0 : m_pCtlPosition->Invalidate();
2217 : // allow 'Position" title, positioning is active
2218 0 : m_pFlPosition->Enable();
2219 0 : m_pFlSize->Enable();
2220 : }
2221 : }
2222 : else
2223 : {
2224 : // disable all when tiling is undefined
2225 0 : m_pTsbStretch->Disable();
2226 0 : m_pFlOffset->Disable();
2227 :
2228 0 : m_pCtlPosition->Invalidate();
2229 0 : m_pFlPosition->Disable();
2230 :
2231 0 : m_pFlSize->Disable();
2232 : }
2233 :
2234 0 : if( m_pTsbOriginal->GetState() == TRISTATE_TRUE )
2235 : {
2236 0 : m_pMtrFldXSize->SetText( "" );
2237 0 : m_pMtrFldYSize->SetText( "" );
2238 0 : m_pGridX_Y->Disable();
2239 0 : m_pTsbScale->Disable();
2240 : }
2241 : else
2242 : {
2243 0 : m_pMtrFldXSize->SetValue( m_pMtrFldXSize->GetValue() );
2244 0 : m_pMtrFldYSize->SetValue( m_pMtrFldYSize->GetValue() );
2245 : }
2246 :
2247 0 : rXFSet.Put( XFillBmpTileItem( sal::static_int_cast< sal_Bool >( eState ) ) );
2248 :
2249 0 : if( m_pTsbStretch->IsEnabled() )
2250 : rXFSet.Put(
2251 : XFillBmpStretchItem(
2252 0 : sal::static_int_cast< sal_Bool >( m_pTsbStretch->GetState() ) ) );
2253 :
2254 0 : if( m_pTsbScale->IsEnabled() )
2255 0 : rXFSet.Put( XFillBmpSizeLogItem( m_pTsbScale->GetState() == TRISTATE_FALSE ) );
2256 :
2257 0 : if( m_pMtrFldXSize->IsEnabled() )
2258 : {
2259 0 : XFillBmpSizeXItem* pItem = NULL;
2260 0 : TriState eScaleState = m_pTsbScale->GetState();
2261 :
2262 0 : if( eScaleState == TRISTATE_FALSE )
2263 0 : pItem = new XFillBmpSizeXItem( GetCoreValue( *m_pMtrFldXSize, ePoolUnit ) );
2264 : else
2265 0 : pItem = new XFillBmpSizeXItem( -labs( static_cast<long>(m_pMtrFldXSize->GetValue()) ) );
2266 :
2267 0 : rXFSet.Put( *pItem );
2268 :
2269 0 : delete pItem;
2270 : }
2271 0 : else if( m_pTsbOriginal->IsEnabled() && m_pTsbOriginal->GetState() == TRISTATE_TRUE )
2272 : {
2273 : // original size -> size == 0
2274 0 : rXFSet.Put( XFillBmpSizeXItem( 0 ) );
2275 0 : rXFSet.Put( XFillBmpSizeLogItem( true ) );
2276 : }
2277 :
2278 0 : if( m_pMtrFldYSize->IsEnabled() )
2279 : {
2280 0 : XFillBmpSizeYItem* pItem = NULL;
2281 0 : TriState eScaleState = m_pTsbScale->GetState();
2282 :
2283 0 : if( eScaleState == TRISTATE_FALSE )
2284 0 : pItem = new XFillBmpSizeYItem( GetCoreValue( *m_pMtrFldYSize, ePoolUnit ) );
2285 : else
2286 0 : pItem = new XFillBmpSizeYItem( -labs( static_cast<long>(m_pMtrFldYSize->GetValue()) ) );
2287 :
2288 0 : rXFSet.Put( *pItem );
2289 :
2290 0 : delete pItem;
2291 : }
2292 0 : else if( m_pTsbOriginal->IsEnabled() && m_pTsbOriginal->GetState() == TRISTATE_TRUE )
2293 : {
2294 : // original size -> size == 0
2295 0 : rXFSet.Put( XFillBmpSizeYItem( 0 ) );
2296 0 : rXFSet.Put( XFillBmpSizeLogItem( true ) );
2297 : }
2298 :
2299 0 : if( m_pMtrFldOffset->IsEnabled() )
2300 : {
2301 0 : if( m_pRbtRow->IsChecked() )
2302 : {
2303 0 : rXFSet.Put( XFillBmpTileOffsetXItem( (sal_uInt16) m_pMtrFldOffset->GetValue() ) );
2304 0 : rXFSet.Put( XFillBmpTileOffsetYItem( (sal_uInt16) 0 ) );
2305 : }
2306 0 : else if( m_pRbtColumn->IsChecked() )
2307 : {
2308 0 : rXFSet.Put( XFillBmpTileOffsetXItem( (sal_uInt16) 0 ) );
2309 0 : rXFSet.Put( XFillBmpTileOffsetYItem( (sal_uInt16) m_pMtrFldOffset->GetValue() ) );
2310 : }
2311 : }
2312 :
2313 0 : if( m_pCtlPosition->IsEnabled() )
2314 0 : rXFSet.Put( XFillBmpPosItem( m_pCtlPosition->GetActualRP() ) );
2315 :
2316 0 : if( m_pMtrFldXOffset->IsEnabled() )
2317 0 : rXFSet.Put( XFillBmpPosOffsetXItem( (sal_uInt16) m_pMtrFldXOffset->GetValue() ) );
2318 :
2319 0 : if( m_pMtrFldYOffset->IsEnabled() )
2320 0 : rXFSet.Put( XFillBmpPosOffsetYItem( (sal_uInt16) m_pMtrFldYOffset->GetValue() ) );
2321 :
2322 :
2323 0 : m_pCtlBitmapPreview->SetAttributes( aXFillAttr.GetItemSet() );
2324 0 : m_pCtlBitmapPreview->Invalidate();
2325 :
2326 0 : return( 0L );
2327 : }
2328 :
2329 :
2330 :
2331 0 : IMPL_LINK_NOARG(SvxAreaTabPage, ClickScaleHdl_Impl)
2332 : {
2333 0 : if( m_pTsbScale->GetState() == TRISTATE_TRUE )
2334 : {
2335 0 : m_pMtrFldXSize->SetDecimalDigits( 0 );
2336 0 : m_pMtrFldXSize->SetUnit(FUNIT_PERCENT);
2337 0 : m_pMtrFldXSize->SetValue( 100 );
2338 0 : m_pMtrFldXSize->SetMax( 100 );
2339 0 : m_pMtrFldXSize->SetLast( 100 );
2340 :
2341 0 : m_pMtrFldYSize->SetDecimalDigits( 0 );
2342 0 : m_pMtrFldYSize->SetUnit(FUNIT_PERCENT);
2343 0 : m_pMtrFldYSize->SetValue( 100 );
2344 0 : m_pMtrFldYSize->SetMax( 100 );
2345 0 : m_pMtrFldYSize->SetLast( 100 );
2346 : }
2347 : else
2348 : {
2349 0 : m_pMtrFldXSize->SetDecimalDigits( 2 );
2350 0 : m_pMtrFldXSize->SetUnit( eFUnit );
2351 0 : m_pMtrFldXSize->SetValue( 100 );
2352 0 : m_pMtrFldXSize->SetMax( 999900 );
2353 0 : m_pMtrFldXSize->SetLast( 100000 );
2354 :
2355 0 : m_pMtrFldYSize->SetDecimalDigits( 2 );
2356 0 : m_pMtrFldYSize->SetUnit( eFUnit );
2357 0 : m_pMtrFldYSize->SetValue( 100 );
2358 0 : m_pMtrFldYSize->SetMax( 999900 );
2359 0 : m_pMtrFldYSize->SetLast( 100000 );
2360 : }
2361 :
2362 0 : ModifyTileHdl_Impl( NULL );
2363 :
2364 0 : return( 0L );
2365 : }
2366 :
2367 :
2368 :
2369 0 : void SvxAreaTabPage::PointChanged( Window* pWindow, RECT_POINT eRcPt )
2370 : {
2371 0 : eRP = eRcPt;
2372 :
2373 : // alignment of the bitmap fill
2374 0 : ModifyTileHdl_Impl( pWindow );
2375 0 : }
2376 :
2377 0 : void SvxAreaTabPage::PageCreated (SfxAllItemSet aSet)
2378 : {
2379 0 : SFX_ITEMSET_ARG (&aSet,pColorListItem,SvxColorListItem,SID_COLOR_TABLE,false);
2380 0 : SFX_ITEMSET_ARG (&aSet,pGradientListItem,SvxGradientListItem,SID_GRADIENT_LIST,false);
2381 0 : SFX_ITEMSET_ARG (&aSet,pHatchingListItem,SvxHatchListItem,SID_HATCH_LIST,false);
2382 0 : SFX_ITEMSET_ARG (&aSet,pBitmapListItem,SvxBitmapListItem,SID_BITMAP_LIST,false);
2383 0 : SFX_ITEMSET_ARG (&aSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,false);
2384 0 : SFX_ITEMSET_ARG (&aSet,pDlgTypeItem,SfxUInt16Item,SID_DLG_TYPE,false);
2385 0 : SFX_ITEMSET_ARG (&aSet,pPosItem,SfxUInt16Item,SID_TABPAGE_POS,false);
2386 : //UUUU
2387 0 : SFX_ITEMSET_ARG (&aSet, pOfferImportItem, SfxBoolItem, SID_OFFER_IMPORT, false);
2388 :
2389 0 : if (pColorListItem)
2390 0 : SetColorList(pColorListItem->GetColorList());
2391 0 : if (pGradientListItem)
2392 0 : SetGradientList(pGradientListItem->GetGradientList());
2393 0 : if (pHatchingListItem)
2394 0 : SetHatchingList(pHatchingListItem->GetHatchList());
2395 0 : if (pBitmapListItem)
2396 0 : SetBitmapList(pBitmapListItem->GetBitmapList());
2397 0 : if (pPageTypeItem)
2398 0 : SetPageType(pPageTypeItem->GetValue());
2399 0 : if (pDlgTypeItem)
2400 0 : SetDlgType(pDlgTypeItem->GetValue());
2401 0 : if (pPosItem)
2402 0 : SetPos(pPosItem->GetValue());
2403 :
2404 : //UUUU
2405 0 : if(pOfferImportItem)
2406 : {
2407 0 : const bool bNew(pOfferImportItem->GetValue());
2408 :
2409 0 : if(mbOfferImportButton != bNew)
2410 : {
2411 0 : mbOfferImportButton = bNew;
2412 : }
2413 : }
2414 :
2415 0 : Construct();
2416 0 : }
2417 :
2418 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
