svx/source/cui/tpbitmap.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: tpbitmap.cxx,v $
  10  * $Revision: 1.31 $
  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
  40 //svdraw.hxx
  41 #define _SVDRAW_HXX
  42 #define _SDR_NOITEMS
  43 #define _SDR_NOTOUCH
  44 #define _SDR_NOTRANSFORM
  45 #define _SDR_NOOBJECTS
  46 #define _SDR_NOVIEWS
  47 #define _SDR_NOVIEWMARKER
  48 #define _SDR_NODRAGMETHODS
  49 #define _SDR_NOUNDO
  50 #define _SDR_NOXOUTDEV
  51 #include <vcl/wrkwin.hxx>
  52 #include <tools/shl.hxx>
  53 #include <vcl/msgbox.hxx>
  54 #include <tools/urlobj.hxx>
  55 #ifndef _UNOTOOLS_UCBSTREAMHELPER_HXX
  56 #include <unotools/ucbstreamhelper.hxx>
  57 #endif
  58 #include <svtools/pathoptions.hxx>
  59 #include <sfx2/app.hxx>
  60 #include <sfx2/filedlghelper.hxx>
  61 #include <unotools/localfilehelper.hxx>
  62 #include "com/sun/star/ui/dialogs/TemplateDescription.hpp"
  63 #include <vcl/bmpacc.hxx>
  64
  65 #define _SVX_TPBITMAP_CXX
  66
  67
  68
  69 #include <svx/dialogs.hrc>
  70
  71 #include "helpid.hrc"
  72 #include "xattr.hxx"
  73 #include <svx/xpool.hxx>
  74 #include <svx/xtable.hxx>
  75 #include "xoutbmp.hxx"
  76 #include "drawitem.hxx"
  77 #include "cuitabarea.hxx"
  78 #include "tabarea.hrc"
  79 #include "defdlgname.hxx" //CHINA001 #include "dlgname.hxx"
  80 #include "dlgname.hrc"
  81 #include <svx/svxdlg.hxx> //CHINA001
  82 #include <svx/dialmgr.hxx>
  83 #include "opengrf.hxx"
  84
  85 #define DLGWIN this->GetParent()->GetParent()
  86
  87 /*************************************************************************
  88 |*
  89 |*      Dialog zum Aendern und Definieren der Bitmaps
  90 |*
  91 \************************************************************************/
  92
  93 SvxBitmapTabPage::SvxBitmapTabPage
  94 (
  95     Window* pParent,
  96     const SfxItemSet& rInAttrs
  97 ) :
  98
  99     SvxTabPage                  ( pParent, SVX_RES( RID_SVXPAGE_BITMAP ), rInAttrs ),
 100
 101     aCtlPixel           ( this, SVX_RES( CTL_PIXEL ) ),
 102     aFtPixelEdit        ( this, SVX_RES( FT_PIXEL_EDIT ) ),
 103     aFtColor            ( this, SVX_RES( FT_COLOR ) ),
 104     aLbColor                    ( this, SVX_RES( LB_COLOR ) ),
 105     aFtBackgroundColor  ( this, SVX_RES( FT_BACKGROUND_COLOR ) ),
 106     aLbBackgroundColor  ( this, SVX_RES( LB_BACKGROUND_COLOR ) ),
 107     // This fix text is used only to provide the name for the following
 108     // bitmap list box.  The fixed text is not displayed.
 109     aLbBitmapsHidden    ( this, SVX_RES( FT_BITMAPS_HIDDEN ) ),
 110     aLbBitmaps                  ( this, SVX_RES( LB_BITMAPS ) ),
 111     aFlProp             ( this, SVX_RES( FL_PROP ) ),
 112     aCtlPreview                 ( this, SVX_RES( CTL_PREVIEW ) ),
 113     aBtnAdd                             ( this, SVX_RES( BTN_ADD ) ),
 114     aBtnModify          ( this, SVX_RES( BTN_MODIFY ) ),
 115     aBtnImport          ( this, SVX_RES( BTN_IMPORT ) ),
 116     aBtnDelete          ( this, SVX_RES( BTN_DELETE ) ),
 117     aBtnLoad                    ( this, SVX_RES( BTN_LOAD ) ),
 118     aBtnSave                    ( this, SVX_RES( BTN_SAVE ) ),
 119
 120     aBitmapCtl          ( this, aCtlPreview.GetSizePixel() ),
 121     rOutAttrs           ( rInAttrs ),
 122
 123     pColorTab( NULL ),
 124     pBitmapList( NULL ),
 125
 126     pXPool              ( (XOutdevItemPool*) rInAttrs.GetPool() ),
 127     aXFStyleItem        ( XFILL_BITMAP ),
 128     aXBitmapItem        ( String(), XOBitmap() ),
 129     aXFillAttr          ( pXPool ),
 130     rXFSet              ( aXFillAttr.GetItemSet() )
 131 {
 132     aBtnLoad.SetModeImage( Image( SVX_RES( RID_SVXIMG_LOAD_H ) ), BMP_COLOR_HIGHCONTRAST );
 133     aBtnSave.SetModeImage( Image( SVX_RES( RID_SVXIMG_SAVE_H ) ), BMP_COLOR_HIGHCONTRAST );
 134     FreeResource();
 135
 136     // diese Page braucht ExchangeSupport
 137     SetExchangeSupport();
 138
 139     // Setzen des Output-Devices
 140     rXFSet.Put( aXFStyleItem );
 141     rXFSet.Put( aXBitmapItem );
 142     //aCtlPreview.SetAttributes( aXFillAttr );
 143
 144     aBtnAdd.SetClickHdl( LINK( this, SvxBitmapTabPage, ClickAddHdl_Impl ) );
 145     aBtnImport.SetClickHdl(
 146         LINK( this, SvxBitmapTabPage, ClickImportHdl_Impl ) );
 147     aBtnModify.SetClickHdl(
 148         LINK( this, SvxBitmapTabPage, ClickModifyHdl_Impl ) );
 149     aBtnDelete.SetClickHdl(
 150         LINK( this, SvxBitmapTabPage, ClickDeleteHdl_Impl ) );
 151     aBtnLoad.SetClickHdl( LINK( this, SvxBitmapTabPage, ClickLoadHdl_Impl ) );
 152     aBtnSave.SetClickHdl( LINK( this, SvxBitmapTabPage, ClickSaveHdl_Impl ) );
 153
 154     aLbBitmaps.SetSelectHdl(
 155         LINK( this, SvxBitmapTabPage, ChangeBitmapHdl_Impl ) );
 156     aLbColor.SetSelectHdl(
 157         LINK( this, SvxBitmapTabPage, ChangePixelColorHdl_Impl ) );
 158     aLbBackgroundColor.SetSelectHdl(
 159         LINK( this, SvxBitmapTabPage, ChangeBackgrndColorHdl_Impl ) );
 160
 161 }
 162
 163 // -----------------------------------------------------------------------
 164
 165 void SvxBitmapTabPage::Construct()
 166 {
 167     // Farbtabellen
 168     aLbColor.Fill( pColorTab );
 169     aLbBackgroundColor.CopyEntries( aLbColor );
 170
 171     // Bitmaptabelle
 172     aLbBitmaps.Fill( pBitmapList );
 173 }
 174
 175 // -----------------------------------------------------------------------
 176
 177 void SvxBitmapTabPage::ActivatePage( const SfxItemSet&  )
 178 {
 179     USHORT nPos;
 180     USHORT nCount;
 181
 182     if( *pDlgType == 0 ) // Flaechen-Dialog
 183     {
 184         *pbAreaTP = FALSE;
 185
 186         if( pColorTab )
 187         {
 188             // ColorTable
 189             if( *pnColorTableState & CT_CHANGED ||
 190                 *pnColorTableState & CT_MODIFIED )
 191             {
 192                 if( *pnColorTableState & CT_CHANGED )
 193                     pColorTab = ( (SvxAreaTabDialog*) DLGWIN )->GetNewColorTable();
 194
 195                 // LbColor
 196                 nPos = aLbColor.GetSelectEntryPos();
 197                 aLbColor.Clear();
 198                 aLbColor.Fill( pColorTab );
 199                 nCount = aLbColor.GetEntryCount();
 200                 if( nCount == 0 )
 201                     ; // Dieser Fall sollte nicht auftreten
 202                 else if( nCount <= nPos )
 203                     aLbColor.SelectEntryPos( 0 );
 204                 else
 205                     aLbColor.SelectEntryPos( nPos );
 206
 207                 // LbColorBackground
 208                 nPos = aLbBackgroundColor.GetSelectEntryPos();
 209                 aLbBackgroundColor.Clear();
 210                 aLbBackgroundColor.CopyEntries( aLbColor );
 211                 nCount = aLbBackgroundColor.GetEntryCount();
 212                 if( nCount == 0 )
 213                     ; // Dieser Fall sollte nicht auftreten
 214                 else if( nCount <= nPos )
 215                     aLbBackgroundColor.SelectEntryPos( 0 );
 216                 else
 217                     aLbBackgroundColor.SelectEntryPos( nPos );
 218
 219                 ChangePixelColorHdl_Impl( this );
 220                 ChangeBackgrndColorHdl_Impl( this );
 221             }
 222
 223             // Ermitteln (evtl. abschneiden) des Namens und in
 224             // der GroupBox darstellen
 225             String                      aString( SVX_RES( RID_SVXSTR_TABLE ) ); aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
 226             INetURLObject       aURL( pBitmapList->GetPath() );
 227
 228             aURL.Append( pBitmapList->GetName() );
 229             DBG_ASSERT( aURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
 230
 231             if( aURL.getBase().getLength() > 18 )
 232             {
 233                 aString += String(aURL.getBase()).Copy( 0, 15 );
 234                 aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "..." ) );
 235             }
 236             else
 237                 aString += String(aURL.getBase());
 238
 239             if( *pPageType == PT_BITMAP && *pPos != LISTBOX_ENTRY_NOTFOUND )
 240             {
 241                 aLbBitmaps.SelectEntryPos( *pPos );
 242             }
 243             // Farben koennten geloescht worden sein
 244             ChangeBitmapHdl_Impl( this );
 245
 246             *pPageType = PT_BITMAP;
 247             *pPos = LISTBOX_ENTRY_NOTFOUND;
 248         }
 249     }
 250 }
 251
 252 // -----------------------------------------------------------------------
 253
 254 int SvxBitmapTabPage::DeactivatePage( SfxItemSet* _pSet)
 255 {
 256     if ( CheckChanges_Impl() == -1L )
 257         return KEEP_PAGE;
 258
 259     if( _pSet )
 260         FillItemSet( *_pSet );
 261
 262     return LEAVE_PAGE;
 263 }
 264
 265 // -----------------------------------------------------------------------
 266
 267 BOOL SvxBitmapTabPage::FillItemSet( SfxItemSet& _rOutAttrs )
 268 {
 269     if( *pDlgType == 0 && *pbAreaTP == FALSE ) // Flaechen-Dialog
 270     {
 271         if( *pPageType == PT_BITMAP )
 272         {
 273             // CheckChanges_Impl(); <-- doppelte Abfrage ?
 274
 275             XOBitmap aXOBitmap;
 276             String aString;
 277             USHORT nPos = aLbBitmaps.GetSelectEntryPos();
 278             if( nPos != LISTBOX_ENTRY_NOTFOUND )
 279             {
 280                 aXOBitmap = pBitmapList->GetBitmap( nPos )->GetXBitmap();
 281                 aString = aLbBitmaps.GetSelectEntry();
 282
 283             }
 284             else
 285             {
 286                 aXOBitmap = aBitmapCtl.GetXBitmap();
 287
 288                 // #85339# if it's an array, force conversion to bitmap before using it.
 289                 if(aXOBitmap.GetBitmapType() == XBITMAP_8X8)
 290                     aXOBitmap.GetBitmap();
 291
 292             }
 293             _rOutAttrs.Put( XFillStyleItem( XFILL_BITMAP ) );
 294             _rOutAttrs.Put( XFillBitmapItem( aString, aXOBitmap ) );
 295         }
 296     }
 297     return TRUE;
 298 }
 299
 300 // -----------------------------------------------------------------------
 301
 302 void SvxBitmapTabPage::Reset( const SfxItemSet&  )
 303 {
 304     // aLbBitmaps.SelectEntryPos( 0 );
 305
 306     aBitmapCtl.SetLines( aCtlPixel.GetLineCount() );
 307     aBitmapCtl.SetPixelColor( aLbColor.GetSelectEntryColor() );
 308     aBitmapCtl.SetBackgroundColor( aLbBackgroundColor.GetSelectEntryColor() );
 309     aBitmapCtl.SetBmpArray( aCtlPixel.GetBitmapPixelPtr() );
 310
 311     // Bitmap holen und darstellen
 312     XFillBitmapItem aBmpItem( (const String &) String(), aBitmapCtl.GetXBitmap() );
 313     rXFSet.Put( aBmpItem );
 314     aCtlPreview.SetAttributes( aXFillAttr.GetItemSet() );
 315     aCtlPreview.Invalidate();
 316
 317     ChangeBitmapHdl_Impl( this );
 318
 319     // Status der Buttons ermitteln
 320     if( pBitmapList->Count() )
 321     {
 322         aBtnAdd.Enable();
 323         aBtnModify.Enable();
 324         aBtnDelete.Enable();
 325         aBtnSave.Enable();
 326     }
 327     else
 328     {
 329         aBtnModify.Disable();
 330         aBtnDelete.Disable();
 331         aBtnSave.Disable();
 332     }
 333 }
 334
 335 // -----------------------------------------------------------------------
 336
 337 SfxTabPage* SvxBitmapTabPage::Create( Window* pWindow,
 338                 const SfxItemSet& rSet )
 339 {
 340     return new SvxBitmapTabPage( pWindow, rSet );
 341 }
 342
 343 //------------------------------------------------------------------------
 344
 345 IMPL_LINK( SvxBitmapTabPage, ChangeBitmapHdl_Impl, void *, EMPTYARG )
 346 {
 347     XOBitmap* pXOBitmap = NULL;
 348     int nPos = aLbBitmaps.GetSelectEntryPos();
 349
 350     if( nPos != LISTBOX_ENTRY_NOTFOUND )
 351         pXOBitmap = new XOBitmap( ( (XBitmapEntry*) pBitmapList->GetBitmap( nPos ) )->GetXBitmap() );
 352     else
 353     {
 354         const SfxPoolItem* pPoolItem = NULL;
 355         if( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLSTYLE ), TRUE, &pPoolItem ) )
 356         {
 357             XFillStyle eXFS = (XFillStyle) ( ( const XFillStyleItem* ) pPoolItem )->GetValue();
 358             if( ( XFILL_BITMAP == eXFS ) &&
 359                 ( SFX_ITEM_SET == rOutAttrs.GetItemState( GetWhich( XATTR_FILLBITMAP ), TRUE, &pPoolItem ) ) )
 360             {
 361                 pXOBitmap = new XOBitmap( ( ( const XFillBitmapItem* ) pPoolItem )->GetBitmapValue() );
 362             }
 363         }
 364         if( !pXOBitmap )
 365         {
 366             aLbBitmaps.SelectEntryPos( 0 );
 367             nPos = aLbBitmaps.GetSelectEntryPos();
 368             if( nPos != LISTBOX_ENTRY_NOTFOUND )
 369                 pXOBitmap = new XOBitmap( ( (XBitmapEntry*) pBitmapList->GetBitmap( nPos ) )->GetXBitmap() );
 370         }
 371     }
 372     if( pXOBitmap )
 373     {
 374         //WorkWindow            aTmpWW( DLGWIN );
 375         //VirtualDevice aVD( aTmpWW );
 376         //USHORT        nLines = aCtlPixel.GetLineCount();
 377         //Color aPixelColor, aBackColor;
 378         //BOOL  bPixelColor = FALSE;
 379         //USHORT        nWidth  = pBitmap->GetSizePixel().Width();
 380         //USHORT        nHeight = pBitmap->GetSizePixel().Height();
 381
 382         // #85339# try to convert bitmapped item to array item.
 383         if(pXOBitmap->GetBitmapType() == XBITMAP_IMPORT)
 384         {
 385             Bitmap aBitmap(pXOBitmap->GetBitmap());
 386             Size aSizePixel(aBitmap.GetSizePixel());
 387
 388             if(8 == aSizePixel.Width() && 8 == aSizePixel.Height())
 389             {
 390                 sal_uInt16* pPixelArray = new sal_uInt16[64];
 391                 sal_uInt32 nCol1(0xffffffff); // background
 392                 sal_uInt32 nCol2(0xffffffff); // pixel
 393                 BitmapReadAccess* pAccess = aBitmap.AcquireReadAccess();
 394                 sal_Bool bValid(TRUE);
 395
 396                 if(pAccess)
 397                 {
 398                     for(sal_uInt32 a(0); bValid && a < 64; a++)
 399                     {
 400                         const BitmapColor aBmCol = pAccess->GetColor(a>>3, a%8);
 401                         Color aRgbCol(aBmCol.GetRed(), aBmCol.GetGreen(), aBmCol.GetBlue());
 402                         sal_uInt32 nColVal = aRgbCol.GetRGBColor();
 403
 404                         // test with nCol1
 405                         if(nCol1 != nColVal)
 406                         {
 407                             if(0xffffffff == nCol1)
 408                             {
 409                                 // nCol1 is used first time
 410                                 nCol1 = nColVal;
 411                                 pPixelArray[a] = 0;
 412                             }
 413                             else
 414                             {
 415                                 // test with nCol2
 416                                 if(nCol2 != nColVal)
 417                                 {
 418                                     if(0xffffffff == nCol2)
 419                                     {
 420                                         // nCol2 used first time
 421                                         nCol2 = nColVal;
 422                                         pPixelArray[a] = 1;
 423                                     }
 424                                     else
 425                                     {
 426                                         // Third color detected
 427                                         bValid = FALSE;
 428                                     }
 429                                 }
 430                                 else
 431                                 {
 432                                     // color is pixel color
 433                                     pPixelArray[a] = 1;
 434                                 }
 435                             }
 436                         }
 437                         else
 438                         {
 439                             // color is background color
 440                             pPixelArray[a] = 0;
 441                         }
 442                     }
 443
 444                     // release ReadAccess
 445                     aBitmap.ReleaseAccess(pAccess);
 446                 }
 447                 else
 448                 {
 449                     // no access -> no success
 450                     bValid = FALSE;
 451                 }
 452
 453                 if(bValid)
 454                 {
 455                     Color aCol1(nCol1);
 456                     Color aCol2(nCol2);
 457
 458                     // no pixel color found? Use opposite od background color.
 459                     if(0xffffffff == nCol2)
 460                     {
 461                         aCol2 = Color(
 462                             0xff - aCol1.GetRed(),
 463                             0xff - aCol1.GetGreen(),
 464                             0xff - aCol1.GetBlue());
 465                     }
 466
 467                     // transformation did work, create a new Item
 468                     delete pXOBitmap;
 469                     pXOBitmap = new XOBitmap(pPixelArray, aCol2, aCol1);
 470                 }
 471
 472                 // cleanup
 473                 delete[] pPixelArray;
 474             }
 475         }
 476
 477         aLbColor.SetNoSelection();
 478         aLbBackgroundColor.SetNoSelection();
 479
 480         if( pXOBitmap->GetBitmapType() == XBITMAP_IMPORT )
 481         {
 482             aCtlPixel.Reset();
 483             aCtlPixel.SetPaintable( FALSE );
 484             aCtlPixel.Disable();
 485             aFtPixelEdit.Disable();
 486             aFtColor.Disable();
 487             aLbColor.Disable();
 488             aFtBackgroundColor.Disable();
 489             aLbBackgroundColor.Disable();
 490             aBtnModify.Disable();
 491             aBtnAdd.Disable();
 492         }
 493         else if( pXOBitmap->GetBitmapType() == XBITMAP_8X8 )
 494         {
 495             aCtlPixel.SetPaintable( TRUE );
 496             aCtlPixel.Enable();
 497             aFtPixelEdit.Enable();
 498             aFtColor.Enable();
 499             aLbColor.Enable();
 500             aFtBackgroundColor.Enable();
 501             aLbBackgroundColor.Enable();
 502             aBtnModify.Enable();
 503             aBtnAdd.Enable();
 504
 505             // Setzen des PixelControls
 506             aCtlPixel.SetXBitmap( *pXOBitmap );
 507
 508             Color aPixelColor = pXOBitmap->GetPixelColor();
 509             Color aBackColor  = pXOBitmap->GetBackgroundColor();
 510
 511             aBitmapCtl.SetPixelColor( aPixelColor );
 512             aBitmapCtl.SetBackgroundColor( aBackColor );
 513
 514             // Wenn der Eintrag nicht in der Listbox ist, wird die Farbe
 515             // temporaer hinzugenommen
 516             if( 0 == aLbBitmaps.GetSelectEntryPos() )
 517             {
 518                 aLbColor.SelectEntry( Color( COL_BLACK ) );
 519                 ChangePixelColorHdl_Impl( this );
 520             }
 521             else
 522                 aLbColor.SelectEntry( aPixelColor );
 523             if( aLbColor.GetSelectEntryCount() == 0 )
 524             {
 525                 aLbColor.InsertEntry( aPixelColor, String() );
 526                 aLbColor.SelectEntry( aPixelColor );
 527             }
 528             aLbBackgroundColor.SelectEntry( aBackColor );
 529             if( aLbBackgroundColor.GetSelectEntryCount() == 0 )
 530             {
 531                 aLbBackgroundColor.InsertEntry( aBackColor, String() );
 532                 aLbBackgroundColor.SelectEntry( aBackColor );
 533             }
 534         }
 535         aCtlPixel.Invalidate();
 536
 537         // Bitmap darstellen
 538         XFillBitmapItem aXBmpItem( (const String &) String(), *pXOBitmap );
 539         rXFSet.Put( aXBmpItem );
 540
 541         aCtlPreview.SetAttributes( aXFillAttr.GetItemSet() );
 542         aCtlPreview.Invalidate();
 543
 544         bBmpChanged = FALSE;
 545         delete pXOBitmap;
 546     }
 547     return 0L;
 548 }
 549
 550 // -----------------------------------------------------------------------
 551
 552 long SvxBitmapTabPage::CheckChanges_Impl()
 553 {
 554     USHORT nPos = aLbBitmaps.GetSelectEntryPos();
 555     if( nPos != LISTBOX_ENTRY_NOTFOUND )
 556     {
 557         String aString = aLbBitmaps.GetSelectEntry();
 558
 559         if( bBmpChanged )
 560         {
 561             ResMgr& rMgr = DIALOG_MGR();
 562             Image aWarningBoxImage = WarningBox::GetStandardImage();
 563             //CHINA001 SvxMessDialog aMessDlg( DLGWIN,
 564             //CHINA001  String( SVX_RES( RID_SVXSTR_BITMAP, rMgr ) ),
 565             //CHINA001  String( SVX_RES( RID_SVXSTR_ASK_CHANGE_BITMAP, rMgr ) ),
 566             //CHINA001  &aWarningBoxImage );
 567             SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 568             DBG_ASSERT(pFact, "Dialogdiet fail!");//CHINA001
 569             AbstractSvxMessDialog* aMessDlg = pFact->CreateSvxMessDialog( DLGWIN, RID_SVXDLG_MESSBOX,
 570                                                         String( ResId( RID_SVXSTR_BITMAP, rMgr ) ),
 571                                                         String( ResId( RID_SVXSTR_ASK_CHANGE_BITMAP, rMgr ) ),
 572                                                         &aWarningBoxImage  );
 573             DBG_ASSERT(aMessDlg, "Dialogdiet fail!");//CHINA001
 574             aMessDlg->SetButtonText( MESS_BTN_1, //CHINA001 aMessDlg.SetButtonText( MESS_BTN_1,
 575                                     String( ResId( RID_SVXSTR_CHANGE, rMgr ) ) );
 576             aMessDlg->SetButtonText( MESS_BTN_2, //CHINA001 aMessDlg.SetButtonText( MESS_BTN_2,
 577                                     String( ResId( RID_SVXSTR_ADD, rMgr ) ) );
 578
 579             short nRet = aMessDlg->Execute(); //CHINA001 short nRet = aMessDlg.Execute();
 580
 581             switch( nRet )
 582             {
 583                 case RET_BTN_1: // Aendern
 584                 {
 585                     ClickModifyHdl_Impl( this );
 586                 }
 587                 break;
 588
 589                 case RET_BTN_2: // Hinzufuegen
 590                 {
 591                     ClickAddHdl_Impl( this );
 592                     nPos = aLbBitmaps.GetSelectEntryPos();
 593                 }
 594                 break;
 595
 596                 case RET_CANCEL:
 597                     // return( -1L );
 598                 break;
 599                 // return( TRUE ); // Abbruch
 600             }
 601             delete aMessDlg; //add by CHINA001
 602         }
 603     }
 604     nPos = aLbBitmaps.GetSelectEntryPos();
 605     if( nPos != LISTBOX_ENTRY_NOTFOUND )
 606         *pPos = nPos;
 607     return 0L;
 608 }
 609
 610 //------------------------------------------------------------------------
 611
 612 IMPL_LINK( SvxBitmapTabPage, ClickAddHdl_Impl, void *, EMPTYARG )
 613 {
 614     ResMgr& rMgr = DIALOG_MGR();
 615     String aNewName( ResId( RID_SVXSTR_BITMAP, rMgr ) );
 616     String aDesc( ResId( RID_SVXSTR_DESC_NEW_BITMAP, rMgr ) );
 617     String aName;
 618
 619     long nCount = pBitmapList->Count();
 620     long j = 1;
 621     BOOL bDifferent = FALSE;
 622
 623     while( !bDifferent )
 624     {
 625         aName  = aNewName;
 626         aName += sal_Unicode(' ');
 627         aName += UniString::CreateFromInt32( j++ );
 628         bDifferent = TRUE;
 629
 630         for( long i = 0; i < nCount && bDifferent; i++ )
 631             if( aName == pBitmapList->GetBitmap( i )->GetName() )
 632                 bDifferent = FALSE;
 633     }
 634
 635     //CHINA001 SvxNameDialog* pDlg     = new SvxNameDialog( DLGWIN, aName, aDesc );
 636     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 637     DBG_ASSERT(pFact, "Dialogdiet fail!");//CHINA001
 638     AbstractSvxNameDialog* pDlg = pFact->CreateSvxNameDialog( DLGWIN, aName, aDesc, RID_SVXDLG_NAME );
 639     DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001
 640     WarningBox*    pWarnBox = NULL;
 641     USHORT         nError   = RID_SVXSTR_WARN_NAME_DUPLICATE;
 642
 643     while( pDlg->Execute() == RET_OK )
 644     {
 645         pDlg->GetName( aName );
 646
 647         bDifferent = TRUE;
 648
 649         for( long i = 0; i < nCount && bDifferent; i++ )
 650             if( aName == pBitmapList->GetBitmap( i )->GetName() )
 651                 bDifferent = FALSE;
 652
 653         if( bDifferent ) {
 654             nError = 0;
 655             break;
 656         }
 657
 658         if( !pWarnBox )
 659         {
 660             pWarnBox = new WarningBox( DLGWIN,
 661                                        WinBits( WB_OK_CANCEL ),
 662                                        String( ResId( nError, rMgr ) ) );
 663             pWarnBox->SetHelpId( HID_WARN_NAME_DUPLICATE );
 664         }
 665
 666         if( pWarnBox->Execute() != RET_OK )
 667             break;
 668     }
 669     //Rectangle aDlgRect( pDlg->GetPosPixel(), pDlg->GetSizePixel() );
 670     delete pDlg;
 671     delete pWarnBox;
 672
 673     if( !nError )
 674     {
 675         XBitmapEntry* pEntry = 0;
 676         if( aCtlPixel.IsEnabled() )
 677         {
 678             XOBitmap aXOBitmap = aBitmapCtl.GetXBitmap();
 679
 680             // #85339# if it's an array, force conversion to bitmap before using it.
 681             if(aXOBitmap.GetBitmapType() == XBITMAP_8X8)
 682                 aXOBitmap.GetBitmap();
 683
 684             pEntry = new XBitmapEntry( aXOBitmap, aName );
 685         }
 686         else // Es muss sich um eine nicht vorhandene importierte Bitmap handeln
 687         {
 688             const SfxPoolItem* pPoolItem = NULL;
 689             if( SFX_ITEM_SET == rOutAttrs.GetItemState( XATTR_FILLBITMAP, TRUE, &pPoolItem ) )
 690             {
 691                 XOBitmap aXOBitmap( ( ( const XFillBitmapItem* ) pPoolItem )->GetBitmapValue() );
 692                 pEntry = new XBitmapEntry( aXOBitmap, aName );
 693             }
 694         }
 695
 696         DBG_ASSERT( pEntry, "SvxBitmapTabPage::ClickAddHdl_Impl(), pEntry == 0 ?" );
 697
 698         if( pEntry )
 699         {
 700             pBitmapList->Insert( pEntry );
 701
 702             aLbBitmaps.Append( pEntry );
 703             aLbBitmaps.SelectEntryPos( aLbBitmaps.GetEntryCount() - 1 );
 704
 705 #ifdef WNT
 706             // hack: #31355# W.P.
 707             Rectangle aRect( aLbBitmaps.GetPosPixel(), aLbBitmaps.GetSizePixel() );
 708             if( TRUE ) {                                // ??? overlapped with pDlg
 709                                         // and srolling
 710                 Invalidate( aRect );
 711                 //aLbBitmaps.Invalidate();
 712             }
 713 #endif
 714
 715             // Flag fuer modifiziert setzen
 716             *pnBitmapListState |= CT_MODIFIED;
 717
 718             ChangeBitmapHdl_Impl( this );
 719         }
 720     }
 721
 722     // Status der Buttons ermitteln
 723     if( pBitmapList->Count() )
 724     {
 725         aBtnModify.Enable();
 726         aBtnDelete.Enable();
 727         aBtnSave.Enable();
 728     }
 729     return 0L;
 730 }
 731
 732
 733 /******************************************************************************/
 734 /******************************************************************************/
 735
 736
 737 //------------------------------------------------------------------------
 738
 739 #ifdef _MSC_VER
 740 #pragma optimize ( "", off )
 741 #endif
 742
 743 IMPL_LINK( SvxBitmapTabPage, ClickImportHdl_Impl, void *, EMPTYARG )
 744 {
 745     ResMgr& rMgr = DIALOG_MGR();
 746     SvxOpenGraphicDialog aDlg( UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "Import" ) ) );
 747     aDlg.EnableLink(sal_False);
 748
 749     if( !aDlg.Execute() )
 750     {
 751         Graphic                 aGraphic;
 752         int                     nError = 1;
 753
 754         EnterWait();
 755         nError = aDlg.GetGraphic( aGraphic );
 756         LeaveWait();
 757
 758         if( !nError )
 759         {
 760             String aDesc( ResId(RID_SVXSTR_DESC_EXT_BITMAP, rMgr) );
 761             WarningBox*    pWarnBox = NULL;
 762
 763             // convert file URL to UI name
 764             String                      aName;
 765             INetURLObject       aURL( aDlg.GetPath() );
 766             //CHINA001 SvxNameDialog*  pDlg = new SvxNameDialog( DLGWIN, aURL.GetName().GetToken( 0, '.' ), aDesc );
 767             SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 768             DBG_ASSERT(pFact, "Dialogdiet fail!");//CHINA001
 769             AbstractSvxNameDialog* pDlg = pFact->CreateSvxNameDialog( DLGWIN, String(aURL.GetName()).GetToken( 0, '.' ), aDesc, RID_SVXDLG_NAME );
 770             DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001
 771             nError = RID_SVXSTR_WARN_NAME_DUPLICATE;
 772
 773             while( pDlg->Execute() == RET_OK )
 774             {
 775                 pDlg->GetName( aName );
 776
 777                 BOOL bDifferent = TRUE;
 778                 long nCount     = pBitmapList->Count();
 779
 780                 for( long i = 0; i < nCount && bDifferent; i++ )
 781                     if( aName == pBitmapList->GetBitmap( i )->GetName() )
 782                         bDifferent = FALSE;
 783
 784                 if( bDifferent ) {
 785                     nError = 0;
 786                     break;
 787                 }
 788
 789                 if( !pWarnBox )
 790                 {
 791                     pWarnBox = new WarningBox( DLGWIN,
 792                                                WinBits( WB_OK_CANCEL ),
 793                                                String( ResId( nError, rMgr ) ) );
 794                     pWarnBox->SetHelpId( HID_WARN_NAME_DUPLICATE );
 795                 }
 796
 797
 798                 if( pWarnBox->Execute() != RET_OK )
 799                     break;
 800             }
 801             //Rectangle aDlgRect( pDlg->GetPosPixel(), pDlg->GetSizePixel() );
 802             delete pDlg;
 803             delete pWarnBox;
 804
 805             if( !nError )
 806             {
 807                 Bitmap aBmp( aGraphic.GetBitmap() );
 808                 XBitmapEntry* pEntry =
 809                     new XBitmapEntry( XOBitmap( aBmp ), aName );
 810                 pBitmapList->Insert( pEntry );
 811
 812                 aLbBitmaps.Append( pEntry );
 813                 aLbBitmaps.SelectEntryPos( aLbBitmaps.GetEntryCount() - 1 );
 814
 815 #ifdef WNT
 816                 // hack: #31355# W.P.
 817                 Rectangle aRect( aLbBitmaps.GetPosPixel(), aLbBitmaps.GetSizePixel() );
 818                 if( TRUE ) {                            // ??? overlapped with pDlg
 819                                             // and srolling
 820                     Invalidate( aRect );
 821                     //aLbBitmaps.Invalidate();
 822                 }
 823 #endif
 824
 825                 // Flag fuer modifiziert setzen
 826                 *pnBitmapListState |= CT_MODIFIED;
 827
 828                 ChangeBitmapHdl_Impl( this );
 829             }
 830         }
 831         else
 832             // Graphik konnte nicht geladen werden
 833             ErrorBox( DLGWIN,
 834                       WinBits( WB_OK ),
 835                       String( ResId( RID_SVXSTR_READ_DATA_ERROR, rMgr ) ) ).Execute();
 836     }
 837
 838     return 0L;
 839 }
 840
 841 #ifdef _MSC_VER
 842 #pragma optimize ( "", on )
 843 #endif
 844
 845 //------------------------------------------------------------------------
 846
 847 IMPL_LINK( SvxBitmapTabPage, ClickModifyHdl_Impl, void *, EMPTYARG )
 848 {
 849     USHORT nPos = aLbBitmaps.GetSelectEntryPos();
 850
 851     if ( nPos != LISTBOX_ENTRY_NOTFOUND )
 852     {
 853         ResMgr& rMgr = DIALOG_MGR();
 854         String aNewName( ResId( RID_SVXSTR_BITMAP, rMgr ) );
 855         String aDesc( ResId( RID_SVXSTR_DESC_NEW_BITMAP, rMgr ) );
 856         String aName( pBitmapList->GetBitmap( nPos )->GetName() );
 857         String aOldName = aName;
 858
 859         //CHINA001 SvxNameDialog* pDlg = new SvxNameDialog( DLGWIN, aName, aDesc );
 860         SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 861         DBG_ASSERT(pFact, "Dialogdiet fail!");//CHINA001
 862         AbstractSvxNameDialog* pDlg = pFact->CreateSvxNameDialog( DLGWIN, aName, aDesc, RID_SVXDLG_NAME );
 863         DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001
 864
 865         long nCount = pBitmapList->Count();
 866         BOOL bDifferent = FALSE;
 867         BOOL bLoop = TRUE;
 868
 869         while( bLoop && pDlg->Execute() == RET_OK )
 870         {
 871             pDlg->GetName( aName );
 872             bDifferent = TRUE;
 873
 874             for( long i = 0; i < nCount && bDifferent; i++ )
 875             {
 876                 if( aName == pBitmapList->GetBitmap( i )->GetName() &&
 877                     aName != aOldName )
 878                     bDifferent = FALSE;
 879             }
 880
 881             if( bDifferent )
 882             {
 883                 bLoop = FALSE;
 884                 XBitmapEntry* pEntry = pBitmapList->GetBitmap( nPos );
 885
 886                 pEntry->SetName( aName );
 887
 888                 XOBitmap aXOBitmap = aBitmapCtl.GetXBitmap();
 889
 890                 // #85339# if it's an array, force conversion to bitmap before using it.
 891                 if(aXOBitmap.GetBitmapType() == XBITMAP_8X8)
 892                     aXOBitmap.GetBitmap();
 893
 894                 pEntry->SetXBitmap( aXOBitmap );
 895
 896                 aLbBitmaps.Modify( pEntry, nPos );
 897                 aLbBitmaps.SelectEntryPos( nPos );
 898
 899                 // Flag fuer modifiziert setzen
 900                 *pnBitmapListState |= CT_MODIFIED;
 901
 902                 bBmpChanged = FALSE;
 903             }
 904             else
 905             {
 906                 WarningBox aBox( DLGWIN, WinBits( WB_OK ), String( ResId( RID_SVXSTR_WARN_NAME_DUPLICATE, rMgr ) ) );
 907                 aBox.SetHelpId( HID_WARN_NAME_DUPLICATE );
 908                 aBox.Execute();
 909             }
 910         }
 911         delete pDlg;
 912     }
 913     return 0L;
 914 }
 915
 916 //------------------------------------------------------------------------
 917
 918 IMPL_LINK( SvxBitmapTabPage, ClickDeleteHdl_Impl, void *, EMPTYARG )
 919 {
 920     USHORT nPos = aLbBitmaps.GetSelectEntryPos();
 921
 922     if( nPos != LISTBOX_ENTRY_NOTFOUND )
 923     {
 924         QueryBox aQueryBox( DLGWIN, WinBits( WB_YES_NO | WB_DEF_NO ),
 925 //!                     SVX_RES( RID_SVXSTR_DEL_BITMAP ),
 926             String( SVX_RES( RID_SVXSTR_ASK_DEL_BITMAP ) ) );
 927
 928         if( aQueryBox.Execute() == RET_YES )
 929         {
 930             delete pBitmapList->Remove( nPos );
 931             aLbBitmaps.RemoveEntry( nPos );
 932             aLbBitmaps.SelectEntryPos( 0 );
 933
 934             aCtlPreview.Invalidate();
 935             aCtlPixel.Invalidate();
 936
 937             ChangeBitmapHdl_Impl( this );
 938
 939             // Flag fuer modifiziert setzen
 940             *pnBitmapListState |= CT_MODIFIED;
 941         }
 942     }
 943     // Status der Buttons ermitteln
 944     if( !pBitmapList->Count() )
 945     {
 946         aBtnModify.Disable();
 947         aBtnDelete.Disable();
 948         aBtnSave.Disable();
 949     }
 950     return 0L;
 951 }
 952
 953 // -----------------------------------------------------------------------
 954
 955 IMPL_LINK( SvxBitmapTabPage, ClickLoadHdl_Impl, void *, EMPTYARG )
 956 {
 957     USHORT nReturn = RET_YES;
 958     ResMgr& rMgr = DIALOG_MGR();
 959
 960     if ( *pnBitmapListState & CT_MODIFIED )
 961     {
 962         nReturn = WarningBox( DLGWIN, WinBits( WB_YES_NO_CANCEL ),
 963             String( ResId( RID_SVXSTR_WARN_TABLE_OVERWRITE, rMgr ) ) ).Execute();
 964
 965         if ( nReturn == RET_YES )
 966             pBitmapList->Save();
 967     }
 968
 969     if ( nReturn != RET_CANCEL )
 970     {
 971         ::sfx2::FileDialogHelper aDlg(
 972             com::sun::star::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
 973             0 );
 974         String aStrFilterType( RTL_CONSTASCII_USTRINGPARAM( "*.sob" ) );
 975         aDlg.AddFilter( aStrFilterType, aStrFilterType );
 976         INetURLObject aFile( SvtPathOptions().GetPalettePath() );
 977         aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::NO_DECODE ) );
 978
 979         if ( aDlg.Execute() == ERRCODE_NONE )
 980         {
 981             EnterWait();
 982             INetURLObject aURL( aDlg.GetPath() );
 983             INetURLObject aPathURL( aURL );
 984
 985             aPathURL.removeSegment();
 986             aPathURL.removeFinalSlash();
 987
 988             // Tabelle speichern
 989             XBitmapList* pBmpList = new XBitmapList( aPathURL.GetMainURL( INetURLObject::NO_DECODE ), pXPool );
 990             pBmpList->SetName( aURL.getName() );
 991             if( pBmpList->Load() )
 992             {
 993                 if( pBmpList )
 994                 {
 995                     // Pruefen, ob Tabelle geloescht werden darf:
 996                     if( pBitmapList != ( (SvxAreaTabDialog*) DLGWIN )->GetBitmapList() )
 997                         delete pBitmapList;
 998
 999                     pBitmapList = pBmpList;
1000                     ( (SvxAreaTabDialog*) DLGWIN )->SetNewBitmapList( pBitmapList );
1001
1002                     aLbBitmaps.Clear();
1003                     aLbBitmaps.Fill( pBitmapList );
1004                     Reset( rOutAttrs );
1005
1006                     pBitmapList->SetName( aURL.getName() );
1007
1008                     // Ermitteln (evtl. abschneiden) des Namens und in
1009                     // der GroupBox darstellen
1010                     String aString( ResId( RID_SVXSTR_TABLE, rMgr ) );
1011                     aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
1012
1013                     if ( aURL.getBase().getLength() > 18 )
1014                     {
1015                         aString += String(aURL.getBase()).Copy( 0, 15 );
1016                         aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "..." ) );
1017                     }
1018                     else
1019                         aString += String(aURL.getBase());
1020
1021                     // Flag fuer gewechselt setzen
1022                     *pnBitmapListState |= CT_CHANGED;
1023                     // Flag fuer modifiziert entfernen
1024                     *pnBitmapListState &= ~CT_MODIFIED;
1025                 }
1026                 LeaveWait();
1027             }
1028             else
1029             {
1030                 LeaveWait();
1031                 ErrorBox( DLGWIN, WinBits( WB_OK ),
1032                     String( ResId( RID_SVXSTR_READ_DATA_ERROR, rMgr ) ) ).Execute();
1033             }
1034         }
1035     }
1036
1037     // Status der Buttons ermitteln
1038     if( pBitmapList->Count() )
1039     {
1040         aBtnModify.Enable();
1041         aBtnDelete.Enable();
1042         aBtnSave.Enable();
1043     }
1044     else
1045     {
1046         aBtnModify.Disable();
1047         aBtnDelete.Disable();
1048         aBtnSave.Disable();
1049     }
1050     return 0L;
1051 }
1052
1053 // -----------------------------------------------------------------------
1054
1055 IMPL_LINK( SvxBitmapTabPage, ClickSaveHdl_Impl, void *, EMPTYARG )
1056 {
1057        ::sfx2::FileDialogHelper aDlg(
1058         com::sun::star::ui::dialogs::TemplateDescription::FILESAVE_SIMPLE, 0 );
1059     String aStrFilterType( RTL_CONSTASCII_USTRINGPARAM( "*.sob" ) );
1060     aDlg.AddFilter( aStrFilterType, aStrFilterType );
1061
1062     INetURLObject aFile( SvtPathOptions().GetPalettePath() );
1063     DBG_ASSERT( aFile.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
1064
1065     if( pBitmapList->GetName().Len() )
1066     {
1067         aFile.Append( pBitmapList->GetName() );
1068
1069         if( !aFile.getExtension().getLength() )
1070             aFile.SetExtension( UniString::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "sob" ) ) );
1071     }
1072
1073     aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::NO_DECODE ) );
1074     if ( aDlg.Execute() == ERRCODE_NONE )
1075     {
1076         INetURLObject   aURL( aDlg.GetPath() );
1077         INetURLObject   aPathURL( aURL );
1078
1079         aPathURL.removeSegment();
1080         aPathURL.removeFinalSlash();
1081
1082         pBitmapList->SetName( aURL.getName() );
1083         pBitmapList->SetPath( aPathURL.GetMainURL( INetURLObject::NO_DECODE ) );
1084
1085         if( pBitmapList->Save() )
1086         {
1087             // Ermitteln (evtl. abschneiden) des Namens und in
1088             // der GroupBox darstellen
1089             String aString( SVX_RES( RID_SVXSTR_TABLE ) );
1090             aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );
1091
1092             if ( aURL.getBase().getLength() > 18 )
1093             {
1094                 aString += String(aURL.getBase()).Copy( 0, 15 );
1095                 aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "..." ) );
1096             }
1097             else
1098                 aString += String(aURL.getBase());
1099
1100             // Flag fuer gespeichert setzen
1101             *pnBitmapListState |= CT_SAVED;
1102             // Flag fuer modifiziert entfernen
1103             *pnBitmapListState &= ~CT_MODIFIED;
1104         }
1105         else
1106         {
1107             ErrorBox( DLGWIN, WinBits( WB_OK ),
1108                 String( SVX_RES( RID_SVXSTR_WRITE_DATA_ERROR ) ) ).Execute();
1109         }
1110     }
1111
1112     return 0L;
1113 }
1114
1115 //------------------------------------------------------------------------
1116
1117 IMPL_LINK( SvxBitmapTabPage, ChangePixelColorHdl_Impl, void *, EMPTYARG )
1118 {
1119     aCtlPixel.SetPixelColor( aLbColor.GetSelectEntryColor() );
1120     aCtlPixel.Invalidate();
1121
1122     aBitmapCtl.SetPixelColor( aLbColor.GetSelectEntryColor() );
1123
1124     // Bitmap holen und darstellen
1125     rXFSet.Put( XFillBitmapItem( String(), aBitmapCtl.GetXBitmap() ) );
1126     aCtlPreview.SetAttributes( aXFillAttr.GetItemSet() );
1127     aCtlPreview.Invalidate();
1128
1129     bBmpChanged = TRUE;
1130
1131     return 0L;
1132 }
1133
1134 //------------------------------------------------------------------------
1135
1136 IMPL_LINK( SvxBitmapTabPage, ChangeBackgrndColorHdl_Impl, void *, EMPTYARG )
1137 {
1138     aCtlPixel.SetBackgroundColor( aLbBackgroundColor.GetSelectEntryColor() );
1139     aCtlPixel.Invalidate();
1140
1141     aBitmapCtl.SetBackgroundColor( aLbBackgroundColor.GetSelectEntryColor() );
1142
1143     // Bitmap holen und darstellen
1144     rXFSet.Put( XFillBitmapItem( String(), aBitmapCtl.GetXBitmap() ) );
1145     aCtlPreview.SetAttributes( aXFillAttr.GetItemSet() );
1146     aCtlPreview.Invalidate();
1147
1148     bBmpChanged = TRUE;
1149
1150     return 0L;
1151 }
1152
1153 //------------------------------------------------------------------------
1154
1155 void SvxBitmapTabPage::PointChanged( Window* pWindow, RECT_POINT )
1156 {
1157     if( pWindow == &aCtlPixel )
1158     {
1159         aBitmapCtl.SetBmpArray( aCtlPixel.GetBitmapPixelPtr() );
1160
1161         // Bitmap holen und darstellen
1162         rXFSet.Put( XFillBitmapItem( String(), aBitmapCtl.GetXBitmap() ) );
1163         aCtlPreview.SetAttributes( aXFillAttr.GetItemSet() );
1164         aCtlPreview.Invalidate();
1165
1166         bBmpChanged = TRUE;
1167     }
1168 }
1169
1170
1171
1172
1173 Window* SvxBitmapTabPage::GetParentLabeledBy( const Window* pLabeled ) const
1174 {
1175     if (pLabeled == &aLbBitmaps)
1176         return const_cast<FixedText*>(&aLbBitmapsHidden);
1177     else
1178         return SvxTabPage::GetParentLabeledBy (pLabeled);
1179 }