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