svx/source/cui/backgrnd.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: backgrnd.cxx,v $
  10  * $Revision: 1.39 $
  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 <svtools/pathoptions.hxx>
  40 #include <svtools/intitem.hxx>
  41 #include <vcl/msgbox.hxx>
  42 #include <tools/urlobj.hxx>
  43 #include <sfx2/objsh.hxx>
  44 #include <sfx2/docfile.hxx>
  45 #include <svtools/wallitem.hxx>
  46 #include <svtools/cntwall.hxx>
  47 #ifndef _CNTIDS_HRC
  48 #include <sfx2/cntids.hrc>
  49 #endif
  50
  51 #define _SVX_BACKGRND_CXX
  52
  53 #include <svx/dialogs.hrc>
  54 #include "backgrnd.hrc"
  55 #include <svx/svxitems.hrc>
  56
  57
  58
  59
  60 // Tabellenhintergrund
  61 #define TBL_DEST_CELL   0
  62 #define TBL_DEST_ROW    1
  63 #define TBL_DEST_TBL    2
  64
  65 #include <svx/brshitem.hxx>
  66 #include "backgrnd.hxx"
  67
  68 #include <svx/xtable.hxx>
  69 #include "opengrf.hxx"
  70 #include "impgrf.hxx"
  71 #include "svxerr.hxx"
  72 #include "drawitem.hxx"
  73 #include <svx/dialmgr.hxx>
  74 #include "htmlmode.hxx"
  75 #ifndef _SVT_CONTROLDIMS_HRC_
  76 #include <svtools/controldims.hrc>
  77 #endif
  78 #include <svx/svxids.hrc> //CHINA001
  79 #include "flagsdef.hxx" //CHINA001
  80 #include <svtools/intitem.hxx> //CHINA001
  81 #include <sfx2/request.hxx> //CHINA001
  82 using namespace ::com::sun::star;
  83 // static ----------------------------------------------------------------
  84
  85 static USHORT pRanges[] =
  86 {
  87     SID_VIEW_FLD_PIC, SID_VIEW_FLD_PIC,
  88     SID_ATTR_BRUSH, SID_ATTR_BRUSH,
  89     SID_ATTR_BRUSH_CHAR, SID_ATTR_BRUSH_CHAR,
  90     0
  91 };
  92
  93 struct SvxBackgroundTable_Impl
  94 {
  95     SvxBrushItem*       pCellBrush;
  96     SvxBrushItem*       pRowBrush;
  97     SvxBrushItem*       pTableBrush;
  98     USHORT          nCellWhich;
  99     USHORT          nRowWhich;
 100     USHORT          nTableWhich;
 101     USHORT          nActPos;
 102
 103     SvxBackgroundTable_Impl() :
 104         pCellBrush(NULL), pRowBrush(NULL), pTableBrush(NULL),
 105         nCellWhich(0), nRowWhich(0), nTableWhich(0) {}
 106 };
 107
 108 struct SvxBackgroundPara_Impl
 109 {
 110     SvxBrushItem*       pParaBrush;
 111     SvxBrushItem*       pCharBrush;
 112
 113     USHORT                      nActPos;
 114
 115     SvxBackgroundPara_Impl() :
 116         pParaBrush(NULL), pCharBrush(NULL) {}
 117 };
 118
 119 struct SvxBackgroundPage_Impl
 120 {
 121     Timer*          pLoadTimer;
 122     BOOL            bIsImportDlgInExecute;
 123
 124     SvxBackgroundPage_Impl() :
 125         pLoadTimer(NULL), bIsImportDlgInExecute(FALSE) {}
 126 };
 127 /* -----------------------------15.08.2002 12:21------------------------------
 128
 129  ---------------------------------------------------------------------------*/
 130 inline BYTE lcl_PercentToTransparency(long nPercent)
 131 {
 132     //0xff must not be returned!
 133     return BYTE(nPercent ? (50 + 0xfe * nPercent) / 100 : 0);
 134 }
 135 inline BYTE lcl_TransparencyToPercent(BYTE nTrans)
 136 {
 137     return (nTrans * 100 + 127) / 254;
 138 }
 139 void lcl_SetTransparency(SvxBrushItem& rBrush, long nTransparency)
 140 {
 141     uno::Any aTransparency;
 142     aTransparency <<= (sal_Int8)nTransparency;
 143     rBrush.PutValue(aTransparency, MID_GRAPHIC_TRANSPARENCY);
 144 }
 145 //-------------------------------------------------------------------------
 146
 147 /*      [Beschreibung]
 148
 149 */
 150
 151 USHORT GetItemId_Impl( ValueSet& rValueSet, const Color& rCol )
 152 {
 153     BOOL        bFound = FALSE;
 154     USHORT      nCount = rValueSet.GetItemCount();
 155     USHORT      n          = 1;
 156
 157     while ( !bFound && n <= nCount )
 158     {
 159         Color aValCol = rValueSet.GetItemColor(n);
 160
 161         bFound = (   aValCol.GetRed()   == rCol.GetRed()
 162                   && aValCol.GetGreen() == rCol.GetGreen()
 163                   && aValCol.GetBlue()  == rCol.GetBlue() );
 164
 165         if ( !bFound )
 166             n++;
 167     }
 168     return bFound ? n : 0;
 169 }
 170
 171 // class BackgroundPreview -----------------------------------------------
 172
 173 /*      [Beschreibung]
 174
 175     Vorschaufenster f"ur Brush oder Bitmap
 176 */
 177
 178 class BackgroundPreviewImpl : public Window
 179 {
 180 public:
 181     BackgroundPreviewImpl( Window* pParent,
 182                            const ResId& rResId, BOOL bIsBmpPreview );
 183     ~BackgroundPreviewImpl();
 184
 185     void                        NotifyChange( const Color&  rColor );
 186     void                        NotifyChange( const Bitmap* pBitmap );
 187
 188 protected:
 189     virtual void        Paint( const Rectangle& rRect );
 190     virtual void    DataChanged( const DataChangedEvent& rDCEvt );
 191
 192 private:
 193     const BOOL          bIsBmp;
 194     Bitmap*                     pBitmap;
 195     Point                       aDrawPos;
 196     Size                        aDrawSize;
 197     Rectangle           aDrawRect;
 198     BYTE            nTransparency;
 199 };
 200
 201 //-----------------------------------------------------------------------
 202
 203 BackgroundPreviewImpl::BackgroundPreviewImpl
 204 (
 205     Window* pParent,
 206     const ResId& rResId,
 207     BOOL bIsBmpPreview
 208 ) :
 209
 210 /*      [Beschreibung]
 211
 212 */
 213
 214     Window( pParent, rResId ),
 215
 216     bIsBmp       ( bIsBmpPreview ),
 217     pBitmap      ( NULL ),
 218     aDrawRect( Point(0,0), GetOutputSizePixel() ),
 219     nTransparency(0)
 220
 221 {
 222     SetBorderStyle(WINDOW_BORDER_MONO);
 223     Paint( aDrawRect );
 224 }
 225
 226 //-----------------------------------------------------------------------
 227
 228 BackgroundPreviewImpl::~BackgroundPreviewImpl()
 229
 230 /*      [Beschreibung]
 231
 232 */
 233
 234 {
 235     delete pBitmap;
 236 }
 237
 238 //-----------------------------------------------------------------------
 239 void BackgroundPreviewImpl::NotifyChange( const Color& rColor )
 240 {
 241     if ( !bIsBmp )
 242     {
 243         const static Color aTranspCol( COL_TRANSPARENT );
 244
 245         nTransparency = lcl_TransparencyToPercent( rColor.GetTransparency() );
 246
 247         SetFillColor( rColor == aTranspCol ? GetSettings().GetStyleSettings().GetFieldColor() : (Color) rColor.GetRGBColor() );
 248         Paint( aDrawRect );
 249     }
 250 }
 251
 252 //-----------------------------------------------------------------------
 253
 254 void BackgroundPreviewImpl::NotifyChange( const Bitmap* pNewBitmap )
 255 /*      [Beschreibung]
 256
 257 */
 258
 259 {
 260     if ( bIsBmp && (pNewBitmap || pBitmap) )
 261     {
 262         if ( pNewBitmap && pBitmap )
 263             *pBitmap = *pNewBitmap;
 264         else if ( pNewBitmap && !pBitmap )
 265             pBitmap = new Bitmap( *pNewBitmap );
 266         else if ( !pNewBitmap )
 267             DELETEZ( pBitmap );
 268
 269         if ( pBitmap )
 270         {
 271             Size aSize = GetOutputSizePixel();
 272             // InnerSize == Size without one pixel border
 273             Size aInnerSize = aSize;
 274             aInnerSize.Width() -= 2;
 275             aInnerSize.Height() -= 2;
 276             aDrawSize = pBitmap->GetSizePixel();
 277
 278             // bitmap bigger than preview window?
 279             if ( aDrawSize.Width() > aInnerSize.Width() )
 280             {
 281                 aDrawSize.Height() = aDrawSize.Height() * aInnerSize.Width() / aDrawSize.Width();
 282                 if ( aDrawSize.Height() > aInnerSize.Height() )
 283                 {
 284                     aDrawSize.Width() = aDrawSize.Height();
 285                     aDrawSize.Height() = aInnerSize.Height();
 286                 }
 287                 else
 288                     aDrawSize.Width() = aInnerSize.Width();
 289             }
 290             else if ( aDrawSize.Height() > aInnerSize.Height() )
 291             {
 292                 aDrawSize.Width() = aDrawSize.Width() * aInnerSize.Height() / aDrawSize.Height();
 293                 if ( aDrawSize.Width() > aInnerSize.Width() )
 294                 {
 295                     aDrawSize.Height() = aDrawSize.Width();
 296                     aDrawSize.Width() = aInnerSize.Width();
 297                 }
 298                 else
 299                     aDrawSize.Height() = aInnerSize.Height();
 300             }
 301
 302             aDrawPos.X() = (aSize.Width()  - aDrawSize.Width())  / 2;
 303             aDrawPos.Y() = (aSize.Height() - aDrawSize.Height()) / 2;
 304         }
 305         Invalidate( aDrawRect );
 306         Update();
 307     }
 308 }
 309
 310 //-----------------------------------------------------------------------
 311
 312 void BackgroundPreviewImpl::Paint( const Rectangle& )
 313 {
 314     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 315     SetBackground(Wallpaper(rStyleSettings.GetWindowColor()));
 316     SetLineColor();
 317     if(bIsBmp)
 318         SetFillColor( Color(COL_TRANSPARENT) );
 319     DrawRect( aDrawRect );
 320     if ( bIsBmp )
 321     {
 322         if ( pBitmap )
 323             DrawBitmap( aDrawPos, aDrawSize, *pBitmap );
 324         else
 325         {
 326             Size aSize = GetOutputSizePixel();
 327             DrawLine( Point(0,0),               Point(aSize.Width(),aSize.Height()) );
 328             DrawLine( Point(0,aSize.Height()),  Point(aSize.Width(),0) );
 329         }
 330     }
 331 }
 332 /* -----------------------------27.02.2002 11:07------------------------------
 333
 334  ---------------------------------------------------------------------------*/
 335 void BackgroundPreviewImpl::DataChanged( const DataChangedEvent& rDCEvt )
 336 {
 337     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 338          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 339     {
 340         Invalidate();
 341     }
 342     Window::DataChanged( rDCEvt );
 343 }
 344
 345 // class SvxBackgroundTabPage --------------------------------------------
 346
 347 #define HDL(hdl) LINK(this,SvxBackgroundTabPage,hdl)
 348
 349 SvxBackgroundTabPage::SvxBackgroundTabPage( Window* pParent,
 350                                             const SfxItemSet& rCoreSet ) :
 351
 352 /*      [Beschreibung]
 353
 354 */
 355
 356     SvxTabPage( pParent, SVX_RES( RID_SVXPAGE_BACKGROUND ), rCoreSet ),
 357
 358     aBorderWin                  ( this, SVX_RES(CT_BORDER) ),
 359     aBackgroundColorSet ( &aBorderWin, SVX_RES( SET_BGDCOLOR ) ),
 360     aBackgroundColorBox ( this, SVX_RES( GB_BGDCOLOR ) ),
 361     pPreviewWin1        ( new BackgroundPreviewImpl(
 362                             this, SVX_RES( WIN_PREVIEW1 ), FALSE ) ),
 363     aColTransFT         ( this, SVX_RES( FT_COL_TRANS ) ),
 364     aColTransMF         ( this, SVX_RES( MF_COL_TRANS ) ),
 365     aBtnBrowse          ( this, SVX_RES( BTN_BROWSE ) ),
 366     aBtnLink            ( this, SVX_RES( BTN_LINK ) ),
 367     aBtnPreview         ( this, SVX_RES( BTN_PREVIEW ) ),
 368     aFtFile                     ( this, SVX_RES( FT_FILE ) ),
 369     aGbFile                     ( this, SVX_RES( GB_FILE ) ),
 370     aBtnPosition        ( this, SVX_RES( BTN_POSITION ) ),
 371     aBtnArea            ( this, SVX_RES( BTN_AREA ) ),
 372     aBtnTile            ( this, SVX_RES( BTN_TILE ) ),
 373     aWndPosition                ( this, SVX_RES( WND_POSITION ), RP_MM ),
 374     aGbPosition                 ( this, SVX_RES( GB_POSITION ) ),
 375     aGraphTransFL       ( this, SVX_RES( FL_GRAPH_TRANS ) ),
 376     aGraphTransMF       ( this, SVX_RES( MF_GRAPH_TRANS ) ),
 377     pPreviewWin2        ( new BackgroundPreviewImpl(
 378                             this, SVX_RES( WIN_PREVIEW2 ), TRUE ) ),
 379     aSelectTxt                  ( this, SVX_RES( FT_SELECTOR ) ),
 380     aLbSelect                   ( this, SVX_RES( LB_SELECTOR ) ),
 381     aStrBrowse          ( SVX_RES( STR_BROWSE ) ),
 382     aStrUnlinked        ( SVX_RES( STR_UNLINKED ) ),
 383     aTblDesc            ( this, SVX_RES( FT_TBL_DESC ) ),
 384     aTblLBox            ( this, SVX_RES( LB_TBL_BOX ) ),
 385     aParaLBox           ( this, SVX_RES( LB_PARA_BOX ) ),
 386     nHtmlMode           ( 0 ),
 387     bAllowShowSelector  ( TRUE ),
 388     bIsGraphicValid             ( FALSE ),
 389     bLinkOnly                   ( FALSE ),
 390     bResized            ( FALSE ),
 391     bColTransparency    ( FALSE ),
 392     bGraphTransparency  ( FALSE ),
 393
 394     pPageImpl           ( new SvxBackgroundPage_Impl ),
 395     pImportDlg                  ( NULL ),
 396     pTableBck_Impl              ( NULL ),
 397     pParaBck_Impl       ( NULL )
 398
 399 {
 400     // diese Page braucht ExchangeSupport
 401     SetExchangeSupport();
 402
 403     const SfxPoolItem* pItem;
 404     SfxObjectShell* pShell;
 405
 406     if ( SFX_ITEM_SET == rCoreSet.GetItemState( SID_HTML_MODE, FALSE, &pItem )
 407          || ( 0 != ( pShell = SfxObjectShell::Current()) &&
 408               0 != ( pItem = pShell->GetItem( SID_HTML_MODE ) ) ) )
 409     {
 410         nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
 411     }
 412
 413     FillColorValueSets_Impl();
 414
 415     aBackgroundColorSet.SetSelectHdl( HDL(BackgroundColorHdl_Impl) );
 416     FreeResource();
 417 }
 418
 419 //------------------------------------------------------------------------
 420
 421 SvxBackgroundTabPage::~SvxBackgroundTabPage()
 422
 423 /*      [Beschreibung]
 424
 425 */
 426
 427 {
 428     delete pPreviewWin1;
 429     delete pPreviewWin2;
 430     delete pPageImpl->pLoadTimer;
 431     delete pPageImpl;
 432     delete pImportDlg;
 433
 434     if( pTableBck_Impl)
 435     {
 436         delete pTableBck_Impl->pCellBrush;
 437         delete pTableBck_Impl->pRowBrush;
 438         delete pTableBck_Impl->pTableBrush;
 439         delete pTableBck_Impl;
 440     }
 441
 442     if(pParaBck_Impl)
 443     {
 444         delete pParaBck_Impl->pParaBrush;
 445         delete pParaBck_Impl->pCharBrush;
 446         delete pParaBck_Impl;
 447     }
 448 }
 449
 450 //------------------------------------------------------------------------
 451
 452 USHORT* SvxBackgroundTabPage::GetRanges()
 453
 454 /*      [Beschreibung]
 455
 456     gibt den Bereich der Which-Werte zur"uck
 457 */
 458
 459 {
 460     return pRanges;
 461 }
 462
 463 //------------------------------------------------------------------------
 464
 465 SfxTabPage* SvxBackgroundTabPage::Create( Window* pParent,
 466                                           const SfxItemSet& rAttrSet )
 467
 468 /*      [Beschreibung]
 469
 470     Create-Methode f"ur den TabDialog
 471 */
 472
 473 {
 474     return ( new SvxBackgroundTabPage( pParent, rAttrSet ) );
 475 }
 476
 477 //------------------------------------------------------------------------
 478
 479 void SvxBackgroundTabPage::Reset( const SfxItemSet& rSet )
 480
 481 /*      [Beschreibung]
 482
 483 */
 484
 485 {
 486 // os: So ein Unsinn! Irgendwo laesst sich so ein Item immer finden,
 487 //              es muss aber im rSet vorhanden sein!
 488 //      const SfxPoolItem* pX = GetOldItem( rSet, SID_VIEW_FLD_PIC );
 489 //      if( pX && pX->ISA(SfxWallpaperItem))
 490     if(SFX_ITEM_AVAILABLE <= rSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), FALSE))
 491     {
 492         ResetFromWallpaperItem( rSet );
 493         return;
 494     }
 495
 496     // Zustand des Vorschau-Buttons durch UserData persistent
 497     String aUserData = GetUserData();
 498     aBtnPreview.Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) );
 499
 500     // nach Reset kein ShowSelector() mehr aufrufen d"urfen
 501     bAllowShowSelector = FALSE;
 502
 503
 504     // Input-BrushItem besorgen und auswerten
 505     const SvxBrushItem* pBgdAttr = NULL;
 506     USHORT nSlot = SID_ATTR_BRUSH;
 507     const SfxPoolItem* pItem;
 508     USHORT nDestValue = USHRT_MAX;
 509
 510     if ( SFX_ITEM_SET == rSet.GetItemState(     SID_BACKGRND_DESTINATION,
 511                                             FALSE, &pItem ) )
 512     {
 513         nDestValue = ((const SfxUInt16Item*)pItem)->GetValue();
 514         aTblLBox.SelectEntryPos(nDestValue);
 515
 516         switch ( nDestValue )
 517         {
 518             case TBL_DEST_CELL:
 519                 nSlot = SID_ATTR_BRUSH;
 520             break;
 521             case TBL_DEST_ROW:
 522                 nSlot = SID_ATTR_BRUSH_ROW;
 523             break;
 524             case TBL_DEST_TBL:
 525                 nSlot = SID_ATTR_BRUSH_TABLE;
 526             break;
 527         }
 528     }
 529     else if( SFX_ITEM_SET == rSet.GetItemState(
 530                 SID_PARA_BACKGRND_DESTINATION, FALSE, &pItem ) )
 531     {
 532         nDestValue = ((const SfxUInt16Item*)pItem)->GetValue();
 533         // ist gerade Zeichen aktiviert?
 534         USHORT nParaSel  = aParaLBox.GetSelectEntryPos();
 535         if(1 == nParaSel)
 536         {
 537             // dann war das ein "Standard" - Aufruf
 538             nDestValue = nParaSel;
 539         }
 540         aParaLBox.SelectEntryPos(nDestValue);
 541
 542         switch ( nDestValue )
 543         {
 544             case PARA_DEST_PARA:
 545                 nSlot = SID_ATTR_BRUSH;
 546             break;
 547             case PARA_DEST_CHAR:
 548                 nSlot = SID_ATTR_BRUSH_CHAR;
 549             break;
 550         }
 551     }
 552     //#111173# the destination item is missing when the parent style has been changed
 553     if(USHRT_MAX == nDestValue && (aParaLBox.IsVisible()||aTblLBox.IsVisible()))
 554         nDestValue = 0;
 555     USHORT nWhich = GetWhich( nSlot );
 556
 557     if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
 558         pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
 559
 560     aBtnTile.Check();
 561
 562     if ( pBgdAttr )
 563     {
 564         FillControls_Impl(*pBgdAttr, aUserData);
 565         aBgdColor = ( (SvxBrushItem*)pBgdAttr )->GetColor();
 566     }
 567     else
 568     {
 569         aSelectTxt.Hide();
 570         aLbSelect.Hide();
 571         aLbSelect.SelectEntryPos( 0 );
 572         ShowColorUI_Impl();
 573
 574         const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_BRUSH );
 575
 576         if ( pOld )
 577             aBgdColor = ( (SvxBrushItem*)pOld )->GetColor();
 578     }
 579
 580     if ( nDestValue != USHRT_MAX )
 581     {
 582         if(aTblLBox.IsVisible())
 583         {
 584             USHORT nValue = aTblLBox.GetSelectEntryPos();
 585
 586             if ( pTableBck_Impl )
 587             {
 588                 DELETEZ( pTableBck_Impl->pCellBrush);
 589                 DELETEZ( pTableBck_Impl->pRowBrush);
 590                 DELETEZ( pTableBck_Impl->pTableBrush);
 591             }
 592             else
 593                 pTableBck_Impl = new SvxBackgroundTable_Impl();
 594
 595             pTableBck_Impl->nActPos = nValue;
 596
 597             nWhich = GetWhich( SID_ATTR_BRUSH );
 598             if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
 599             {
 600                 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
 601                 pTableBck_Impl->pCellBrush = new SvxBrushItem(*pBgdAttr);
 602             }
 603             pTableBck_Impl->nCellWhich = nWhich;
 604
 605             if ( rSet.GetItemState( SID_ATTR_BRUSH_ROW, FALSE ) >= SFX_ITEM_AVAILABLE )
 606             {
 607                 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_ROW ) );
 608                 pTableBck_Impl->pRowBrush = new SvxBrushItem(*pBgdAttr);
 609             }
 610             pTableBck_Impl->nRowWhich = SID_ATTR_BRUSH_ROW;
 611
 612             if ( rSet.GetItemState( SID_ATTR_BRUSH_TABLE, FALSE ) >= SFX_ITEM_AVAILABLE )
 613             {
 614                 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_TABLE ) );
 615                 pTableBck_Impl->pTableBrush = new SvxBrushItem(*pBgdAttr);
 616             }
 617             pTableBck_Impl->nTableWhich = SID_ATTR_BRUSH_TABLE;
 618
 619             TblDestinationHdl_Impl(&aTblLBox);
 620             aTblLBox.SaveValue();
 621         }
 622         else
 623         {
 624             USHORT nValue = aParaLBox.GetSelectEntryPos();
 625
 626             if ( pParaBck_Impl )
 627             {
 628                 delete pParaBck_Impl->pParaBrush;
 629                 delete pParaBck_Impl->pCharBrush;
 630             }
 631             else
 632                 pParaBck_Impl = new SvxBackgroundPara_Impl();
 633
 634             pParaBck_Impl->nActPos = nValue;
 635
 636             nWhich = GetWhich( SID_ATTR_BRUSH );
 637             if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
 638             {
 639                 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
 640                 pParaBck_Impl->pParaBrush = new SvxBrushItem(*pBgdAttr);
 641             }
 642
 643             nWhich = GetWhich( SID_ATTR_BRUSH_CHAR );
 644             SfxItemState eState = rSet.GetItemState( nWhich, TRUE );
 645             eState = rSet.GetItemState( nWhich, FALSE );
 646             if ( rSet.GetItemState( nWhich, TRUE ) > SFX_ITEM_AVAILABLE )
 647             {
 648                 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
 649                 pParaBck_Impl->pCharBrush = new SvxBrushItem(*pBgdAttr);
 650             }
 651             else
 652                 pParaBck_Impl->pCharBrush = new SvxBrushItem(SID_ATTR_BRUSH_CHAR);
 653
 654             ParaDestinationHdl_Impl(&aParaLBox);
 655             aParaLBox.SaveValue();
 656         }
 657     }
 658     if(!bResized)
 659     {
 660         if(!aLbSelect.IsVisible() && !aTblLBox.IsVisible() && !aParaLBox.IsVisible())
 661         {
 662             long nY(LogicToPixel(Point(11,14), MAP_APPFONT).X());
 663             long nX(LogicToPixel(Point(11,14), MAP_APPFONT).Y());
 664             Point aPos(aBorderWin.GetPosPixel());
 665             aPos.X() = nX;
 666             aPos.Y() = nY;
 667             aBorderWin.SetPosPixel(aPos);
 668             aPos = pPreviewWin1->GetPosPixel();
 669             aPos.Y()  = nY;
 670             pPreviewWin1->SetPosPixel(aPos);
 671             aBackgroundColorBox.Hide();
 672         }
 673     }
 674 }
 675
 676 void SvxBackgroundTabPage::ResetFromWallpaperItem( const SfxItemSet& rSet )
 677 {
 678     ShowSelector();
 679
 680     // Zustand des Vorschau-Buttons durch UserData persistent
 681     String aUserData = GetUserData();
 682     aBtnPreview.Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) );
 683
 684     // Input-BrushItem besorgen und auswerten
 685     const SvxBrushItem* pBgdAttr = NULL;
 686     USHORT nSlot = SID_VIEW_FLD_PIC;
 687     USHORT nWhich = GetWhich( nSlot );
 688     SvxBrushItem* pTemp = 0;
 689     const CntWallpaperItem* pItem = 0;
 690
 691     if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
 692     {
 693         pItem = (const CntWallpaperItem*)&rSet.Get( nWhich );
 694         pTemp = new SvxBrushItem( *pItem, nWhich );
 695         pBgdAttr = pTemp;
 696     }
 697
 698     aBtnTile.Check();
 699
 700     if ( pBgdAttr )
 701     {
 702         FillControls_Impl(*pBgdAttr, aUserData);
 703         // Auch bei Anzeige der Grafik, soll die Brush erhalten bleiben
 704         if( aBgdColor != pBgdAttr->GetColor() )
 705         {
 706             aBgdColor = pBgdAttr->GetColor();
 707             USHORT nCol = GetItemId_Impl( aBackgroundColorSet, aBgdColor );
 708             aBackgroundColorSet.SelectItem( nCol );
 709             pPreviewWin1->NotifyChange( aBgdColor );
 710         }
 711     }
 712     else
 713     {
 714         aLbSelect.SelectEntryPos( 0 );
 715         ShowColorUI_Impl();
 716
 717         const SfxPoolItem* pOld = GetOldItem( rSet, SID_VIEW_FLD_PIC );
 718         if ( pOld )
 719             aBgdColor = Color( ((CntWallpaperItem*)pOld)->GetColor() );
 720     }
 721
 722     // We now have always a link to the background
 723     bLinkOnly = TRUE;
 724     aBtnLink.Check( TRUE );
 725     aBtnLink.Show( FALSE );
 726 //      if( !pItem || !pItem->GetWallpaper(FALSE).IsBitmap() )
 727 //              aBtnLink.Check();
 728
 729     delete pTemp;
 730 }
 731
 732
 733
 734 //------------------------------------------------------------------------
 735
 736 void SvxBackgroundTabPage::FillUserData()
 737
 738 /*      [Beschreibung]
 739
 740     Beim Destruieren einer SfxTabPage wird diese virtuelle Methode gerufen,
 741     damit die TabPage interne Informationen sichern kann.
 742
 743     In diesem Fall wird der Zustand des Vorschau-Buttons gesichert.
 744 */
 745
 746 {
 747     SetUserData( String( aBtnPreview.IsChecked() ? sal_Unicode('1') : sal_Unicode('0') ) );
 748 }
 749
 750 //------------------------------------------------------------------------
 751
 752 BOOL SvxBackgroundTabPage::FillItemSet( SfxItemSet& rCoreSet )
 753
 754 /*      [Beschreibung]
 755
 756 */
 757
 758 {
 759     if ( pPageImpl->pLoadTimer && pPageImpl->pLoadTimer->IsActive() )
 760     {
 761         pPageImpl->pLoadTimer->Stop();
 762         LoadTimerHdl_Impl( pPageImpl->pLoadTimer );
 763     }
 764 // os: So ein Unsinn! Irgendwo laesst sich so ein Item immer finden,
 765 //              es muss aber im rSet vorhanden sein!
 766
 767 //      const SfxPoolItem* pX = GetOldItem( rCoreSet, SID_VIEW_FLD_PIC );
 768 //      if( pX && pX->ISA(SfxWallpaperItem))
 769     if(SFX_ITEM_AVAILABLE <= rCoreSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), FALSE))
 770         return FillItemSetWithWallpaperItem( rCoreSet, SID_VIEW_FLD_PIC );
 771
 772     BOOL bModified = FALSE;
 773     USHORT nSlot = SID_ATTR_BRUSH;
 774
 775     if ( aTblLBox.IsVisible() )
 776     {
 777         switch( aTblLBox.GetSelectEntryPos() )
 778         {
 779             case TBL_DEST_CELL:
 780                 nSlot = SID_ATTR_BRUSH;
 781             break;
 782             case TBL_DEST_ROW:
 783                 nSlot = SID_ATTR_BRUSH_ROW;
 784             break;
 785             case TBL_DEST_TBL:
 786                 nSlot = SID_ATTR_BRUSH_TABLE;
 787             break;
 788         }
 789     }
 790     else if(aParaLBox.GetData() == &aParaLBox)
 791     {
 792         switch(aParaLBox.GetSelectEntryPos())
 793         {
 794             case PARA_DEST_PARA:
 795                 nSlot = SID_ATTR_BRUSH;
 796             break;
 797             case PARA_DEST_CHAR:
 798                 nSlot = SID_ATTR_BRUSH_CHAR;
 799             break;
 800         }
 801     }
 802     USHORT nWhich = GetWhich( nSlot );
 803
 804     const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot );
 805     SfxItemState eOldItemState = rCoreSet.GetItemState(nSlot, FALSE);
 806     const SfxItemSet& rOldSet = GetItemSet();
 807
 808     BOOL bGraphTransparencyChanged = bGraphTransparency && (aGraphTransMF.GetText() != aGraphTransMF.GetSavedValue());
 809     if ( pOld )
 810     {
 811         const SvxBrushItem& rOldItem    = (const SvxBrushItem&)*pOld;
 812         SvxGraphicPosition      eOldPos         = rOldItem.GetGraphicPos();
 813         const BOOL                      bIsBrush        = ( 0 == aLbSelect.GetSelectEntryPos() );
 814
 815         // transparency has to be set if enabled, the color not already set to "No fill" and
 816         if( bColTransparency &&
 817             aBgdColor.GetTransparency() < 0xff)
 818         {
 819             aBgdColor.SetTransparency(lcl_PercentToTransparency(static_cast<long>(aColTransMF.GetValue())));
 820         }
 821         if (   ( (GPOS_NONE == eOldPos) && bIsBrush  )
 822             || ( (GPOS_NONE != eOldPos) && !bIsBrush ) ) // Brush <-> Bitmap gewechselt?
 823         {
 824             // Hintergrund-Art wurde nicht gewechselt:
 825
 826             if ( (GPOS_NONE == eOldPos) || !aLbSelect.IsVisible() )
 827             {
 828                 // Brush-Behandlung:
 829                 if ( rOldItem.GetColor() != aBgdColor ||
 830                         (SFX_ITEM_AVAILABLE >= eOldItemState && !aBackgroundColorSet.IsNoSelection()))
 831                 {
 832                     bModified = TRUE;
 833                     rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
 834                 }
 835                 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
 836                     rCoreSet.ClearItem( nWhich );
 837             }
 838             else
 839             {
 840                 // Bitmap-Behandlung:
 841
 842                 SvxGraphicPosition      eNewPos  = GetGraphicPosition_Impl();
 843                 const BOOL                      bIsLink  = aBtnLink.IsChecked();
 844                 const BOOL                      bWasLink = (NULL != rOldItem.GetGraphicLink() );
 845
 846
 847                 if ( !bIsLink && !bIsGraphicValid )
 848                     bIsGraphicValid = LoadLinkedGraphic_Impl();
 849
 850                 if (    bGraphTransparencyChanged ||
 851                         eNewPos != eOldPos
 852                     || bIsLink != bWasLink
 853                     || ( bWasLink  &&    *rOldItem.GetGraphicLink()
 854                                       != aBgdGraphicPath )
 855                     || ( !bWasLink &&    rOldItem.GetGraphic()->GetBitmap()
 856                                       != aBgdGraphic.GetBitmap() )
 857                    )
 858                 {
 859                     bModified = TRUE;
 860
 861                     SvxBrushItem aTmpBrush(nWhich);
 862                     if ( bIsLink )
 863                     {
 864                         aTmpBrush = SvxBrushItem( aBgdGraphicPath,
 865                                                 aBgdGraphicFilter,
 866                                                 eNewPos,
 867                                                 nWhich );
 868                     }
 869                     else
 870                         aTmpBrush = SvxBrushItem( aBgdGraphic,
 871                                         eNewPos,
 872                                         nWhich );
 873                     lcl_SetTransparency(aTmpBrush, static_cast<long>(aGraphTransMF.GetValue()));
 874
 875                     rCoreSet.Put(aTmpBrush);
 876                 }
 877                 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
 878                     rCoreSet.ClearItem( nWhich );
 879             }
 880         }
 881         else // Brush <-> Bitmap gewechselt!
 882         {
 883             if ( bIsBrush )
 884                 rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
 885             else
 886             {
 887                 SvxBrushItem* pTmpBrush = 0;
 888                 if ( aBtnLink.IsChecked() )
 889                 {
 890                     pTmpBrush = new SvxBrushItem( aBgdGraphicPath,
 891                                                 aBgdGraphicFilter,
 892                                                 GetGraphicPosition_Impl(),
 893                                                 nWhich );
 894                 }
 895                 else
 896                 {
 897                     if ( !bIsGraphicValid )
 898                         bIsGraphicValid = LoadLinkedGraphic_Impl();
 899
 900                     if ( bIsGraphicValid )
 901                         pTmpBrush = new SvxBrushItem( aBgdGraphic,
 902                                                     GetGraphicPosition_Impl(),
 903                                                     nWhich );
 904                 }
 905                 if(pTmpBrush)
 906                 {
 907                     lcl_SetTransparency(*pTmpBrush, static_cast<long>(aGraphTransMF.GetValue()));
 908                     rCoreSet.Put(*pTmpBrush);
 909                     delete pTmpBrush;
 910                 }
 911             }
 912             bModified = ( bIsBrush || aBtnLink.IsChecked() || bIsGraphicValid );
 913         }
 914     }
 915     else if ( SID_ATTR_BRUSH_CHAR == nSlot && aBgdColor != Color( COL_WHITE ) )
 916     {
 917         rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
 918         bModified = TRUE;
 919     }
 920
 921     if( aTblLBox.IsVisible() )
 922     {
 923         // Der aktuelle Zustand wurde bereits geputtet
 924         if( nSlot != SID_ATTR_BRUSH && pTableBck_Impl->pCellBrush)
 925         {
 926             const SfxPoolItem* pOldCell =
 927                 GetOldItem( rCoreSet, SID_ATTR_BRUSH );
 928
 929             if ( *pTableBck_Impl->pCellBrush != *pOldCell )
 930             {
 931                 rCoreSet.Put( *pTableBck_Impl->pCellBrush );
 932                 bModified |= TRUE;
 933             }
 934         }
 935
 936         if( nSlot != SID_ATTR_BRUSH_ROW && pTableBck_Impl->pRowBrush)
 937         {
 938             const SfxPoolItem* pOldRow =
 939                 GetOldItem( rCoreSet, SID_ATTR_BRUSH_ROW );
 940
 941             if ( *pTableBck_Impl->pRowBrush != *pOldRow )
 942             {
 943                 rCoreSet.Put( *pTableBck_Impl->pRowBrush );
 944                 bModified |= TRUE;
 945             }
 946         }
 947
 948         if( nSlot != SID_ATTR_BRUSH_TABLE && pTableBck_Impl->pTableBrush)
 949         {
 950             const SfxPoolItem* pOldTable =
 951                 GetOldItem( rCoreSet, SID_ATTR_BRUSH_TABLE );
 952
 953             if ( *pTableBck_Impl->pTableBrush != *pOldTable )
 954             {
 955                 rCoreSet.Put( *pTableBck_Impl->pTableBrush );
 956                 bModified |= TRUE;
 957             }
 958         }
 959
 960         if( aTblLBox.GetSavedValue() != aTblLBox.GetSelectEntryPos() )
 961         {
 962             rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION,
 963                                          aTblLBox.GetSelectEntryPos() ) );
 964             bModified |= TRUE;
 965         }
 966     }
 967     else if(aParaLBox.GetData() == &aParaLBox)
 968     {
 969         // Der aktuelle Zustand wurde bereits geputtet
 970         if( nSlot != SID_ATTR_BRUSH && aParaLBox.IsVisible()) // nicht im Suchen-Format-Dialog
 971         {
 972             const SfxPoolItem* pOldPara =
 973                 GetOldItem( rCoreSet, SID_ATTR_BRUSH );
 974
 975             if ( *pParaBck_Impl->pParaBrush != *pOldPara )
 976             {
 977                 rCoreSet.Put( *pParaBck_Impl->pParaBrush );
 978                 bModified |= TRUE;
 979             }
 980         }
 981
 982         if( nSlot != SID_ATTR_BRUSH_CHAR )
 983         {
 984             const SfxPoolItem* pOldChar =
 985                 GetOldItem( rCoreSet, SID_ATTR_BRUSH_CHAR );
 986             DBG_ASSERT(pParaBck_Impl, "pParaBck_Impl == NULL ?");
 987             if ( pOldChar &&
 988                     //#111173#  crash report shows that pParaBck_Impl can be NULL, the cause is unknown
 989                     pParaBck_Impl &&
 990                         (*pParaBck_Impl->pCharBrush != *pOldChar ||
 991                 *pParaBck_Impl->pCharBrush != SvxBrushItem(SID_ATTR_BRUSH_CHAR)))
 992             {
 993                 rCoreSet.Put( *pParaBck_Impl->pCharBrush );
 994                 bModified |= TRUE;
 995             }
 996         }
 997
 998         if( aParaLBox.GetSavedValue() != aParaLBox.GetSelectEntryPos() )
 999         {
1000             rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION,
1001                                          aParaLBox.GetSelectEntryPos() ) );
1002             bModified |= TRUE;
1003         }
1004     }
1005     return bModified;
1006 }
1007
1008 BOOL SvxBackgroundTabPage::FillItemSetWithWallpaperItem( SfxItemSet& rCoreSet, USHORT nSlot)
1009 {
1010     USHORT nWhich = GetWhich( nSlot );
1011     const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot );
1012     const SfxItemSet& rOldSet = GetItemSet();
1013     DBG_ASSERT(pOld,"FillItemSetWithWallpaperItem: Item not found");
1014
1015     SvxBrushItem                rOldItem( (const CntWallpaperItem&)*pOld, nWhich );
1016     SvxGraphicPosition  eOldPos         = rOldItem.GetGraphicPos();
1017     const BOOL                  bIsBrush        = ( 0 == aLbSelect.GetSelectEntryPos() );
1018     BOOL                                bModified = FALSE;
1019
1020     if (   ( (GPOS_NONE == eOldPos) && bIsBrush  )
1021         || ( (GPOS_NONE != eOldPos) && !bIsBrush ) ) // Brush <-> Bitmap gewechselt?
1022     {
1023         // Hintergrund-Art wurde nicht gewechselt:
1024
1025         if ( (GPOS_NONE == eOldPos) || !aLbSelect.IsVisible() )
1026         {
1027             // Brush-Behandlung:
1028             if ( rOldItem.GetColor() != aBgdColor )
1029             {
1030                 bModified = TRUE;
1031                 CntWallpaperItem aItem( nWhich );
1032                 aItem.SetColor( aBgdColor );
1033                 rCoreSet.Put( aItem );
1034             }
1035             else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1036                 rCoreSet.ClearItem( nWhich );
1037         }
1038         else
1039         {
1040             // Bitmap-Behandlung:
1041             SvxGraphicPosition  eNewPos  = GetGraphicPosition_Impl();
1042
1043             int bBitmapChanged = ( ( eNewPos != eOldPos ) ||
1044                                    ( *rOldItem.GetGraphicLink() != aBgdGraphicPath ) );
1045             int bBrushChanged = ( rOldItem.GetColor() != aBgdColor );
1046             if( bBitmapChanged || bBrushChanged )
1047             {
1048                 bModified = TRUE;
1049
1050                 CntWallpaperItem aItem( nWhich );
1051                 WallpaperStyle eWallStyle = SvxBrushItem::GraphicPos2WallpaperStyle(eNewPos);
1052                 aItem.SetStyle( sal::static_int_cast< USHORT >( eWallStyle ) );
1053                 aItem.SetColor( aBgdColor );
1054                 aItem.SetBitmapURL( aBgdGraphicPath );
1055                 rCoreSet.Put( aItem );
1056             }
1057             else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1058                 rCoreSet.ClearItem( nWhich );
1059         }
1060     }
1061     else // Brush <-> Bitmap gewechselt!
1062     {
1063         CntWallpaperItem aItem( nWhich );
1064         if ( bIsBrush )
1065         {
1066             aItem.SetColor( aBgdColor );
1067             rCoreSet.Put( aItem );
1068         }
1069         else
1070         {
1071             WallpaperStyle eWallStyle =
1072                 SvxBrushItem::GraphicPos2WallpaperStyle( GetGraphicPosition_Impl() );
1073             aItem.SetStyle( sal::static_int_cast< USHORT >( eWallStyle ) );
1074             aItem.SetColor( aBgdColor );
1075             aItem.SetBitmapURL( aBgdGraphicPath );
1076             rCoreSet.Put( aItem );
1077         }
1078
1079         bModified = TRUE;
1080     }
1081     return bModified;
1082 }
1083
1084 //-----------------------------------------------------------------------
1085
1086 int SvxBackgroundTabPage::DeactivatePage( SfxItemSet* _pSet )
1087
1088 /*      [Beschreibung]
1089
1090     virtuelle Methode, wird beim Deaktivieren gerufen
1091 */
1092
1093 {
1094     if ( pPageImpl->bIsImportDlgInExecute )
1095         return KEEP_PAGE;
1096
1097     if ( _pSet )
1098         FillItemSet( *_pSet );
1099
1100     return LEAVE_PAGE;
1101 }
1102
1103 //-----------------------------------------------------------------------
1104
1105 void SvxBackgroundTabPage::PointChanged( Window* , RECT_POINT  )
1106
1107 /*      [Beschreibung]
1108
1109 */
1110
1111 {
1112     // muss implementiert werden, damit Position-Control funktioniert
1113 }
1114
1115 //-----------------------------------------------------------------------
1116
1117 void SvxBackgroundTabPage::ShowSelector()
1118
1119 /*      [Beschreibung]
1120
1121 */
1122
1123 {
1124     if( bAllowShowSelector)
1125     {
1126         aSelectTxt.Show();
1127         aLbSelect.Show();
1128         aLbSelect.SetSelectHdl( HDL(SelectHdl_Impl) );
1129         aBtnLink.SetClickHdl( HDL(FileClickHdl_Impl) );
1130         aBtnPreview.SetClickHdl( HDL(FileClickHdl_Impl) );
1131         aBtnBrowse.SetClickHdl( HDL(BrowseHdl_Impl) );
1132         aBtnArea.SetClickHdl( HDL(RadioClickHdl_Impl) );
1133         aBtnTile.SetClickHdl( HDL(RadioClickHdl_Impl) );
1134         aBtnPosition.SetClickHdl( HDL(RadioClickHdl_Impl) );
1135
1136         // Verz"ogertes Laden "uber Timer (wg. UI-Update)
1137         pPageImpl->pLoadTimer = new Timer;
1138         pPageImpl->pLoadTimer->SetTimeout( 500 ); // 500ms verz"ogern
1139         pPageImpl->pLoadTimer->SetTimeoutHdl(
1140             LINK( this, SvxBackgroundTabPage, LoadTimerHdl_Impl ) );
1141
1142         bAllowShowSelector = FALSE;
1143
1144         if(nHtmlMode & HTMLMODE_ON)
1145         {
1146             if(!(nHtmlMode & HTMLMODE_GRAPH_POS))
1147                 aBtnPosition.Enable(FALSE);
1148             aBtnArea.Enable(FALSE);
1149         }
1150     }
1151 }
1152
1153 //------------------------------------------------------------------------
1154
1155
1156 void SvxBackgroundTabPage::RaiseLoadError_Impl()
1157
1158 /*      [Beschreibung]
1159
1160 */
1161
1162 {
1163     SfxErrorContext aContext( ERRCTX_SVX_BACKGROUND,
1164                               String(),
1165                               this,
1166                               RID_SVXERRCTX,
1167                               &DIALOG_MGR() );
1168
1169     ErrorHandler::HandleError(
1170         *new StringErrorInfo( ERRCODE_SVX_GRAPHIC_NOTREADABLE,
1171                               aBgdGraphicPath ) );
1172 }
1173
1174 //------------------------------------------------------------------------
1175
1176 BOOL SvxBackgroundTabPage::LoadLinkedGraphic_Impl()
1177
1178 /*      [Beschreibung]
1179
1180 */
1181
1182 {
1183     BOOL bResult = ( aBgdGraphicPath.Len() > 0 ) &&
1184                    ( GRFILTER_OK == LoadGraphic( aBgdGraphicPath,
1185                                                  aBgdGraphicFilter,
1186                                                  aBgdGraphic ) );
1187     return bResult;
1188 }
1189
1190 //------------------------------------------------------------------------
1191
1192
1193 void SvxBackgroundTabPage::FillColorValueSets_Impl()
1194
1195 /*      [Beschreibung]
1196
1197     F"ullen des Farb-Sets
1198 */
1199
1200 {
1201     SfxObjectShell* pDocSh = SfxObjectShell::Current();
1202     const SfxPoolItem* pItem = NULL;
1203     XColorTable* pColorTable = NULL;
1204     const Size aSize15x15 = Size( 15, 15 );
1205     FASTBOOL bOwn = FALSE;
1206
1207     if ( pDocSh && ( 0 != ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) ) )
1208         pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
1209
1210     if ( !pColorTable )
1211     {
1212         bOwn = TRUE;
1213         pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
1214     }
1215
1216     if ( pColorTable )
1217     {
1218         short i = 0;
1219         long nCount     = pColorTable->Count();
1220         XColorEntry* pEntry     = NULL;
1221         Color aColWhite( COL_WHITE );
1222         String aStrWhite( SVX_RES( RID_SVXITEMS_COLOR_WHITE ) );
1223         WinBits nBits = ( aBackgroundColorSet.GetStyle() | WB_ITEMBORDER | WB_NAMEFIELD | WB_NONEFIELD );
1224         aBackgroundColorSet.SetText( String( SVX_RES( RID_SVXSTR_TRANSPARENT ) ) );
1225         aBackgroundColorSet.SetStyle( nBits );
1226         for ( i = 0; i < nCount; i++ )
1227         {
1228             pEntry = pColorTable->GetColor(i);
1229             aBackgroundColorSet.InsertItem(     i + 1, pEntry->GetColor(), pEntry->GetName() );
1230         }
1231
1232         while ( i < 80 )
1233         {
1234             aBackgroundColorSet.InsertItem( i + 1, aColWhite, aStrWhite );
1235             i++;
1236         }
1237
1238         if ( nCount > 80 )
1239         {
1240             aBackgroundColorSet.SetStyle( nBits | WB_VSCROLL );
1241         }
1242     }
1243
1244     if ( bOwn )
1245         delete pColorTable;
1246
1247     aBackgroundColorSet.SetColCount( 10 );
1248     aBackgroundColorSet.SetLineCount( 10 );
1249     aBackgroundColorSet.CalcWindowSizePixel( aSize15x15 );
1250
1251 }
1252
1253 //------------------------------------------------------------------------
1254
1255
1256
1257 //------------------------------------------------------------------------
1258
1259 void SvxBackgroundTabPage::ShowColorUI_Impl()
1260
1261 /*      [Beschreibung]
1262
1263     Die Controls f"ur das Einstellen der Grafik ausblenden und die
1264     Controls f"ur die Farbeinstellung einblenden.
1265 */
1266
1267 {
1268     if( !aBackgroundColorSet.IsVisible() )
1269     {
1270         aBackgroundColorSet.Show();
1271         aBackgroundColorBox.Show();
1272         aBorderWin.Show();
1273         pPreviewWin1->Show();
1274         aBtnBrowse.Hide();
1275         aFtFile.Hide();
1276         aBtnLink.Hide();
1277         aBtnPreview.Hide();
1278         aGbFile.Hide();
1279         aBtnPosition.Hide();
1280         aBtnArea.Hide();
1281         aBtnTile.Hide();
1282         aWndPosition.Hide();
1283         aGbPosition.Hide();
1284         pPreviewWin2->Hide();
1285         aGraphTransFL.Show(FALSE);
1286         aGraphTransMF.Show(FALSE);
1287         if(bColTransparency)
1288         {
1289             aColTransFT.Show();
1290             aColTransMF.Show();
1291         }
1292     }
1293 }
1294
1295 //------------------------------------------------------------------------
1296
1297 void SvxBackgroundTabPage::ShowBitmapUI_Impl()
1298
1299 /*      [Beschreibung]
1300
1301     Die Controls f"ur die Farbeinstellung ausblenden und die
1302     Controls f"ur das Einstellen der Grafik einblenden.
1303 */
1304
1305 {
1306     if ( aLbSelect.IsVisible() &&
1307          (
1308         aBackgroundColorSet.IsVisible()
1309          || !aBtnBrowse.IsVisible() ) )
1310     {
1311         aBackgroundColorSet.Hide();
1312         aBackgroundColorBox.Hide();
1313         aBorderWin.Hide();
1314         pPreviewWin1->Hide();
1315         aBtnBrowse.Show();
1316         aFtFile.Show();
1317
1318         if ( !bLinkOnly && ! nHtmlMode & HTMLMODE_ON )
1319             aBtnLink.Show();
1320         aBtnPreview.Show();
1321         aGbFile.Show();
1322         aBtnPosition.Show();
1323         aBtnArea.Show();
1324         aBtnTile.Show();
1325         aWndPosition.Show();
1326         aGbPosition.Show();
1327         pPreviewWin2->Show();
1328         if(bGraphTransparency)
1329         {
1330             aGraphTransFL.Show();
1331             aGraphTransMF.Show();
1332         }
1333         aColTransFT.Show(FALSE);
1334         aColTransMF.Show(FALSE);
1335     }
1336 }
1337
1338 //------------------------------------------------------------------------
1339
1340 void SvxBackgroundTabPage::SetGraphicPosition_Impl( SvxGraphicPosition ePos )
1341
1342 /*      [Beschreibung]
1343
1344     Die Controls f"ur die Grafikposition einstellen.
1345 */
1346
1347 {
1348     switch ( ePos )
1349     {
1350         case GPOS_AREA:
1351         {
1352             aBtnArea.Check();
1353             aWndPosition.Disable();
1354         }
1355         break;
1356
1357         case GPOS_TILED:
1358         {
1359             aBtnTile.Check();
1360             aWndPosition.Disable();
1361         }
1362         break;
1363
1364         default:
1365         {
1366             aBtnPosition.Check();
1367             aWndPosition.Enable();
1368             RECT_POINT eNewPos = RP_MM;
1369
1370             switch ( ePos )
1371             {
1372                 case GPOS_MM:   break;
1373                 case GPOS_LT:   eNewPos = RP_LT; break;
1374                 case GPOS_MT:   eNewPos = RP_MT; break;
1375                 case GPOS_RT:   eNewPos = RP_RT; break;
1376                 case GPOS_LM:   eNewPos = RP_LM; break;
1377                 case GPOS_RM:   eNewPos = RP_RM; break;
1378                 case GPOS_LB:   eNewPos = RP_LB; break;
1379                 case GPOS_MB:   eNewPos = RP_MB; break;
1380                 case GPOS_RB:   eNewPos = RP_RB; break;
1381                 default: ;//prevent warning
1382             }
1383             aWndPosition.SetActualRP( eNewPos );
1384         }
1385         break;
1386     }
1387     aWndPosition.Invalidate();
1388 }
1389
1390 //------------------------------------------------------------------------
1391
1392 SvxGraphicPosition SvxBackgroundTabPage::GetGraphicPosition_Impl()
1393
1394 /*      [Beschreibung]
1395
1396     Die Position der Grafik zur"uckgeben.
1397 */
1398
1399 {
1400     if ( aBtnTile.IsChecked() )
1401         return GPOS_TILED;
1402     else if ( aBtnArea.IsChecked() )
1403         return GPOS_AREA;
1404     else
1405     {
1406         switch ( aWndPosition.GetActualRP() )
1407         {
1408             case RP_LT: return GPOS_LT;
1409             case RP_MT: return GPOS_MT;
1410             case RP_RT: return GPOS_RT;
1411             case RP_LM: return GPOS_LM;
1412             case RP_MM: return GPOS_MM;
1413             case RP_RM: return GPOS_RM;
1414             case RP_LB: return GPOS_LB;
1415             case RP_MB: return GPOS_MB;
1416             case RP_RB: return GPOS_RB;
1417         }
1418     }
1419     return GPOS_MM;
1420 }
1421
1422 //-----------------------------------------------------------------------
1423 // Handler
1424 //-----------------------------------------------------------------------
1425
1426 IMPL_LINK( SvxBackgroundTabPage, BackgroundColorHdl_Impl, ValueSet*, EMPTYARG )
1427 /*
1428     Handler, called when color selection is changed
1429 */
1430 {
1431     USHORT nItemId = aBackgroundColorSet.GetSelectItemId();
1432     Color aColor = nItemId ? ( aBackgroundColorSet.GetItemColor( nItemId ) ) : Color( COL_TRANSPARENT );
1433     aBgdColor = aColor;
1434     pPreviewWin1->NotifyChange( aBgdColor );
1435     BOOL bEnableTransp = aBgdColor.GetTransparency() < 0xff;
1436     aColTransFT.Enable(bEnableTransp);
1437     aColTransMF.Enable(bEnableTransp);
1438     return 0;
1439 }
1440
1441 //------------------------------------------------------------------------
1442
1443 IMPL_LINK( SvxBackgroundTabPage, SelectHdl_Impl, ListBox*, EMPTYARG )
1444
1445 /*      [Beschreibung]
1446
1447 */
1448
1449 {
1450     if ( 0 == aLbSelect.GetSelectEntryPos() )
1451     {
1452         ShowColorUI_Impl();
1453         aParaLBox.Enable(); // Zeichenhintergrund kann keine Bitmap sein
1454     }
1455     else
1456     {
1457         ShowBitmapUI_Impl();
1458         aParaLBox.Enable(FALSE);// Zeichenhintergrund kann keine Bitmap sein
1459     }
1460     return 0;
1461 }
1462
1463 //------------------------------------------------------------------------
1464
1465 IMPL_LINK( SvxBackgroundTabPage, FileClickHdl_Impl, CheckBox*, pBox )
1466
1467 /*      [Beschreibung]
1468
1469 */
1470
1471 {
1472     if ( &aBtnLink == pBox )
1473     {
1474         if ( aBtnLink.IsChecked() )
1475         {
1476             INetURLObject aObj( aBgdGraphicPath );
1477             String aFilePath;
1478             if ( aObj.GetProtocol() == INET_PROT_FILE )
1479                 aFilePath = aObj.getFSysPath( INetURLObject::FSYS_DETECT );
1480             else
1481                 aFilePath = aBgdGraphicPath;
1482             aFtFile.SetText( aFilePath );
1483         }
1484         else
1485             aFtFile.SetText( aStrUnlinked );
1486     }
1487     else if ( &aBtnPreview == pBox )
1488     {
1489         if ( aBtnPreview.IsChecked() )
1490         {
1491             if ( !bIsGraphicValid )
1492                 bIsGraphicValid = LoadLinkedGraphic_Impl();
1493
1494             if ( bIsGraphicValid )
1495             {
1496                 Bitmap aBmp = aBgdGraphic.GetBitmap();
1497                 pPreviewWin2->NotifyChange( &aBmp );
1498             }
1499             else
1500             {
1501                 if ( aBgdGraphicPath.Len() > 0 ) // nur bei gelinkter Grafik
1502                     RaiseLoadError_Impl();               // ein Fehler
1503                 pPreviewWin2->NotifyChange( NULL );
1504             }
1505         }
1506         else
1507             pPreviewWin2->NotifyChange( NULL );
1508     }
1509     return 0;
1510 }
1511
1512 //------------------------------------------------------------------------
1513
1514 IMPL_LINK( SvxBackgroundTabPage, RadioClickHdl_Impl, RadioButton*, pBtn )
1515
1516 /*      [Beschreibung]
1517
1518 */
1519
1520 {
1521     if ( pBtn == &aBtnPosition )
1522     {
1523         if ( !aWndPosition.IsEnabled() )
1524         {
1525             aWndPosition.Enable();
1526             aWndPosition.Invalidate();
1527         }
1528     }
1529     else if ( aWndPosition.IsEnabled() )
1530     {
1531         aWndPosition.Disable();
1532         aWndPosition.Invalidate();
1533     }
1534     return 0;
1535 }
1536
1537 //------------------------------------------------------------------------
1538
1539 IMPL_LINK( SvxBackgroundTabPage, BrowseHdl_Impl, PushButton* , EMPTYARG )
1540
1541 /*      [Beschreibung]
1542
1543     Handler, gerufen durch das Dr"ucken des Durchsuchen-Buttons.
1544     Grafik/Einf"ugen-Dialog erzeugen, Pfad setzen und starten.
1545 */
1546
1547 {
1548     if ( pPageImpl->pLoadTimer->IsActive() )
1549         return 0;
1550     BOOL bHtml = 0 != ( nHtmlMode & HTMLMODE_ON );
1551
1552     pImportDlg = new SvxOpenGraphicDialog( aStrBrowse );
1553     if ( bHtml || bLinkOnly )
1554         pImportDlg->EnableLink(sal_False);
1555     pImportDlg->SetPath( aBgdGraphicPath, aBtnLink.IsChecked() );
1556
1557     pPageImpl->bIsImportDlgInExecute = TRUE;
1558     short nErr = pImportDlg->Execute();
1559     pPageImpl->bIsImportDlgInExecute = FALSE;
1560
1561     if( !nErr )
1562     {
1563         if ( bHtml )
1564             aBtnLink.Check();
1565         // wenn Verkn"upfen nicht gecheckt ist und die Vorschau auch nicht,
1566         // dann die Vorschau aktivieren, damit der Anwender sieht,
1567         // welche Grafik er ausgew"ahlt hat
1568         if ( !aBtnLink.IsChecked() && !aBtnPreview.IsChecked() )
1569             aBtnPreview.Check( TRUE );
1570         // timer-verz"ogertes Laden der Grafik
1571         pPageImpl->pLoadTimer->Start();
1572     }
1573     else
1574         DELETEZ( pImportDlg );
1575     return 0;
1576 }
1577
1578 //-----------------------------------------------------------------------
1579
1580 IMPL_LINK( SvxBackgroundTabPage, LoadTimerHdl_Impl, Timer* , pTimer )
1581
1582 /*      [Beschreibung]
1583
1584     Verz"ogertes Laden der Grafik.
1585     Grafik wird nur dann geladen, wenn sie unterschiedlich zur
1586     aktuellen Grafik ist.
1587 */
1588
1589 {
1590     if ( pTimer == pPageImpl->pLoadTimer )
1591     {
1592         pPageImpl->pLoadTimer->Stop();
1593
1594         if ( pImportDlg )
1595         {
1596             INetURLObject aOld( aBgdGraphicPath );
1597             INetURLObject aNew( pImportDlg->GetPath() );
1598             if ( !aBgdGraphicPath.Len() || aNew != aOld )
1599             {
1600                 // neue Datei gew"ahlt
1601                 aBgdGraphicPath   = pImportDlg->GetPath();
1602                 aBgdGraphicFilter =     pImportDlg->GetCurrentFilter();
1603                 BOOL bLink = ( nHtmlMode & HTMLMODE_ON ) || bLinkOnly ? TRUE : pImportDlg->IsAsLink();
1604                 aBtnLink.Check( bLink );
1605                 aBtnLink.Enable();
1606
1607                 if ( aBtnPreview.IsChecked() )
1608                 {
1609                     if( !pImportDlg->GetGraphic(aBgdGraphic) )
1610                     {
1611                         bIsGraphicValid = TRUE;
1612                     }
1613                     else
1614                     {
1615                         aBgdGraphicFilter.Erase();
1616                         aBgdGraphicPath.Erase();
1617                         bIsGraphicValid = FALSE;
1618                     }
1619                 }
1620                 else
1621                     bIsGraphicValid = FALSE; // Grafik erst beim Preview-Click laden
1622
1623                 if ( aBtnPreview.IsChecked() && bIsGraphicValid )
1624                 {
1625                     Bitmap aBmp = aBgdGraphic.GetBitmap();
1626                     pPreviewWin2->NotifyChange( &aBmp );
1627                 }
1628                 else
1629                     pPreviewWin2->NotifyChange( NULL );
1630             }
1631
1632             FileClickHdl_Impl( &aBtnLink );
1633             DELETEZ( pImportDlg );
1634         }
1635     }
1636     return 0;
1637 }
1638
1639 //-----------------------------------------------------------------------
1640
1641 void SvxBackgroundTabPage::ShowTblControl()
1642
1643 /*      [Beschreibung]
1644
1645 */
1646
1647 {
1648     aTblLBox                    .SetSelectHdl( HDL(TblDestinationHdl_Impl) );
1649     aTblLBox                    .SelectEntryPos(0);
1650     aTblDesc.Show();
1651     aTblLBox.Show();
1652 }
1653
1654 //-----------------------------------------------------------------------
1655
1656 void SvxBackgroundTabPage::ShowParaControl(BOOL bCharOnly)
1657 {
1658     aParaLBox.SetSelectHdl(HDL(ParaDestinationHdl_Impl));
1659     aParaLBox.SelectEntryPos(0);
1660     if(!bCharOnly)
1661     {
1662         aTblDesc.Show();
1663         aParaLBox.Show();
1664     }
1665     aParaLBox.SetData(&aParaLBox); // hier erkennt man, dass dieser Mode eingeschaltet ist
1666 }
1667 //-----------------------------------------------------------------------
1668
1669 IMPL_LINK( SvxBackgroundTabPage, TblDestinationHdl_Impl, ListBox*, pBox )
1670
1671 /*      [Beschreibung]
1672
1673 */
1674
1675 {
1676     USHORT nSelPos = pBox->GetSelectEntryPos();
1677     if( pTableBck_Impl && pTableBck_Impl->nActPos != nSelPos)
1678     {
1679         SvxBrushItem** pActItem = new (SvxBrushItem*);
1680         USHORT nWhich = 0;
1681         switch(pTableBck_Impl->nActPos)
1682         {
1683             case TBL_DEST_CELL:
1684                 *pActItem = pTableBck_Impl->pCellBrush;
1685                 nWhich = pTableBck_Impl->nCellWhich;
1686             break;
1687             case TBL_DEST_ROW:
1688                 *pActItem = pTableBck_Impl->pRowBrush;
1689                 nWhich = pTableBck_Impl->nRowWhich;
1690             break;
1691             case TBL_DEST_TBL:
1692                 *pActItem = pTableBck_Impl->pTableBrush;
1693                 nWhich = pTableBck_Impl->nTableWhich;
1694             break;
1695         }
1696         pTableBck_Impl->nActPos = nSelPos;
1697         if(!*pActItem)
1698             *pActItem = new SvxBrushItem(nWhich);
1699         if(0 == aLbSelect.GetSelectEntryPos())  // Brush ausgewaehlt
1700         {
1701             **pActItem = SvxBrushItem( aBgdColor, nWhich );
1702         }
1703         else
1704         {
1705                 SvxGraphicPosition      eNewPos  = GetGraphicPosition_Impl();
1706                 const BOOL                      bIsLink  = aBtnLink.IsChecked();
1707
1708                 if ( !bIsLink && !bIsGraphicValid )
1709                     bIsGraphicValid = LoadLinkedGraphic_Impl();
1710
1711                 if ( bIsLink )
1712                     **pActItem = SvxBrushItem( aBgdGraphicPath,
1713                                                 aBgdGraphicFilter,
1714                                                 eNewPos,
1715                                                 (*pActItem)->Which() );
1716                 else
1717                     **pActItem = SvxBrushItem( aBgdGraphic,
1718                                                 eNewPos,
1719                                                 (*pActItem)->Which() );
1720         }
1721         switch(nSelPos)
1722         {
1723             case TBL_DEST_CELL:
1724                 *pActItem = pTableBck_Impl->pCellBrush;
1725                 aLbSelect.Enable();
1726                 nWhich = pTableBck_Impl->nCellWhich;
1727             break;
1728             case TBL_DEST_ROW:
1729             {
1730                 if((nHtmlMode & HTMLMODE_ON) && !(nHtmlMode & HTMLMODE_SOME_STYLES))
1731                     aLbSelect.Disable();
1732                 *pActItem = pTableBck_Impl->pRowBrush;
1733                 nWhich = pTableBck_Impl->nRowWhich;
1734             }
1735             break;
1736             case TBL_DEST_TBL:
1737                 *pActItem = pTableBck_Impl->pTableBrush;
1738                 aLbSelect.Enable();
1739                 nWhich = pTableBck_Impl->nTableWhich;
1740             break;
1741         }
1742         String aUserData = GetUserData();
1743         if(!*pActItem)
1744             *pActItem = new SvxBrushItem(nWhich);
1745         FillControls_Impl(**pActItem, aUserData);
1746         delete pActItem;
1747     }
1748     return 0;
1749 }
1750
1751 //-----------------------------------------------------------------------
1752
1753 IMPL_LINK( SvxBackgroundTabPage, ParaDestinationHdl_Impl, ListBox*, pBox )
1754 {
1755     USHORT nSelPos = pBox->GetSelectEntryPos();
1756     if( pParaBck_Impl && pParaBck_Impl->nActPos != nSelPos)
1757     {
1758         SvxBrushItem** pActItem = new (SvxBrushItem*);
1759         switch(pParaBck_Impl->nActPos)
1760         {
1761             case PARA_DEST_PARA:
1762                 *pActItem = pParaBck_Impl->pParaBrush;
1763             break;
1764             case PARA_DEST_CHAR:
1765                 *pActItem = pParaBck_Impl->pCharBrush;
1766             break;
1767         }
1768         pParaBck_Impl->nActPos = nSelPos;
1769         if(0 == aLbSelect.GetSelectEntryPos())  // Brush ausgewaehlt
1770         {
1771             USHORT nWhich = (*pActItem)->Which();
1772             **pActItem = SvxBrushItem( aBgdColor, nWhich );
1773         }
1774         else
1775         {
1776                 SvxGraphicPosition      eNewPos  = GetGraphicPosition_Impl();
1777                 const BOOL                      bIsLink  = aBtnLink.IsChecked();
1778
1779                 if ( !bIsLink && !bIsGraphicValid )
1780                     bIsGraphicValid = LoadLinkedGraphic_Impl();
1781
1782                 if ( bIsLink )
1783                     **pActItem = SvxBrushItem( aBgdGraphicPath,
1784                                                 aBgdGraphicFilter,
1785                                                 eNewPos,
1786                                                 (*pActItem)->Which() );
1787                 else
1788                     **pActItem = SvxBrushItem( aBgdGraphic,
1789                                                 eNewPos,
1790                                                 (*pActItem)->Which() );
1791         }
1792         switch(nSelPos)
1793         {
1794             case PARA_DEST_PARA:
1795                 *pActItem = pParaBck_Impl->pParaBrush;
1796                 aLbSelect.Enable();
1797             break;
1798             case PARA_DEST_CHAR:
1799             {
1800                 *pActItem = pParaBck_Impl->pCharBrush;
1801                 aLbSelect.Enable(FALSE);
1802             }
1803             break;
1804         }
1805         String aUserData = GetUserData();
1806         FillControls_Impl(**pActItem, aUserData);
1807         delete pActItem;
1808     }
1809     return 0;
1810 }
1811
1812 //-----------------------------------------------------------------------
1813
1814 void SvxBackgroundTabPage::FillControls_Impl( const SvxBrushItem& rBgdAttr,
1815                                               const String& rUserData )
1816
1817 /*      [Beschreibung]
1818
1819 */
1820
1821 {
1822     SvxGraphicPosition  ePos = rBgdAttr.GetGraphicPos();
1823     const Color& rColor = rBgdAttr.GetColor();
1824     if(bColTransparency)
1825     {
1826         aColTransMF.SetValue(lcl_TransparencyToPercent(rColor.GetTransparency()));
1827         aColTransMF.SaveValue();
1828         BOOL bEnableTransp = rColor.GetTransparency() < 0xff;
1829         aColTransFT.Enable(bEnableTransp);
1830         aColTransMF.Enable(bEnableTransp);
1831         //the default setting should be "no transparency"
1832         if(!bEnableTransp)
1833             aColTransMF.SetValue(0);
1834     }
1835
1836     if ( GPOS_NONE == ePos || !aLbSelect.IsVisible() )
1837     {
1838         aLbSelect.SelectEntryPos( 0 );
1839         ShowColorUI_Impl();
1840         Color aTrColor( COL_TRANSPARENT );
1841         aBgdColor = rColor;
1842
1843         USHORT nCol = ( aTrColor != aBgdColor ) ?
1844             GetItemId_Impl( aBackgroundColorSet, aBgdColor ) : 0;
1845
1846         if( aTrColor != aBgdColor && nCol == 0)
1847         {
1848             aBackgroundColorSet.SetNoSelection();
1849         }
1850         else
1851         {
1852             aBackgroundColorSet.SelectItem( nCol );
1853         }
1854
1855         pPreviewWin1->NotifyChange( aBgdColor );
1856         if ( aLbSelect.IsVisible() ) // Grafikteil initialisieren
1857         {
1858             aBgdGraphicFilter.Erase();
1859             aBgdGraphicPath.Erase();
1860
1861             if ( !rUserData.Len() )
1862                 aBtnPreview.Check( FALSE );
1863             aBtnLink.Check( FALSE );
1864             aBtnLink.Disable();
1865             pPreviewWin2->NotifyChange( NULL );
1866             SetGraphicPosition_Impl( GPOS_TILED );      // Kacheln als Default
1867         }
1868     }
1869     else
1870     {
1871         const String*   pStrLink   = rBgdAttr.GetGraphicLink();
1872         const String*   pStrFilter = rBgdAttr.GetGraphicFilter();
1873
1874         aLbSelect.SelectEntryPos( 1 );
1875         ShowBitmapUI_Impl();
1876
1877         if ( pStrLink )
1878         {
1879 #ifdef DBG_UTIL
1880             INetURLObject aObj( *pStrLink );
1881             DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" );
1882 #endif
1883             aBgdGraphicPath = *pStrLink;
1884             aBtnLink.Check( TRUE );
1885             aBtnLink.Enable();
1886         }
1887         else
1888         {
1889             aBgdGraphicPath.Erase();
1890             aBtnLink.Check( FALSE );
1891             aBtnLink.Disable();
1892         }
1893
1894         if(bGraphTransparency)
1895         {
1896             const GraphicObject* pObject = rBgdAttr.GetGraphicObject(SfxObjectShell::Current());
1897             if(pObject)
1898                 aGraphTransMF.SetValue(lcl_TransparencyToPercent(pObject->GetAttr().GetTransparency()));
1899             else
1900                 aGraphTransMF.SetValue(0);
1901             aGraphTransMF.SaveValue();
1902         }
1903
1904         FileClickHdl_Impl( &aBtnLink );
1905
1906         if ( pStrFilter )
1907             aBgdGraphicFilter = *pStrFilter;
1908         else
1909             aBgdGraphicFilter.Erase();
1910
1911         if ( !pStrLink || aBtnPreview.IsChecked() )
1912         {
1913             // Grafik ist im Item vorhanden und muss nicht
1914             // geladen werden:
1915
1916             const Graphic* pGraphic =
1917                 rBgdAttr.GetGraphic( SfxObjectShell::Current() );
1918
1919             if ( !pGraphic && aBtnPreview.IsChecked() )
1920                 bIsGraphicValid = LoadLinkedGraphic_Impl();
1921             else if ( pGraphic )
1922             {
1923                 aBgdGraphic = *pGraphic;
1924                 bIsGraphicValid = TRUE;
1925
1926                 if ( !rUserData.Len() )
1927                     aBtnPreview.Check();
1928             }
1929             else
1930             {
1931                 RaiseLoadError_Impl();
1932                 bIsGraphicValid = FALSE;
1933
1934                 if ( !rUserData.Len() )
1935                     aBtnPreview.Check( FALSE );
1936             }
1937         }
1938
1939         if ( aBtnPreview.IsChecked() && bIsGraphicValid )
1940         {
1941             Bitmap aBmp = aBgdGraphic.GetBitmap();
1942             pPreviewWin2->NotifyChange( &aBmp );
1943         }
1944         else
1945             pPreviewWin2->NotifyChange( NULL );
1946
1947         SetGraphicPosition_Impl( ePos );
1948     }
1949 }
1950 /* -----------------------------09.08.2002 14:04------------------------------
1951
1952  ---------------------------------------------------------------------------*/
1953 void SvxBackgroundTabPage::EnableTransparency(BOOL bColor, BOOL bGraphic)
1954 {
1955     bColTransparency  = bColor;
1956     bGraphTransparency = bGraphic;
1957     if(bColor)
1958     {
1959         aColTransFT.Show();
1960         aColTransMF.Show();
1961     }
1962     if(bGraphic)
1963     {
1964         Size aRectSize(aWndPosition.GetSizePixel());
1965         Point aRectPos(aWndPosition.GetPosPixel());
1966         Point aFLPos(aGraphTransFL.GetPosPixel());
1967         Size aTmp(LogicToPixel(Size(RSC_SP_FLGR_SPACE_Y, RSC_SP_FLGR_SPACE_Y), MAP_APPFONT));
1968         long nRectHeight = aFLPos.Y() - aRectPos.Y() - aTmp.Height();
1969         aRectSize.Height() = nRectHeight;
1970         aWndPosition.SetSizePixel(aRectSize);
1971         aWndPosition.Invalidate();
1972     }
1973 }
1974
1975 void SvxBackgroundTabPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
1976 {
1977     SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
1978     if (pFlagItem)
1979     {
1980         UINT32 nFlags=pFlagItem->GetValue();
1981         if ( ( nFlags & SVX_SHOW_TBLCTL ) == SVX_SHOW_TBLCTL )
1982             ShowTblControl();
1983         if ( ( nFlags & SVX_SHOW_PARACTL ) == SVX_SHOW_PARACTL )
1984             ShowParaControl();
1985         if ( ( nFlags & SVX_SHOW_SELECTOR ) == SVX_SHOW_SELECTOR )
1986             ShowSelector();
1987         if ( ( nFlags & SVX_ENABLE_TRANSPARENCY ) == SVX_ENABLE_TRANSPARENCY )
1988             EnableTransparency(TRUE, TRUE);
1989     }
1990 }