svx/source/cui/tpshadow.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: tpshadow.cxx,v $
  10  * $Revision: 1.20 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #ifdef SVX_DLLIMPLEMENTATION
  35 #undef SVX_DLLIMPLEMENTATION
  36 #endif
  37
  38 // include ---------------------------------------------------------------
  39 #include <tools/shl.hxx>
  40 #include <sfx2/app.hxx>
  41 #include <sfx2/module.hxx>
  42
  43 #define _SVX_TPSHADOW_CXX
  44
  45 #include "xattr.hxx"
  46 #include <svx/xpool.hxx>
  47 #include <svx/dialogs.hrc>
  48 #include "tabarea.hrc"
  49
  50
  51
  52 #include <svx/svdattr.hxx>
  53
  54 #include "drawitem.hxx"
  55 #include "cuitabarea.hxx"
  56 #include <svx/dialmgr.hxx>
  57 #include "dlgutil.hxx"
  58 #include <cuitabline.hxx>
  59
  60 #include <svx/xlineit0.hxx>
  61 #include <sfx2/request.hxx> //add CHINA001
  62
  63 #define DLGWIN this->GetParent()->GetParent()
  64
  65 // static ----------------------------------------------------------------
  66
  67 static USHORT pShadowRanges[] =
  68 {
  69     SDRATTR_SHADOWCOLOR,
  70     SDRATTR_SHADOWTRANSPARENCE,
  71     SID_ATTR_FILL_SHADOW,
  72     SID_ATTR_FILL_SHADOW,
  73     0
  74 };
  75
  76 /*************************************************************************
  77 |*
  78 |*      Dialog zum Aendern des Schattens
  79 |*
  80 \************************************************************************/
  81
  82 SvxShadowTabPage::SvxShadowTabPage( Window* pParent, const SfxItemSet& rInAttrs ) :
  83
  84     SvxTabPage                  ( pParent, SVX_RES( RID_SVXPAGE_SHADOW ), rInAttrs ),
  85
  86     aFlProp             ( this, SVX_RES( FL_PROP ) ),
  87     aTsbShowShadow      ( this, SVX_RES( TSB_SHOW_SHADOW ) ),
  88     aFtPosition         ( this, SVX_RES( FT_POSITION ) ),
  89     aCtlPosition        ( this, SVX_RES( CTL_POSITION ) ),
  90     aFtDistance                 ( this, SVX_RES( FT_DISTANCE ) ),
  91     aMtrDistance                ( this, SVX_RES( MTR_FLD_DISTANCE ) ),
  92     aFtShadowColor              ( this, SVX_RES( FT_SHADOW_COLOR ) ),
  93     aLbShadowColor              ( this, SVX_RES( LB_SHADOW_COLOR ) ),
  94     aFtTransparent      ( this, SVX_RES( FT_TRANSPARENT ) ),
  95     aMtrTransparent      ( this, SVX_RES( MTR_SHADOW_TRANSPARENT ) ),
  96     aCtlXRectPreview    ( this, SVX_RES( CTL_COLOR_PREVIEW ) ),
  97     rOutAttrs                   ( rInAttrs ),
  98     pColorTab( NULL ),
  99     bDisable            ( FALSE ),
 100     pXPool              ( (XOutdevItemPool*) rInAttrs.GetPool() ),
 101     aXFillAttr          ( pXPool ),
 102     rXFSet              ( aXFillAttr.GetItemSet() )
 103 {
 104     FreeResource();
 105
 106     // diese Page braucht ExchangeSupport
 107     SetExchangeSupport();
 108
 109     // Metrik einstellen
 110     FieldUnit eFUnit = GetModuleFieldUnit( &rInAttrs );
 111
 112     switch ( eFUnit )
 113     {
 114         case FUNIT_M:
 115         case FUNIT_KM:
 116             eFUnit = FUNIT_MM;
 117             break;
 118         default: ;//prevent warning
 119     }
 120     SetFieldUnit( aMtrDistance, eFUnit );
 121
 122     // PoolUnit ermitteln
 123     SfxItemPool* pPool = rOutAttrs.GetPool();
 124     DBG_ASSERT( pPool, "Wo ist der Pool?" );
 125     ePoolUnit = pPool->GetMetric( SDRATTR_SHADOWXDIST );
 126
 127     // Setzen des Output-Devices
 128     XFillStyle eXFS = XFILL_SOLID;
 129     if( rOutAttrs.GetItemState( XATTR_FILLSTYLE ) != SFX_ITEM_DONTCARE )
 130     {
 131         eXFS = (XFillStyle) ( ( ( const XFillStyleItem& ) rOutAttrs.
 132                                 Get( GetWhich( XATTR_FILLSTYLE ) ) ).GetValue() );
 133         switch( eXFS )
 134         {
 135             //case XFILL_NONE: --> NICHTS
 136
 137             case XFILL_SOLID:
 138                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLCOLOR ) )
 139                 {
 140                     XFillColorItem aColorItem( ( const XFillColorItem& )
 141                                         rOutAttrs.Get( XATTR_FILLCOLOR ) );
 142                     rXFSet.Put( aColorItem );
 143                 }
 144             break;
 145
 146             case XFILL_GRADIENT:
 147                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLGRADIENT ) )
 148                 {
 149                     XFillGradientItem aGradientItem( ( ( const XFillGradientItem& )
 150                                             rOutAttrs.Get( XATTR_FILLGRADIENT ) ) );
 151                     rXFSet.Put( aGradientItem );
 152                 }
 153             break;
 154
 155             case XFILL_HATCH:
 156                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLHATCH ) )
 157                 {
 158                     XFillHatchItem aHatchItem( ( ( const XFillHatchItem& )
 159                                     rOutAttrs.Get( XATTR_FILLHATCH ) ) );
 160                     rXFSet.Put( aHatchItem );
 161                 }
 162             break;
 163
 164             case XFILL_BITMAP:
 165             {
 166                 if( SFX_ITEM_DONTCARE != rOutAttrs.GetItemState( XATTR_FILLBITMAP ) )
 167                 {
 168                     XFillBitmapItem aBitmapItem( ( const XFillBitmapItem& )
 169                                         rOutAttrs.Get( XATTR_FILLBITMAP ) );
 170                     rXFSet.Put( aBitmapItem );
 171                 }
 172             }
 173             break;
 174             case XFILL_NONE : break;
 175         }
 176     }
 177     else
 178     {
 179         rXFSet.Put( XFillColorItem( String(), COL_LIGHTRED ) );
 180     }
 181
 182     if(XFILL_NONE == eXFS)
 183     {
 184         // #i96350#
 185         // fallback to solid fillmode when no fill mode is provided to have
 186         // a reasonable shadow preview. The used color will be a set one or
 187         // the default (currently blue8)
 188         eXFS = XFILL_SOLID;
 189     }
 190
 191     rXFSet.Put( XFillStyleItem( eXFS ) );
 192     aCtlXRectPreview.SetRectangleAttributes(aXFillAttr.GetItemSet());
 193     //aCtlXRectPreview.SetFillAttr( aXFillAttr );
 194
 195     aTsbShowShadow.SetClickHdl( LINK( this, SvxShadowTabPage, ClickShadowHdl_Impl ) );
 196     Link aLink = LINK( this, SvxShadowTabPage, ModifyShadowHdl_Impl );
 197     aLbShadowColor.SetSelectHdl( aLink );
 198     aMtrTransparent.SetModifyHdl( aLink );
 199     aMtrDistance.SetModifyHdl( aLink );
 200
 201 }
 202
 203 // -----------------------------------------------------------------------
 204
 205 void SvxShadowTabPage::Construct()
 206 {
 207     // Farbtabelle fuellen
 208     aLbShadowColor.Fill( pColorTab );
 209
 210     if( bDisable )
 211     {
 212         aTsbShowShadow.Disable();
 213         aFtPosition.Disable();
 214         aCtlPosition.Disable();
 215         aFtDistance.Disable();
 216         aMtrDistance.Disable();
 217         aFtShadowColor.Disable();
 218         aLbShadowColor.Disable();
 219         aFtTransparent.Disable();
 220         aMtrTransparent.Disable();
 221     }
 222 }
 223
 224 // -----------------------------------------------------------------------
 225
 226 void SvxShadowTabPage::ActivatePage( const SfxItemSet& rSet )
 227 {
 228     USHORT nPos;
 229     USHORT nCount;
 230     //add CHINA001 Begin
 231     SFX_ITEMSET_ARG (&rSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,sal_False);
 232     if (pPageTypeItem)
 233         SetPageType(pPageTypeItem->GetValue());
 234     //add CHINA001 end
 235     if( nDlgType == 0 ) //CHINA001 // Flaechen-Dialogif( *pDlgType == 0 ) // Flaechen-Dialog
 236     {
 237         if( pColorTab )
 238         {
 239             // ColorTable
 240             if( *pnColorTableState & CT_CHANGED ||
 241                 *pnColorTableState & CT_MODIFIED )
 242             {
 243                 if( *pnColorTableState & CT_CHANGED )
 244                 {
 245                     SvxAreaTabDialog* pArea = dynamic_cast< SvxAreaTabDialog* >( DLGWIN );
 246                     if( pArea )
 247                     {
 248                         pColorTab = pArea->GetNewColorTable();
 249                     }
 250                     else
 251                     {
 252                         SvxLineTabDialog* pLine = dynamic_cast< SvxLineTabDialog* >( DLGWIN );
 253                         if( pLine )
 254                             pColorTab = pLine->GetNewColorTable();
 255                     }
 256                 }
 257
 258                 // aLbShadowColor
 259                 nPos = aLbShadowColor.GetSelectEntryPos();
 260                 aLbShadowColor.Clear();
 261                 aLbShadowColor.Fill( pColorTab );
 262                 nCount = aLbShadowColor.GetEntryCount();
 263                 if( nCount == 0 )
 264                     ; // Dieser Fall sollte nicht auftreten
 265                 else if( nCount <= nPos )
 266                     aLbShadowColor.SelectEntryPos( 0 );
 267                 else
 268                     aLbShadowColor.SelectEntryPos( nPos );
 269
 270                 ModifyShadowHdl_Impl( this );
 271             }
 272             nPageType = PT_SHADOW;//CHINA001 *pPageType = PT_SHADOW;
 273         }
 274     }
 275 }
 276
 277 // -----------------------------------------------------------------------
 278
 279 int SvxShadowTabPage::DeactivatePage( SfxItemSet* _pSet )
 280 {
 281     if( _pSet )
 282         FillItemSet( *_pSet );
 283
 284     return( LEAVE_PAGE );
 285 }
 286
 287 // -----------------------------------------------------------------------
 288
 289 BOOL SvxShadowTabPage::FillItemSet( SfxItemSet& rAttrs )
 290 {
 291     const SfxPoolItem*  pOld = NULL;
 292     BOOL                                bModified = FALSE;
 293
 294     if( !bDisable )
 295     {
 296         // Schatten
 297         TriState eState = aTsbShowShadow.GetState();
 298         if( eState != aTsbShowShadow.GetSavedValue() )
 299         {
 300             SdrShadowItem aItem( sal::static_int_cast< BOOL >( eState ) );
 301             pOld = GetOldItem( rAttrs, SDRATTR_SHADOW );
 302             if ( !pOld || !( *(const SdrShadowItem*)pOld == aItem ) )
 303             {
 304                 rAttrs.Put( aItem );
 305                 bModified = TRUE;
 306             }
 307         }
 308
 309         // Schatten-Entfernung
 310         // Etwas umstaendliche Abfrage, ob etwas geaendert wurde,
 311         // da Items nicht direkt auf Controls abbildbar sind
 312         INT32 nX = 0L, nY = 0L;
 313         INT32 nXY = GetCoreValue( aMtrDistance, ePoolUnit );
 314
 315         switch( aCtlPosition.GetActualRP() )
 316         {
 317             case RP_LT: nX = nY = -nXY;          break;
 318             case RP_MT: nY = -nXY;                       break;
 319             case RP_RT: nX = nXY; nY = -nXY; break;
 320             case RP_LM: nX = -nXY;                       break;
 321             case RP_RM: nX = nXY;                        break;
 322             case RP_LB: nX = -nXY; nY = nXY; break;
 323             case RP_MB: nY = nXY;                        break;
 324             case RP_RB: nX = nY = nXY;           break;
 325             case RP_MM: break;
 326         }
 327
 328         // Wenn die Werte des Schattenabstanden==SFX_ITEM_DONTCARE und der angezeigte
 329         // String im entspr. MetricField=="", dann w�rde der Vergleich zw. alten und
 330         // neuen Distance-Werte ein falsches Ergebnis liefern, da in so einem Fall die
 331         // neuen Distance-Werte den Default-Werten des MetricField entspr�chen !!!!
 332         if ( !aMtrDistance.IsEmptyFieldValue()                                  ||
 333              rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE ||
 334              rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE    )
 335         {
 336             INT32 nOldX = 9876543; // Unmoeglicher Wert, entspr. DontCare
 337             INT32 nOldY = 9876543;
 338             if( rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE &&
 339                 rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE )
 340             {
 341                 nOldX = ( ( const SdrShadowXDistItem& ) rOutAttrs.
 342                                     Get( SDRATTR_SHADOWXDIST ) ).GetValue();
 343                 nOldY = ( ( const SdrShadowYDistItem& ) rOutAttrs.
 344                                     Get( SDRATTR_SHADOWYDIST ) ).GetValue();
 345             }
 346             SdrShadowXDistItem aXItem( nX );
 347             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWXDIST );
 348             if ( nX != nOldX &&
 349                 ( !pOld || !( *(const SdrShadowXDistItem*)pOld == aXItem ) ) )
 350             {
 351                 rAttrs.Put( aXItem );
 352                 bModified = TRUE;
 353             }
 354             SdrShadowYDistItem aYItem( nY );
 355             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWYDIST );
 356             if ( nY != nOldY &&
 357                 ( !pOld || !( *(const SdrShadowYDistItem*)pOld == aYItem ) ) )
 358             {
 359                 rAttrs.Put( aYItem );
 360                 bModified = TRUE;
 361             }
 362         }
 363
 364         // ShadowColor
 365         USHORT nPos = aLbShadowColor.GetSelectEntryPos();
 366         if( nPos != LISTBOX_ENTRY_NOTFOUND &&
 367             nPos != aLbShadowColor.GetSavedValue() )
 368         {
 369             SdrShadowColorItem aItem( aLbShadowColor.GetSelectEntry(),
 370                                     aLbShadowColor.GetSelectEntryColor() );
 371             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWCOLOR );
 372             if ( !pOld || !( *(const SdrShadowColorItem*)pOld == aItem ) )
 373             {
 374                 rAttrs.Put( aItem );
 375                 bModified = TRUE;
 376             }
 377         }
 378
 379         // Transparenz
 380         UINT16 nVal = (UINT16)aMtrTransparent.GetValue();
 381         if( nVal != (UINT16)aMtrTransparent.GetSavedValue().ToInt32() )
 382         {
 383             SdrShadowTransparenceItem aItem( nVal );
 384             pOld = GetOldItem( rAttrs, SDRATTR_SHADOWTRANSPARENCE );
 385             if ( !pOld || !( *(const SdrShadowTransparenceItem*)pOld == aItem ) )
 386             {
 387                 rAttrs.Put( aItem );
 388                 bModified = TRUE;
 389             }
 390         }
 391     }
 392     //add CHINA001  begin
 393     rAttrs.Put (CntUInt16Item(SID_PAGE_TYPE,nPageType));
 394     //add CHINA001  end
 395     return( bModified );
 396 }
 397
 398 // -----------------------------------------------------------------------
 399
 400 void SvxShadowTabPage::Reset( const SfxItemSet& rAttrs )
 401 {
 402     if( !bDisable )
 403     {
 404         // Alle Objekte koennen einen Schatten besitzen
 405         // z.Z. gibt es nur 8 m�gliche Positionen den Schatten zu setzen
 406
 407         // Ist Schatten gesetzt?
 408         if( rAttrs.GetItemState( SDRATTR_SHADOW ) != SFX_ITEM_DONTCARE )
 409         {
 410             aTsbShowShadow.EnableTriState( FALSE );
 411
 412             if( ( ( const SdrShadowItem& ) rAttrs.Get( SDRATTR_SHADOW ) ).GetValue() )
 413                 aTsbShowShadow.SetState( STATE_CHECK );
 414             else
 415             {
 416                 aTsbShowShadow.SetState( STATE_NOCHECK );
 417             }
 418         }
 419         else
 420             aTsbShowShadow.SetState( STATE_DONTKNOW );
 421
 422         // Entfernung (nur 8 moegliche Positionen), deshalb
 423         // wird nur ein Item ausgewertet
 424
 425         if( rAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SFX_ITEM_DONTCARE &&
 426             rAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SFX_ITEM_DONTCARE )
 427         {
 428             INT32 nX = ( ( const SdrShadowXDistItem& ) rAttrs.Get( SDRATTR_SHADOWXDIST ) ).GetValue();
 429             INT32 nY = ( ( const SdrShadowYDistItem& ) rAttrs.Get( SDRATTR_SHADOWYDIST ) ).GetValue();
 430
 431             if( nX != 0 )
 432                 SetMetricValue( aMtrDistance, nX < 0L ? -nX : nX, ePoolUnit );
 433             else
 434                 SetMetricValue( aMtrDistance, nY < 0L ? -nY : nY, ePoolUnit );
 435
 436             // Setzen des Schatten-Controls
 437             if     ( nX <  0L && nY <  0L ) aCtlPosition.SetActualRP( RP_LT );
 438             else if( nX == 0L && nY <  0L ) aCtlPosition.SetActualRP( RP_MT );
 439             else if( nX >  0L && nY <  0L ) aCtlPosition.SetActualRP( RP_RT );
 440             else if( nX <  0L && nY == 0L ) aCtlPosition.SetActualRP( RP_LM );
 441             // Mittelpunkt gibt es nicht mehr
 442             else if( nX == 0L && nY == 0L ) aCtlPosition.SetActualRP( RP_RB );
 443             else if( nX >  0L && nY == 0L ) aCtlPosition.SetActualRP( RP_RM );
 444             else if( nX <  0L && nY >  0L ) aCtlPosition.SetActualRP( RP_LB );
 445             else if( nX == 0L && nY >  0L ) aCtlPosition.SetActualRP( RP_MB );
 446             else if( nX >  0L && nY >  0L ) aCtlPosition.SetActualRP( RP_RB );
 447         }
 448         else
 449         {
 450             // determine default-distance
 451             SfxItemPool* pPool = rOutAttrs.GetPool();
 452             SdrShadowXDistItem* pXDistItem = (SdrShadowXDistItem*)&pPool->GetDefaultItem (SDRATTR_SHADOWXDIST);
 453             SdrShadowYDistItem* pYDistItem = (SdrShadowYDistItem*)&pPool->GetDefaultItem (SDRATTR_SHADOWYDIST);
 454             if (pXDistItem && pYDistItem)
 455             {
 456                 INT32 nX = pXDistItem->GetValue();
 457                 INT32 nY = pYDistItem->GetValue();
 458                 if( nX != 0 )
 459                     SetMetricValue( aMtrDistance, nX < 0L ? -nX : nX, ePoolUnit );
 460                 else
 461                     SetMetricValue( aMtrDistance, nY < 0L ? -nY : nY, ePoolUnit );
 462             }
 463
 464             // Tristate, z.B. mehrer Objekte wurden markiert, wovon einige einen Schatten besitzen, einige nicht.
 465             // Der anzuzeigende Text des MetricFields wird auf "" gesetzt und dient in der Methode FillItemSet
 466             // als Erkennungszeichen daf�r, das der Distance-Wert NICHT ver�ndert wurde !!!!
 467             aMtrDistance.SetText( String() );
 468             aCtlPosition.SetActualRP( RP_MM );
 469         }
 470
 471         // SchattenFarbe:
 472         if( rAttrs.GetItemState( SDRATTR_SHADOWCOLOR ) != SFX_ITEM_DONTCARE )
 473         {
 474             aLbShadowColor.SelectEntry( ( ( const SdrShadowColorItem& ) rAttrs.Get( SDRATTR_SHADOWCOLOR ) ).GetColorValue() );
 475         }
 476         else
 477             aLbShadowColor.SetNoSelection();
 478
 479         // Transparenz
 480         if( rAttrs.GetItemState( SDRATTR_SHADOWTRANSPARENCE ) != SFX_ITEM_DONTCARE )
 481         {
 482             USHORT nTransp = ( ( const SdrShadowTransparenceItem& ) rAttrs.Get( SDRATTR_SHADOWTRANSPARENCE ) ).GetValue();
 483             aMtrTransparent.SetValue( nTransp );
 484         }
 485         else
 486             aMtrTransparent.SetText( String() );
 487
 488         // Werte sichern
 489         //aCtlPosition
 490         aMtrDistance.SaveValue();
 491         aLbShadowColor.SaveValue();
 492         aTsbShowShadow.SaveValue();
 493
 494         // #66832# This field was not saved, but used to determine changes.
 495         // Why? Seems to be the error.
 496         // It IS the error.
 497         aMtrTransparent.SaveValue();
 498
 499         ClickShadowHdl_Impl( NULL );
 500         ModifyShadowHdl_Impl( NULL );
 501     }
 502 }
 503
 504 // -----------------------------------------------------------------------
 505
 506 SfxTabPage* SvxShadowTabPage::Create( Window* pWindow,
 507                 const SfxItemSet& rAttrs )
 508 {
 509     return( new SvxShadowTabPage( pWindow, rAttrs ) );
 510 }
 511
 512 //------------------------------------------------------------------------
 513
 514 USHORT* SvxShadowTabPage::GetRanges()
 515 {
 516     return( pShadowRanges );
 517 }
 518
 519 //------------------------------------------------------------------------
 520
 521 IMPL_LINK( SvxShadowTabPage, ClickShadowHdl_Impl, void *, EMPTYARG )
 522 {
 523     if( aTsbShowShadow.GetState() == STATE_NOCHECK )
 524     {
 525         aFtPosition.Disable();
 526         aCtlPosition.Disable();
 527         aFtDistance.Disable();
 528         aMtrDistance.Disable();
 529         aFtShadowColor.Disable();
 530         aLbShadowColor.Disable();
 531         aFtTransparent.Disable();
 532         aMtrTransparent.Disable();
 533     }
 534     else
 535     {
 536         aFtPosition.Enable();
 537         aCtlPosition.Enable();
 538         aFtDistance.Enable();
 539         aMtrDistance.Enable();
 540         aFtShadowColor.Enable();
 541         aLbShadowColor.Enable();
 542         aFtTransparent.Enable();
 543         aMtrTransparent.Enable();
 544     }
 545     aCtlPosition.Invalidate();
 546
 547     ModifyShadowHdl_Impl( NULL );
 548
 549     return( 0L );
 550 }
 551
 552 //------------------------------------------------------------------------
 553
 554 IMPL_LINK( SvxShadowTabPage, ModifyShadowHdl_Impl, void *, EMPTYARG )
 555 {
 556     if( aTsbShowShadow.GetState() == STATE_CHECK )
 557         rXFSet.Put( XFillStyleItem( XFILL_SOLID ) );
 558     else
 559         rXFSet.Put( XFillStyleItem( XFILL_NONE ) );
 560
 561     USHORT nPos = aLbShadowColor.GetSelectEntryPos();
 562     if( nPos != LISTBOX_ENTRY_NOTFOUND )
 563     {
 564         rXFSet.Put( XFillColorItem( String(),
 565                         aLbShadowColor.GetSelectEntryColor() ) );
 566     }
 567     UINT16 nVal = (UINT16)aMtrTransparent.GetValue();
 568     XFillTransparenceItem aItem( nVal );
 569     rXFSet.Put( XFillTransparenceItem( aItem ) );
 570
 571     // Schatten-Entfernung
 572     INT32 nX = 0L, nY = 0L;
 573     INT32 nXY = GetCoreValue( aMtrDistance, ePoolUnit );
 574     switch( aCtlPosition.GetActualRP() )
 575     {
 576         case RP_LT: nX = nY = -nXY;      break;
 577         case RP_MT: nY = -nXY;                   break;
 578         case RP_RT: nX = nXY; nY = -nXY; break;
 579         case RP_LM: nX = -nXY;                   break;
 580         case RP_RM: nX = nXY;                    break;
 581         case RP_LB: nX = -nXY; nY = nXY; break;
 582         case RP_MB: nY = nXY;                    break;
 583         case RP_RB: nX = nY = nXY;               break;
 584         case RP_MM: break;
 585     }
 586
 587     aCtlXRectPreview.SetShadowPosition(Point(nX, nY));
 588
 589     aCtlXRectPreview.SetShadowAttributes(aXFillAttr.GetItemSet());
 590     //aCtlXRectPreview.SetFillAttr( aXFillAttr );
 591     aCtlXRectPreview.Invalidate();
 592
 593     return( 0L );
 594 }
 595
 596 //------------------------------------------------------------------------
 597
 598 void SvxShadowTabPage::PointChanged( Window* pWindow, RECT_POINT eRcPt )
 599 {
 600     eRP = eRcPt;
 601
 602     // Schatten neu zeichnen
 603     ModifyShadowHdl_Impl( pWindow );
 604 }
 605
 606 void SvxShadowTabPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
 607 {
 608     SFX_ITEMSET_ARG (&aSet,pColorTabItem,SvxColorTableItem,SID_COLOR_TABLE,sal_False);
 609     SFX_ITEMSET_ARG (&aSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,sal_False);
 610     SFX_ITEMSET_ARG (&aSet,pDlgTypeItem,SfxUInt16Item,SID_DLG_TYPE,sal_False);
 611
 612
 613     if (pColorTabItem)
 614         SetColorTable(pColorTabItem->GetColorTable());
 615     if (pPageTypeItem)
 616         SetPageType(pPageTypeItem->GetValue());
 617     if (pDlgTypeItem)
 618         SetDlgType(pDlgTypeItem->GetValue());
 619     Construct();
 620 }