LCOV - code coverage report
Current view: top level - cui/source/tabpages - tparea.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1303 0.0 %
Date: 2014-04-14 Functions: 0 66 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10