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