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