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