LCOV - code coverage report
Current view: top level - libreoffice/cui/source/tabpages - tpshadow.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 282 0.4 %
Date: 2012-12-27 Functions: 2 16 12.5 %
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 <tools/shl.hxx>
      21             : #include <sfx2/app.hxx>
      22             : #include <sfx2/module.hxx>
      23             : #include <svx/dialogs.hrc>
      24             : 
      25             : #define _SVX_TPSHADOW_CXX
      26             : 
      27             : #include "svx/xattr.hxx"
      28             : #include <svx/xpool.hxx>
      29             : #include <cuires.hrc>
      30             : #include "tabarea.hrc"
      31             : #include <svx/svdattr.hxx>
      32             : #include "svx/drawitem.hxx"
      33             : #include "cuitabarea.hxx"
      34             : #include <dialmgr.hxx>
      35             : #include "svx/dlgutil.hxx"
      36             : #include <cuitabline.hxx>
      37             : #include "paragrph.hrc"
      38             : #include <svx/xlineit0.hxx>
      39             : #include <sfx2/request.hxx>
      40             : 
      41             : static sal_uInt16 pShadowRanges[] =
      42             : {
      43             :     SDRATTR_SHADOWCOLOR,
      44             :     SDRATTR_SHADOWTRANSPARENCE,
      45             :     SID_ATTR_FILL_SHADOW,
      46             :     SID_ATTR_FILL_SHADOW,
      47             :     0
      48             : };
      49             : 
      50           0 : SvxShadowTabPage::SvxShadowTabPage( Window* pParent, const SfxItemSet& rInAttrs ) :
      51             : 
      52           0 :     SvxTabPage          ( pParent, CUI_RES( RID_SVXPAGE_SHADOW ), rInAttrs ),
      53             : 
      54           0 :     aFlProp             ( this, CUI_RES( FL_PROP ) ),
      55           0 :     aTsbShowShadow      ( this, CUI_RES( TSB_SHOW_SHADOW ) ),
      56           0 :     aFtPosition         ( this, CUI_RES( FT_POSITION ) ),
      57           0 :     aCtlPosition        ( this, CUI_RES( CTL_POSITION ) ),
      58           0 :     aFtDistance         ( this, CUI_RES( FT_DISTANCE ) ),
      59           0 :     aMtrDistance        ( this, CUI_RES( MTR_FLD_DISTANCE ) ),
      60           0 :     aFtShadowColor      ( this, CUI_RES( FT_SHADOW_COLOR ) ),
      61           0 :     aLbShadowColor      ( this, CUI_RES( LB_SHADOW_COLOR ) ),
      62           0 :     aFtTransparent      ( this, CUI_RES( FT_TRANSPARENT ) ),
      63           0 :     aMtrTransparent      ( this, CUI_RES( MTR_SHADOW_TRANSPARENT ) ),
      64           0 :     aCtlXRectPreview    ( this, CUI_RES( CTL_COLOR_PREVIEW ) ),
      65             :     rOutAttrs           ( rInAttrs ),
      66             :     bDisable            ( sal_False ),
      67           0 :     pXPool              ( (XOutdevItemPool*) rInAttrs.GetPool() ),
      68             :     aXFillAttr          ( pXPool ),
      69           0 :     rXFSet              ( aXFillAttr.GetItemSet() )
      70             : {
      71           0 :     FreeResource();
      72             : 
      73             :     // this page needs ExchangeSupport
      74           0 :     SetExchangeSupport();
      75             : 
      76             :     // adjust metric
      77           0 :     FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs );
      78             : 
      79           0 :     switch ( eFUnit )
      80             :     {
      81             :         case FUNIT_M:
      82             :         case FUNIT_KM:
      83           0 :             eFUnit = FUNIT_MM;
      84           0 :             break;
      85             :         default: ;//prevent warning
      86             :     }
      87           0 :     SetFieldUnit( aMtrDistance, eFUnit );
      88             : 
      89             :     // determine PoolUnit
      90           0 :     SfxItemPool* pPool = rOutAttrs.GetPool();
      91             :     DBG_ASSERT( pPool, "Wo ist der Pool?" );
      92           0 :     ePoolUnit = pPool->GetMetric( SDRATTR_SHADOWXDIST );
      93             : 
      94             :     // setting the output device
      95           0 :     XFillStyle eXFS = XFILL_SOLID;
      96           0 :     if( rOutAttrs.GetItemState( XATTR_FILLSTYLE ) != SFX_ITEM_DONTCARE )
      97             :     {
      98             :         eXFS = (XFillStyle) ( ( ( const XFillStyleItem& ) rOutAttrs.
      99           0 :                                 Get( GetWhich( XATTR_FILLSTYLE ) ) ).GetValue() );
     100           0 :         switch( eXFS )
     101             :         {
     102             :             //case XFILL_NONE: --> NOTHING
     103             : 
     104             :             case XFILL_SOLID:
     105           0 :                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLCOLOR ) )
     106             :                 {
     107             :                     XFillColorItem aColorItem( ( const XFillColorItem& )
     108           0 :                                         rOutAttrs.Get( XATTR_FILLCOLOR ) );
     109           0 :                     rXFSet.Put( aColorItem );
     110             :                 }
     111           0 :             break;
     112             : 
     113             :             case XFILL_GRADIENT:
     114           0 :                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLGRADIENT ) )
     115             :                 {
     116             :                     XFillGradientItem aGradientItem( ( ( const XFillGradientItem& )
     117           0 :                                             rOutAttrs.Get( XATTR_FILLGRADIENT ) ) );
     118           0 :                     rXFSet.Put( aGradientItem );
     119             :                 }
     120           0 :             break;
     121             : 
     122             :             case XFILL_HATCH:
     123           0 :                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLHATCH ) )
     124             :                 {
     125             :                     XFillHatchItem aHatchItem( ( ( const XFillHatchItem& )
     126           0 :                                     rOutAttrs.Get( XATTR_FILLHATCH ) ) );
     127           0 :                     rXFSet.Put( aHatchItem );
     128             :                 }
     129           0 :             break;
     130             : 
     131             :             case XFILL_BITMAP:
     132             :             {
     133           0 :                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLBITMAP ) )
     134             :                 {
     135             :                     XFillBitmapItem aBitmapItem( ( const XFillBitmapItem& )
     136           0 :                                         rOutAttrs.Get( XATTR_FILLBITMAP ) );
     137           0 :                     rXFSet.Put( aBitmapItem );
     138             :                 }
     139             :             }
     140           0 :             break;
     141           0 :             case XFILL_NONE : break;
     142             :         }
     143             :     }
     144             :     else
     145             :     {
     146           0 :         rXFSet.Put( XFillColorItem( String(), COL_LIGHTRED ) );
     147             :     }
     148             : 
     149           0 :     if(XFILL_NONE == eXFS)
     150             :     {
     151             :         // #i96350#
     152             :         // fallback to solid fillmode when no fill mode is provided to have
     153             :         // a reasonable shadow preview. The used color will be a set one or
     154             :         // the default (currently blue8)
     155           0 :         eXFS = XFILL_SOLID;
     156             :     }
     157             : 
     158           0 :     rXFSet.Put( XFillStyleItem( eXFS ) );
     159           0 :     aCtlXRectPreview.SetRectangleAttributes(aXFillAttr.GetItemSet());
     160             :     //aCtlXRectPreview.SetFillAttr( aXFillAttr );
     161             : 
     162           0 :     aTsbShowShadow.SetClickHdl( LINK( this, SvxShadowTabPage, ClickShadowHdl_Impl ) );
     163           0 :     Link aLink = LINK( this, SvxShadowTabPage, ModifyShadowHdl_Impl );
     164           0 :     aLbShadowColor.SetSelectHdl( aLink );
     165           0 :     aMtrTransparent.SetModifyHdl( aLink );
     166           0 :     aMtrDistance.SetModifyHdl( aLink );
     167             : 
     168           0 :     aCtlXRectPreview.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));
     169           0 :     aCtlPosition.SetAccessibleRelationMemberOf( &aFlProp );
     170           0 : }
     171             : 
     172             : // -----------------------------------------------------------------------
     173             : 
     174           0 : void SvxShadowTabPage::Construct()
     175             : {
     176           0 :     aLbShadowColor.Fill( pColorList );
     177             : 
     178           0 :     if( bDisable )
     179             :     {
     180           0 :         aTsbShowShadow.Disable();
     181           0 :         aFtPosition.Disable();
     182           0 :         aCtlPosition.Disable();
     183           0 :         aFtDistance.Disable();
     184           0 :         aMtrDistance.Disable();
     185           0 :         aFtShadowColor.Disable();
     186           0 :         aLbShadowColor.Disable();
     187           0 :         aFtTransparent.Disable();
     188           0 :         aMtrTransparent.Disable();
     189             :     }
     190           0 : }
     191             : 
     192             : // -----------------------------------------------------------------------
     193             : 
     194           0 : void SvxShadowTabPage::ActivatePage( const SfxItemSet& rSet )
     195             : {
     196             :     sal_uInt16 nPos;
     197             :     sal_uInt16 nCount;
     198             : 
     199           0 :     SFX_ITEMSET_ARG (&rSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,sal_False);
     200           0 :     if (pPageTypeItem)
     201           0 :         SetPageType(pPageTypeItem->GetValue());
     202             : 
     203           0 :     if( nDlgType == 0 )
     204             :     {
     205           0 :         if( pColorList.is() )
     206             :         {
     207             :             // ColorList
     208           0 :             if( *pnColorListState & CT_CHANGED ||
     209             :                 *pnColorListState & CT_MODIFIED )
     210             :             {
     211           0 :                 if( *pnColorListState & CT_CHANGED )
     212             :                 {
     213           0 :                     SvxAreaTabDialog* pArea = dynamic_cast< SvxAreaTabDialog* >( GetParentDialog() );
     214           0 :                     if( pArea )
     215             :                     {
     216           0 :                         pColorList = pArea->GetNewColorList();
     217             :                     }
     218             :                     else
     219             :                     {
     220           0 :                         SvxLineTabDialog* pLine = dynamic_cast< SvxLineTabDialog* >( GetParentDialog() );
     221           0 :                         if( pLine )
     222           0 :                             pColorList = pLine->GetNewColorList();
     223             :                     }
     224             :                 }
     225             : 
     226           0 :                 aCtlXRectPreview.SetRectangleAttributes(rSet);
     227             :                 // aLbShadowColor
     228           0 :                 nPos = aLbShadowColor.GetSelectEntryPos();
     229           0 :                 aLbShadowColor.Clear();
     230           0 :                 aLbShadowColor.Fill( pColorList );
     231           0 :                 nCount = aLbShadowColor.GetEntryCount();
     232           0 :                 if( nCount == 0 )
     233             :                     ; // this case should not occur
     234           0 :                 else if( nCount <= nPos )
     235           0 :                     aLbShadowColor.SelectEntryPos( 0 );
     236             :                 else
     237           0 :                     aLbShadowColor.SelectEntryPos( nPos );
     238             : 
     239           0 :                 ModifyShadowHdl_Impl( this );
     240             :             }
     241           0 :             nPageType = PT_SHADOW;
     242             :         }
     243             :     }
     244           0 : }
     245             : 
     246             : // -----------------------------------------------------------------------
     247             : 
     248           0 : int SvxShadowTabPage::DeactivatePage( SfxItemSet* _pSet )
     249             : {
     250           0 :     if( _pSet )
     251           0 :         FillItemSet( *_pSet );
     252             : 
     253           0 :     return( LEAVE_PAGE );
     254             : }
     255             : 
     256             : // -----------------------------------------------------------------------
     257             : 
     258           0 : sal_Bool SvxShadowTabPage::FillItemSet( SfxItemSet& rAttrs )
     259             : {
     260           0 :     const SfxPoolItem*  pOld = NULL;
     261           0 :     sal_Bool                bModified = sal_False;
     262             : 
     263           0 :     if( !bDisable )
     264             :     {
     265           0 :         TriState eState = aTsbShowShadow.GetState();
     266           0 :         if( eState != aTsbShowShadow.GetSavedValue() )
     267             :         {
     268           0 :             SdrShadowItem aItem( sal::static_int_cast< sal_Bool >( eState ) );
     269           0 :             pOld = GetOldItem( rAttrs, SDRATTR_SHADOW );
     270           0 :             if ( !pOld || !( *(const SdrShadowItem*)pOld == aItem ) )
     271             :             {
     272           0 :                 rAttrs.Put( aItem );
     273           0 :                 bModified = sal_True;
     274           0 :             }
     275             :         }
     276             : 
     277             :         // shadow removal
     278             :         // a bit intricate inquiry whether there was something changed,
     279             :         // as the items can't be displayed directly on controls
     280           0 :         sal_Int32 nX = 0L, nY = 0L;
     281           0 :         sal_Int32 nXY = GetCoreValue( aMtrDistance, ePoolUnit );
     282             : 
     283           0 :         switch( aCtlPosition.GetActualRP() )
     284             :         {
     285           0 :             case RP_LT: nX = nY = -nXY;      break;
     286           0 :             case RP_MT: nY = -nXY;           break;
     287           0 :             case RP_RT: nX = nXY; nY = -nXY; break;
     288           0 :             case RP_LM: nX = -nXY;           break;
     289           0 :             case RP_RM: nX = nXY;            break;
     290           0 :             case RP_LB: nX = -nXY; nY = nXY; break;
     291           0 :             case RP_MB: nY = nXY;            break;
     292           0 :             case RP_RB: nX = nY = nXY;       break;
     293           0 :             case RP_MM: break;
     294             :         }
     295             : 
     296             :         // If the values of the shadow distances==SFX_ITEM_DONTCARE and the displayed
     297             :         // string in the respective MetricField=="", then the comparison of the old
     298             :         // and the new distance values would return a wrong result because in such a
     299             :         // case the new distance values would matche the default values of the MetricField !!!!
     300           0 :         if ( !aMtrDistance.IsEmptyFieldValue()                                  ||
     301           0 :              rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE ||
     302           0 :              rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE    )
     303             :         {
     304           0 :             sal_Int32 nOldX = 9876543; // impossible value, so DontCare
     305           0 :             sal_Int32 nOldY = 9876543;
     306           0 :             if( rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE &&
     307           0 :                 rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE )
     308             :             {
     309             :                 nOldX = ( ( const SdrShadowXDistItem& ) rOutAttrs.
     310           0 :                                     Get( SDRATTR_SHADOWXDIST ) ).GetValue();
     311             :                 nOldY = ( ( const SdrShadowYDistItem& ) rOutAttrs.
     312           0 :                                     Get( SDRATTR_SHADOWYDIST ) ).GetValue();
     313             :             }
     314           0 :             SdrShadowXDistItem aXItem( nX );
     315           0 :             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWXDIST );
     316           0 :             if ( nX != nOldX &&
     317           0 :                 ( !pOld || !( *(const SdrShadowXDistItem*)pOld == aXItem ) ) )
     318             :             {
     319           0 :                 rAttrs.Put( aXItem );
     320           0 :                 bModified = sal_True;
     321             :             }
     322           0 :             SdrShadowYDistItem aYItem( nY );
     323           0 :             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWYDIST );
     324           0 :             if ( nY != nOldY &&
     325           0 :                 ( !pOld || !( *(const SdrShadowYDistItem*)pOld == aYItem ) ) )
     326             :             {
     327           0 :                 rAttrs.Put( aYItem );
     328           0 :                 bModified = sal_True;
     329           0 :             }
     330             :         }
     331             : 
     332             :         // ShadowColor
     333           0 :         sal_uInt16 nPos = aLbShadowColor.GetSelectEntryPos();
     334           0 :         if( nPos != LISTBOX_ENTRY_NOTFOUND &&
     335           0 :             nPos != aLbShadowColor.GetSavedValue() )
     336             :         {
     337             :             SdrShadowColorItem aItem( aLbShadowColor.GetSelectEntry(),
     338           0 :                                     aLbShadowColor.GetSelectEntryColor() );
     339           0 :             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWCOLOR );
     340           0 :             if ( !pOld || !( *(const SdrShadowColorItem*)pOld == aItem ) )
     341             :             {
     342           0 :                 rAttrs.Put( aItem );
     343           0 :                 bModified = sal_True;
     344           0 :             }
     345             :         }
     346             : 
     347             :         // transparency
     348           0 :         sal_uInt16 nVal = (sal_uInt16)aMtrTransparent.GetValue();
     349           0 :         if( nVal != (sal_uInt16)aMtrTransparent.GetSavedValue().ToInt32() )
     350             :         {
     351           0 :             SdrShadowTransparenceItem aItem( nVal );
     352           0 :             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWTRANSPARENCE );
     353           0 :             if ( !pOld || !( *(const SdrShadowTransparenceItem*)pOld == aItem ) )
     354             :             {
     355           0 :                 rAttrs.Put( aItem );
     356           0 :                 bModified = sal_True;
     357           0 :             }
     358             :         }
     359             :     }
     360             : 
     361           0 :     rAttrs.Put (CntUInt16Item(SID_PAGE_TYPE,nPageType));
     362             : 
     363           0 :     return( bModified );
     364             : }
     365             : 
     366             : // -----------------------------------------------------------------------
     367             : 
     368           0 : void SvxShadowTabPage::Reset( const SfxItemSet& rAttrs )
     369             : {
     370           0 :     if( !bDisable )
     371             :     {
     372             :         // all objects can have a shadow
     373             :         // at the moment there are only 8 possible positions where a shadow can be set
     374             : 
     375             :         // has a shadow been set?
     376           0 :         if( rAttrs.GetItemState( SDRATTR_SHADOW ) != SFX_ITEM_DONTCARE )
     377             :         {
     378           0 :             aTsbShowShadow.EnableTriState( sal_False );
     379             : 
     380           0 :             if( ( ( const SdrShadowItem& ) rAttrs.Get( SDRATTR_SHADOW ) ).GetValue() )
     381           0 :                 aTsbShowShadow.SetState( STATE_CHECK );
     382             :             else
     383             :             {
     384           0 :                 aTsbShowShadow.SetState( STATE_NOCHECK );
     385             :             }
     386             :         }
     387             :         else
     388           0 :             aTsbShowShadow.SetState( STATE_DONTKNOW );
     389             : 
     390             :         // distance (only 8 possible positions),
     391             :         // so there is only one item evaluated
     392             : 
     393           0 :         if( rAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE &&
     394           0 :             rAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE )
     395             :         {
     396           0 :             sal_Int32 nX = ( ( const SdrShadowXDistItem& ) rAttrs.Get( SDRATTR_SHADOWXDIST ) ).GetValue();
     397           0 :             sal_Int32 nY = ( ( const SdrShadowYDistItem& ) rAttrs.Get( SDRATTR_SHADOWYDIST ) ).GetValue();
     398             : 
     399           0 :             if( nX != 0 )
     400           0 :                 SetMetricValue( aMtrDistance, nX < 0L ? -nX : nX, ePoolUnit );
     401             :             else
     402           0 :                 SetMetricValue( aMtrDistance, nY < 0L ? -nY : nY, ePoolUnit );
     403             : 
     404             :             // setting the shadow control
     405           0 :             if     ( nX <  0L && nY <  0L ) aCtlPosition.SetActualRP( RP_LT );
     406           0 :             else if( nX == 0L && nY <  0L ) aCtlPosition.SetActualRP( RP_MT );
     407           0 :             else if( nX >  0L && nY <  0L ) aCtlPosition.SetActualRP( RP_RT );
     408           0 :             else if( nX <  0L && nY == 0L ) aCtlPosition.SetActualRP( RP_LM );
     409             :             // there's no center point anymore
     410           0 :             else if( nX == 0L && nY == 0L ) aCtlPosition.SetActualRP( RP_RB );
     411           0 :             else if( nX >  0L && nY == 0L ) aCtlPosition.SetActualRP( RP_RM );
     412           0 :             else if( nX <  0L && nY >  0L ) aCtlPosition.SetActualRP( RP_LB );
     413           0 :             else if( nX == 0L && nY >  0L ) aCtlPosition.SetActualRP( RP_MB );
     414           0 :             else if( nX >  0L && nY >  0L ) aCtlPosition.SetActualRP( RP_RB );
     415             :         }
     416             :         else
     417             :         {
     418             :             // determine default-distance
     419           0 :             SfxItemPool* pPool = rOutAttrs.GetPool();
     420           0 :             SdrShadowXDistItem* pXDistItem = (SdrShadowXDistItem*)&pPool->GetDefaultItem (SDRATTR_SHADOWXDIST);
     421           0 :             SdrShadowYDistItem* pYDistItem = (SdrShadowYDistItem*)&pPool->GetDefaultItem (SDRATTR_SHADOWYDIST);
     422           0 :             if (pXDistItem && pYDistItem)
     423             :             {
     424           0 :                 sal_Int32 nX = pXDistItem->GetValue();
     425           0 :                 sal_Int32 nY = pYDistItem->GetValue();
     426           0 :                 if( nX != 0 )
     427           0 :                     SetMetricValue( aMtrDistance, nX < 0L ? -nX : nX, ePoolUnit );
     428             :                 else
     429           0 :                     SetMetricValue( aMtrDistance, nY < 0L ? -nY : nY, ePoolUnit );
     430             :             }
     431             : 
     432             :             // Tristate, e. g. multiple objects have been marked of which some have a shadow and some don't.
     433             :             // The text (which shall be displayed) of the MetricFields is set to "" and serves as an
     434             :             // identification in the method FillItemSet for the fact that the distance value was NOT changed !!!!
     435           0 :             aMtrDistance.SetText( String() );
     436           0 :             aCtlPosition.SetActualRP( RP_MM );
     437             :         }
     438             : 
     439           0 :         if( rAttrs.GetItemState( SDRATTR_SHADOWCOLOR ) != SFX_ITEM_DONTCARE )
     440             :         {
     441           0 :             aLbShadowColor.SelectEntry( ( ( const SdrShadowColorItem& ) rAttrs.Get( SDRATTR_SHADOWCOLOR ) ).GetColorValue() );
     442             :         }
     443             :         else
     444           0 :             aLbShadowColor.SetNoSelection();
     445             : 
     446           0 :         if( rAttrs.GetItemState( SDRATTR_SHADOWTRANSPARENCE ) != SFX_ITEM_DONTCARE )
     447             :         {
     448           0 :             sal_uInt16 nTransp = ( ( const SdrShadowTransparenceItem& ) rAttrs.Get( SDRATTR_SHADOWTRANSPARENCE ) ).GetValue();
     449           0 :             aMtrTransparent.SetValue( nTransp );
     450             :         }
     451             :         else
     452           0 :             aMtrTransparent.SetText( String() );
     453             : 
     454             :         //aCtlPosition
     455           0 :         aMtrDistance.SaveValue();
     456           0 :         aLbShadowColor.SaveValue();
     457           0 :         aTsbShowShadow.SaveValue();
     458             : 
     459             :         // #66832# This field was not saved, but used to determine changes.
     460             :         // Why? Seems to be the error.
     461             :         // It IS the error.
     462           0 :         aMtrTransparent.SaveValue();
     463             : 
     464           0 :         ClickShadowHdl_Impl( NULL );
     465           0 :         ModifyShadowHdl_Impl( NULL );
     466             :     }
     467           0 : }
     468             : 
     469             : // -----------------------------------------------------------------------
     470             : 
     471           0 : SfxTabPage* SvxShadowTabPage::Create( Window* pWindow,
     472             :                 const SfxItemSet& rAttrs )
     473             : {
     474           0 :     return( new SvxShadowTabPage( pWindow, rAttrs ) );
     475             : }
     476             : 
     477             : //------------------------------------------------------------------------
     478             : 
     479           0 : sal_uInt16* SvxShadowTabPage::GetRanges()
     480             : {
     481           0 :     return( pShadowRanges );
     482             : }
     483             : 
     484             : //------------------------------------------------------------------------
     485             : 
     486           0 : IMPL_LINK_NOARG(SvxShadowTabPage, ClickShadowHdl_Impl)
     487             : {
     488           0 :     if( aTsbShowShadow.GetState() == STATE_NOCHECK )
     489             :     {
     490           0 :         aFtPosition.Disable();
     491           0 :         aCtlPosition.Disable();
     492           0 :         aFtDistance.Disable();
     493           0 :         aMtrDistance.Disable();
     494           0 :         aFtShadowColor.Disable();
     495           0 :         aLbShadowColor.Disable();
     496           0 :         aFtTransparent.Disable();
     497           0 :         aMtrTransparent.Disable();
     498             :     }
     499             :     else
     500             :     {
     501           0 :         aFtPosition.Enable();
     502           0 :         aCtlPosition.Enable();
     503           0 :         aFtDistance.Enable();
     504           0 :         aMtrDistance.Enable();
     505           0 :         aFtShadowColor.Enable();
     506           0 :         aLbShadowColor.Enable();
     507           0 :         aFtTransparent.Enable();
     508           0 :         aMtrTransparent.Enable();
     509             :     }
     510           0 :     aCtlPosition.Invalidate();
     511             : 
     512           0 :     ModifyShadowHdl_Impl( NULL );
     513             : 
     514           0 :     return( 0L );
     515             : }
     516             : 
     517             : //------------------------------------------------------------------------
     518             : 
     519           0 : IMPL_LINK_NOARG(SvxShadowTabPage, ModifyShadowHdl_Impl)
     520             : {
     521           0 :     if( aTsbShowShadow.GetState() == STATE_CHECK )
     522           0 :         rXFSet.Put( XFillStyleItem( XFILL_SOLID ) );
     523             :     else
     524           0 :         rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
     525             : 
     526           0 :     sal_uInt16 nPos = aLbShadowColor.GetSelectEntryPos();
     527           0 :     if( nPos != LISTBOX_ENTRY_NOTFOUND )
     528             :     {
     529             :         rXFSet.Put( XFillColorItem( String(),
     530           0 :                         aLbShadowColor.GetSelectEntryColor() ) );
     531             :     }
     532           0 :     sal_uInt16 nVal = (sal_uInt16)aMtrTransparent.GetValue();
     533           0 :     XFillTransparenceItem aItem( nVal );
     534           0 :     rXFSet.Put( XFillTransparenceItem( aItem ) );
     535             : 
     536             :     // shadow removal
     537           0 :     sal_Int32 nX = 0L, nY = 0L;
     538           0 :     sal_Int32 nXY = GetCoreValue( aMtrDistance, ePoolUnit );
     539           0 :     switch( aCtlPosition.GetActualRP() )
     540             :     {
     541           0 :         case RP_LT: nX = nY = -nXY;      break;
     542           0 :         case RP_MT: nY = -nXY;           break;
     543           0 :         case RP_RT: nX = nXY; nY = -nXY; break;
     544           0 :         case RP_LM: nX = -nXY;           break;
     545           0 :         case RP_RM: nX = nXY;            break;
     546           0 :         case RP_LB: nX = -nXY; nY = nXY; break;
     547           0 :         case RP_MB: nY = nXY;            break;
     548           0 :         case RP_RB: nX = nY = nXY;       break;
     549           0 :         case RP_MM: break;
     550             :     }
     551             : 
     552           0 :     aCtlXRectPreview.SetShadowPosition(Point(nX, nY));
     553             : 
     554           0 :     aCtlXRectPreview.SetShadowAttributes(aXFillAttr.GetItemSet());
     555             :     //aCtlXRectPreview.SetFillAttr( aXFillAttr );
     556           0 :     aCtlXRectPreview.Invalidate();
     557             : 
     558           0 :     return( 0L );
     559             : }
     560             : 
     561             : //------------------------------------------------------------------------
     562             : 
     563           0 : void SvxShadowTabPage::PointChanged( Window* pWindow, RECT_POINT eRcPt )
     564             : {
     565           0 :     eRP = eRcPt;
     566             : 
     567             :     // repaint shadow
     568           0 :     ModifyShadowHdl_Impl( pWindow );
     569           0 : }
     570             : 
     571           0 : void SvxShadowTabPage::PageCreated (SfxAllItemSet aSet)
     572             : {
     573           0 :     SFX_ITEMSET_ARG (&aSet,pColorListItem,SvxColorListItem,SID_COLOR_TABLE,sal_False);
     574           0 :     SFX_ITEMSET_ARG (&aSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,sal_False);
     575           0 :     SFX_ITEMSET_ARG (&aSet,pDlgTypeItem,SfxUInt16Item,SID_DLG_TYPE,sal_False);
     576             : 
     577           0 :     if (pColorListItem)
     578           0 :         SetColorList(pColorListItem->GetColorList());
     579           0 :     if (pPageTypeItem)
     580           0 :         SetPageType(pPageTypeItem->GetValue());
     581           0 :     if (pDlgTypeItem)
     582           0 :         SetDlgType(pDlgTypeItem->GetValue());
     583           0 :     Construct();
     584           3 : }
     585             : 
     586             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10