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