svx/source/dialog/grfflt.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: grfflt.cxx,v $
  10  * $Revision: 1.12 $
  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 #include <tools/shl.hxx>
  34 #include <vcl/msgbox.hxx>
  35 #include <sfx2/viewfrm.hxx>
  36 #include <sfx2/viewsh.hxx>
  37 #ifndef _SFXOBJSH_HXX
  38 #include <sfx2/objsh.hxx>
  39 #endif
  40 #include <sfx2/request.hxx>
  41
  42 #include <svx/dialmgr.hxx>
  43 #include <svx/grfflt.hxx>
  44 //#include "grfflt.hrc"
  45 #include <svx/dialogs.hrc>
  46 #include <svx/svxdlg.hxx> //CHINA001
  47
  48 // --------------------
  49 // - SvxGraphicFilter -
  50 // --------------------
  51
  52 ULONG SvxGraphicFilter::ExecuteGrfFilterSlot( SfxRequest& rReq, GraphicObject& rFilterObject )
  53 {
  54     const Graphic&      rGraphic = rFilterObject.GetGraphic();
  55     ULONG                       nRet = SVX_GRAPHICFILTER_UNSUPPORTED_GRAPHICTYPE;
  56
  57     if( rGraphic.GetType() == GRAPHIC_BITMAP )
  58     {
  59         SfxViewFrame*   pViewFrame = SfxViewFrame::Current();
  60         SfxObjectShell* pShell = pViewFrame ? pViewFrame->GetObjectShell() : NULL;
  61         Window*                 pWindow = ( pViewFrame && pViewFrame->GetViewShell() ) ? pViewFrame->GetViewShell()->GetWindow() : NULL;
  62         Graphic                 aGraphic;
  63
  64         switch( rReq.GetSlot() )
  65         {
  66             case( SID_GRFFILTER_INVERT ):
  67             {
  68                 if( pShell )
  69                     pShell->SetWaitCursor( TRUE );
  70
  71                 if( rGraphic.IsAnimated() )
  72                 {
  73                     Animation aAnimation( rGraphic.GetAnimation() );
  74
  75                     if( aAnimation.Invert() )
  76                         aGraphic = aAnimation;
  77                 }
  78                 else
  79                 {
  80                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
  81
  82                     if( aBmpEx.Invert() )
  83                         aGraphic = aBmpEx;
  84                 }
  85
  86                 if( pShell )
  87                     pShell->SetWaitCursor( FALSE );
  88             }
  89             break;
  90
  91             case( SID_GRFFILTER_SMOOTH ):
  92             {
  93                 if( pShell )
  94                     pShell->SetWaitCursor( TRUE );
  95
  96                 if( rGraphic.IsAnimated() )
  97                 {
  98                     Animation aAnimation( rGraphic.GetAnimation() );
  99
 100                     if( aAnimation.Filter( BMP_FILTER_SMOOTH ) )
 101                         aGraphic = aAnimation;
 102                 }
 103                 else
 104                 {
 105                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 106
 107                     if( aBmpEx.Filter( BMP_FILTER_SMOOTH ) )
 108                         aGraphic = aBmpEx;
 109                 }
 110
 111                 if( pShell )
 112                     pShell->SetWaitCursor( FALSE );
 113             }
 114             break;
 115
 116             case( SID_GRFFILTER_SHARPEN ):
 117             {
 118                 if( pShell )
 119                     pShell->SetWaitCursor( TRUE );
 120
 121                 if( rGraphic.IsAnimated() )
 122                 {
 123                     Animation aAnimation( rGraphic.GetAnimation() );
 124
 125                     if( aAnimation.Filter( BMP_FILTER_SHARPEN ) )
 126                         aGraphic = aAnimation;
 127                 }
 128                 else
 129                 {
 130                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 131
 132                     if( aBmpEx.Filter( BMP_FILTER_SHARPEN ) )
 133                         aGraphic = aBmpEx;
 134                 }
 135
 136                 if( pShell )
 137                     pShell->SetWaitCursor( FALSE );
 138             }
 139             break;
 140
 141             case( SID_GRFFILTER_REMOVENOISE ):
 142             {
 143                 if( pShell )
 144                     pShell->SetWaitCursor( TRUE );
 145
 146                 if( rGraphic.IsAnimated() )
 147                 {
 148                     Animation aAnimation( rGraphic.GetAnimation() );
 149
 150                     if( aAnimation.Filter( BMP_FILTER_REMOVENOISE ) )
 151                         aGraphic = aAnimation;
 152                 }
 153                 else
 154                 {
 155                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 156
 157                     if( aBmpEx.Filter( BMP_FILTER_REMOVENOISE ) )
 158                         aGraphic = aBmpEx;
 159                 }
 160
 161                 if( pShell )
 162                     pShell->SetWaitCursor( FALSE );
 163             }
 164             break;
 165
 166             case( SID_GRFFILTER_SOBEL ):
 167             {
 168                 if( pShell )
 169                     pShell->SetWaitCursor( TRUE );
 170
 171                 if( rGraphic.IsAnimated() )
 172                 {
 173                     Animation aAnimation( rGraphic.GetAnimation() );
 174
 175                     if( aAnimation.Filter( BMP_FILTER_SOBEL_GREY ) )
 176                         aGraphic = aAnimation;
 177                 }
 178                 else
 179                 {
 180                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 181
 182                     if( aBmpEx.Filter( BMP_FILTER_SOBEL_GREY ) )
 183                         aGraphic = aBmpEx;
 184                 }
 185
 186                 if( pShell )
 187                     pShell->SetWaitCursor( FALSE );
 188             }
 189             break;
 190
 191             case( SID_GRFFILTER_MOSAIC ):
 192             {
 193                 //CHINA001 GraphicFilterMosaic aDlg( pWindow, rGraphic, 4, 4, FALSE );
 194                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 195                 if(pFact)
 196                 {
 197                     AbstractGraphicFilterDialog* aDlg = pFact->CreateGraphicFilterMosaic( pWindow, rGraphic, 4, 4, FALSE, RID_SVX_GRFFILTER_DLG_MOSAIC );
 198                     DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001
 199                     if( aDlg->Execute() == RET_OK ) //CHINA001 if( aDlg.Execute() == RET_OK )
 200                         aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); //CHINA001 aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 );
 201                     delete aDlg; //add by CHINA001
 202                 }
 203             }
 204             break;
 205
 206             case( SID_GRFFILTER_EMBOSS  ):
 207             {
 208                 //CHINA001 GraphicFilterEmboss aDlg( pWindow, rGraphic, RP_MM );
 209                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 210                 if(pFact)
 211                 {
 212                     AbstractGraphicFilterDialog* aDlg = pFact->CreateGraphicFilterEmboss( pWindow, rGraphic, RP_MM, RID_SVX_GRFFILTER_DLG_EMBOSS );
 213                     DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001
 214                     if( aDlg->Execute() == RET_OK ) //CHINA001 if( aDlg.Execute() == RET_OK )
 215                         aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); //CHINA001 aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 );
 216                     delete aDlg; //add by CHINA001
 217                 }
 218             }
 219             break;
 220
 221             case( SID_GRFFILTER_POSTER  ):
 222             {
 223                 //CHINA001 GraphicFilterPoster aDlg( pWindow, rGraphic, 16 );
 224                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 225                 if(pFact)
 226                 {
 227                     AbstractGraphicFilterDialog* aDlg = pFact->CreateGraphicFilterPosterSepia( pWindow, rGraphic, 16, RID_SVX_GRFFILTER_DLG_POSTER );
 228                     DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001
 229                     if( aDlg->Execute() == RET_OK ) //CHINA001 if( aDlg.Execute() == RET_OK )
 230                         aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); //CHINA001 aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 );
 231                     delete aDlg; //add by CHINA001
 232                 }
 233             }
 234             break;
 235
 236             case( SID_GRFFILTER_POPART  ):
 237             {
 238                 if( pShell )
 239                     pShell->SetWaitCursor( TRUE );
 240
 241                 if( rGraphic.IsAnimated() )
 242                 {
 243                     Animation aAnimation( rGraphic.GetAnimation() );
 244
 245                     if( aAnimation.Filter( BMP_FILTER_POPART ) )
 246                         aGraphic = aAnimation;
 247                 }
 248                 else
 249                 {
 250                     BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 251
 252                     if( aBmpEx.Filter( BMP_FILTER_POPART ) )
 253                         aGraphic = aBmpEx;
 254                 }
 255
 256                 if( pShell )
 257                     pShell->SetWaitCursor( FALSE );
 258             }
 259             break;
 260
 261             case( SID_GRFFILTER_SEPIA ):
 262             {
 263                 //CHINA001 GraphicFilterSepia aDlg( pWindow, rGraphic, 10 );
 264                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 265                 if(pFact)
 266                 {
 267                     AbstractGraphicFilterDialog* aDlg = pFact->CreateGraphicFilterPosterSepia( pWindow, rGraphic, 10, RID_SVX_GRFFILTER_DLG_SEPIA );
 268                     DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001
 269                     if( aDlg->Execute() == RET_OK ) //CHINA001 if( aDlg.Execute() == RET_OK )
 270                         aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); //CHINA001 aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 );
 271                     delete aDlg; //add by CHINA001
 272                 }
 273             }
 274             break;
 275
 276             case( SID_GRFFILTER_SOLARIZE ):
 277             {
 278                 //CHINA001 GraphicFilterSolarize aDlg( pWindow, rGraphic, 128, FALSE );
 279                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 280                 if(pFact)
 281                 {
 282                     AbstractGraphicFilterDialog* aDlg = pFact->CreateGraphicFilterSolarize( pWindow, rGraphic, 128, FALSE, RID_SVX_GRFFILTER_DLG_SOLARIZE );
 283                     DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001
 284                     if( aDlg->Execute() == RET_OK ) //CHINA001 if( aDlg.Execute() == RET_OK )
 285                         aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); //CHINA001 aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 );
 286                     delete aDlg; //add by CHINA001
 287                 }
 288             }
 289             break;
 290
 291             case SID_GRFFILTER :
 292             {
 293                 // do nothing; no error
 294                 nRet = SVX_GRAPHICFILTER_ERRCODE_NONE;
 295                 break;
 296             }
 297
 298             default:
 299             {
 300                 DBG_ERROR( "SvxGraphicFilter: selected filter slot not yet implemented" );
 301                 nRet = SVX_GRAPHICFILTER_UNSUPPORTED_SLOT;
 302             }
 303             break;
 304         }
 305
 306         if( aGraphic.GetType() != GRAPHIC_NONE )
 307         {
 308             rFilterObject.SetGraphic( aGraphic );
 309             nRet = SVX_GRAPHICFILTER_ERRCODE_NONE;
 310         }
 311     }
 312
 313     return nRet;
 314 }
 315
 316 // -----------------------------------------------------------------------------
 317
 318 void SvxGraphicFilter::DisableGraphicFilterSlots( SfxItemSet& rSet )
 319 {
 320     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER ) )
 321         rSet.DisableItem( SID_GRFFILTER );
 322
 323     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_INVERT ) )
 324         rSet.DisableItem( SID_GRFFILTER_INVERT );
 325
 326     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SMOOTH ) )
 327         rSet.DisableItem( SID_GRFFILTER_SMOOTH );
 328
 329     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SHARPEN ) )
 330         rSet.DisableItem( SID_GRFFILTER_SHARPEN );
 331
 332     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_REMOVENOISE ) )
 333         rSet.DisableItem( SID_GRFFILTER_REMOVENOISE );
 334
 335     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SOBEL ) )
 336         rSet.DisableItem( SID_GRFFILTER_SOBEL );
 337
 338     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_MOSAIC ) )
 339         rSet.DisableItem( SID_GRFFILTER_MOSAIC );
 340
 341     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_EMBOSS ) )
 342         rSet.DisableItem( SID_GRFFILTER_EMBOSS );
 343
 344     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_POSTER ) )
 345         rSet.DisableItem( SID_GRFFILTER_POSTER );
 346
 347     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_POPART ) )
 348         rSet.DisableItem( SID_GRFFILTER_POPART );
 349
 350     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SEPIA ) )
 351         rSet.DisableItem( SID_GRFFILTER_SEPIA );
 352
 353     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SOLARIZE ) )
 354         rSet.DisableItem( SID_GRFFILTER_SOLARIZE );
 355 };
 356 /* CHINA001 move to cuigrfflt.cxx
 357 // --------------------------------------
 358 // - GraphicFilterDialog::PreviewWindow -
 359 // --------------------------------------
 360
 361 GraphicFilterDialog::PreviewWindow::PreviewWindow( Window* pParent, const ResId& rResId ) :
 362     Control( pParent, rResId )
 363 {
 364 }
 365
 366 // -----------------------------------------------------------------------------
 367
 368 GraphicFilterDialog::PreviewWindow::~PreviewWindow()
 369 {
 370 }
 371
 372 // -----------------------------------------------------------------------------
 373
 374 void GraphicFilterDialog::PreviewWindow::Paint( const Rectangle& rRect )
 375 {
 376     Control::Paint( rRect );
 377
 378     const Size  aGrfSize( LogicToPixel( maGraphic.GetPrefSize(), maGraphic.GetPrefMapMode() ) );
 379     const Size  aOutSize( GetOutputSizePixel() );
 380     const Point aGrfPos( ( aOutSize.Width() - aGrfSize.Width() ) >> 1,
 381                          ( aOutSize.Height() - aGrfSize.Height() ) >> 1 );
 382
 383     if( maGraphic.IsAnimated() )
 384         maGraphic.StartAnimation( this , aGrfPos, aGrfSize );
 385     else
 386         maGraphic.Draw( this, aGrfPos, aGrfSize );
 387 }
 388
 389 // -----------------------------------------------------------------------------
 390
 391 void GraphicFilterDialog::PreviewWindow::SetGraphic( const Graphic& rGraphic )
 392 {
 393     maGraphic = rGraphic;
 394
 395     if( maGraphic.IsAnimated() || maGraphic.IsTransparent() )
 396         Invalidate();
 397     else
 398         Paint( Rectangle( Point(), GetOutputSizePixel() ) );
 399 }
 400
 401 // -----------------------
 402 // - GraphicFilterDialog -
 403 // -----------------------
 404
 405 GraphicFilterDialog::GraphicFilterDialog( Window* pParent, const ResId& rResId, const Graphic& rGraphic ) :
 406     ModalDialog         ( pParent, rResId ),
 407     mfScaleX            ( 0.0 ),
 408     mfScaleY            ( 0.0 ),
 409     maSizePixel         ( LogicToPixel( rGraphic.GetPrefSize(), rGraphic.GetPrefMapMode() ) ),
 410     maModifyHdl         ( LINK( this, GraphicFilterDialog, ImplModifyHdl ) ),
 411     maPreview           ( this, SVX_RES( CTL_PREVIEW ) ),
 412     maFlParameter       ( this, SVX_RES( FL_PARAMETER ) ),
 413     maBtnOK                     ( this, SVX_RES( BTN_OK ) ),
 414     maBtnCancel         ( this, SVX_RES( BTN_CANCEL ) ),
 415     maBtnHelp           ( this, SVX_RES( BTN_HELP ) )
 416 {
 417     const Size  aPreviewSize( maPreview.GetOutputSizePixel() );
 418     Size                aGrfSize( maSizePixel );
 419
 420     if( rGraphic.GetType() == GRAPHIC_BITMAP &&
 421         aPreviewSize.Width() && aPreviewSize.Height() &&
 422         aGrfSize.Width() && aGrfSize.Height() )
 423     {
 424         const double fGrfWH = (double) aGrfSize.Width() / aGrfSize.Height();
 425         const double fPreWH = (double) aPreviewSize.Width() / aPreviewSize.Height();
 426
 427         if( fGrfWH < fPreWH )
 428         {
 429             aGrfSize.Width() = (long) ( aPreviewSize.Height() * fGrfWH );
 430             aGrfSize.Height()= aPreviewSize.Height();
 431         }
 432         else
 433         {
 434             aGrfSize.Width() = aPreviewSize.Width();
 435             aGrfSize.Height()= (long) ( aPreviewSize.Width() / fGrfWH);
 436         }
 437
 438         mfScaleX = (double) aGrfSize.Width() / maSizePixel.Width();
 439         mfScaleY = (double) aGrfSize.Height() / maSizePixel.Height();
 440
 441         if( !rGraphic.IsAnimated() )
 442         {
 443             BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 444
 445             if( aBmpEx.Scale( aGrfSize, BMP_SCALE_INTERPOLATE ) )
 446                 maGraphic = aBmpEx;
 447         }
 448     }
 449
 450     maTimer.SetTimeoutHdl( LINK( this, GraphicFilterDialog, ImplPreviewTimeoutHdl ) );
 451     maTimer.SetTimeout( 100 );
 452     ImplModifyHdl( NULL );
 453 }
 454
 455 // -----------------------------------------------------------------------------
 456
 457 GraphicFilterDialog::~GraphicFilterDialog()
 458 {
 459 }
 460
 461 // -----------------------------------------------------------------------------
 462
 463 IMPL_LINK( GraphicFilterDialog, ImplPreviewTimeoutHdl, Timer*, pTimer )
 464 {
 465     maTimer.Stop();
 466     maPreview.SetGraphic( GetFilteredGraphic( maGraphic, mfScaleX, mfScaleY ) );
 467
 468     return 0;
 469 }
 470
 471 // -----------------------------------------------------------------------------
 472
 473 IMPL_LINK( GraphicFilterDialog, ImplModifyHdl, void*, p )
 474 {
 475     if( maGraphic.GetType() == GRAPHIC_BITMAP )
 476     {
 477         maTimer.Stop();
 478         maTimer.Start();
 479     }
 480
 481     return 0;
 482 }
 483
 484 // ----------------
 485 // - FilterMosaic -
 486 // ----------------
 487
 488 GraphicFilterMosaic::GraphicFilterMosaic( Window* pParent, const Graphic& rGraphic,
 489                                           USHORT nTileWidth, USHORT nTileHeight, BOOL bEnhanceEdges ) :
 490     GraphicFilterDialog( pParent, SVX_RES( RID_SVX_GRFFILTER_DLG_MOSAIC ), rGraphic ),
 491     maFtWidth   ( this, SVX_RES( DLG_FILTERMOSAIC_FT_WIDTH ) ),
 492     maMtrWidth  ( this, SVX_RES( DLG_FILTERMOSAIC_MTR_WIDTH ) ),
 493     maFtHeight  ( this, SVX_RES( DLG_FILTERMOSAIC_FT_HEIGHT ) ),
 494     maMtrHeight ( this, SVX_RES( DLG_FILTERMOSAIC_MTR_HEIGHT ) ),
 495     maCbxEdges  ( this, SVX_RES( DLG_FILTERMOSAIC_CBX_EDGES ) )
 496 {
 497     FreeResource();
 498
 499     maMtrWidth.SetValue( nTileWidth );
 500     maMtrWidth.SetLast( GetGraphicSizePixel().Width() );
 501     maMtrWidth.SetModifyHdl( GetModifyHdl() );
 502
 503     maMtrHeight.SetValue( nTileHeight );
 504     maMtrHeight.SetLast( GetGraphicSizePixel().Height() );
 505     maMtrHeight.SetModifyHdl( GetModifyHdl() );
 506
 507     maCbxEdges.Check( bEnhanceEdges );
 508     maCbxEdges.SetToggleHdl( GetModifyHdl() );
 509
 510     maMtrWidth.GrabFocus();
 511 }
 512
 513 // -----------------------------------------------------------------------------
 514
 515 GraphicFilterMosaic::~GraphicFilterMosaic()
 516 {
 517 }
 518
 519 // -----------------------------------------------------------------------------
 520
 521 Graphic GraphicFilterMosaic::GetFilteredGraphic( const Graphic& rGraphic,
 522                                                  double fScaleX, double fScaleY )
 523 {
 524     Graphic                     aRet;
 525     const Size          aSize( Max( FRound( GetTileWidth() * fScaleX ), 1L ),
 526                            Max( FRound( GetTileHeight() * fScaleY ), 1L ) );
 527     BmpFilterParam      aParam( aSize );
 528
 529     if( rGraphic.IsAnimated() )
 530     {
 531         Animation aAnim( rGraphic.GetAnimation() );
 532
 533         if( aAnim.Filter( BMP_FILTER_MOSAIC, &aParam ) )
 534         {
 535             if( IsEnhanceEdges() )
 536                 aAnim.Filter( BMP_FILTER_SHARPEN );
 537
 538             aRet = aAnim;
 539         }
 540     }
 541     else
 542     {
 543         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 544
 545         if( aBmpEx.Filter( BMP_FILTER_MOSAIC, &aParam ) )
 546         {
 547             if( IsEnhanceEdges() )
 548                 aBmpEx.Filter( BMP_FILTER_SHARPEN );
 549
 550             aRet = aBmpEx;
 551         }
 552     }
 553
 554     return aRet;
 555 }
 556
 557 // ------------------
 558 // - GraphicFilterSolarize -
 559 // ------------------
 560
 561 GraphicFilterSolarize::GraphicFilterSolarize( Window* pParent, const Graphic& rGraphic,
 562                                               BYTE cGreyThreshold, BOOL bInvert ) :
 563     GraphicFilterDialog ( pParent, SVX_RES( RID_SVX_GRFFILTER_DLG_SOLARIZE ), rGraphic ),
 564     maFtThreshold       ( this, SVX_RES( DLG_FILTERSOLARIZE_FT_THRESHOLD ) ),
 565     maMtrThreshold      ( this, SVX_RES( DLG_FILTERSOLARIZE_MTR_THRESHOLD ) ),
 566     maCbxInvert         ( this, SVX_RES( DLG_FILTERSOLARIZE_CBX_INVERT ) )
 567 {
 568     FreeResource();
 569
 570     maMtrThreshold.SetValue( FRound( cGreyThreshold / 2.55 ) );
 571     maMtrThreshold.SetModifyHdl( GetModifyHdl() );
 572
 573     maCbxInvert.Check( bInvert );
 574     maCbxInvert.SetToggleHdl( GetModifyHdl() );
 575
 576     maMtrThreshold.GrabFocus();
 577 }
 578
 579 // -----------------------------------------------------------------------------
 580
 581 GraphicFilterSolarize::~GraphicFilterSolarize()
 582 {
 583 }
 584
 585 // -----------------------------------------------------------------------------
 586
 587 Graphic GraphicFilterSolarize::GetFilteredGraphic( const Graphic& rGraphic,
 588                                                    double fScaleX, double fScaleY )
 589 {
 590     Graphic                     aRet;
 591     BmpFilterParam      aParam( GetGreyThreshold() );
 592
 593     if( rGraphic.IsAnimated() )
 594     {
 595         Animation aAnim( rGraphic.GetAnimation() );
 596
 597         if( aAnim.Filter( BMP_FILTER_SOLARIZE, &aParam ) )
 598         {
 599             if( IsInvert() )
 600                 aAnim.Invert();
 601
 602             aRet = aAnim;
 603         }
 604     }
 605     else
 606     {
 607         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 608
 609         if( aBmpEx.Filter( BMP_FILTER_SOLARIZE, &aParam ) )
 610         {
 611             if( IsInvert() )
 612                 aBmpEx.Invert();
 613
 614             aRet = aBmpEx;
 615         }
 616     }
 617
 618     return aRet;
 619 }
 620
 621 // ----------------------
 622 // - GraphicFilterSepia -
 623 // ----------------------
 624
 625 GraphicFilterSepia::GraphicFilterSepia( Window* pParent, const Graphic& rGraphic,
 626                                         USHORT nSepiaPercent ) :
 627     GraphicFilterDialog ( pParent, SVX_RES( RID_SVX_GRFFILTER_DLG_SEPIA ), rGraphic ),
 628     maFtSepia           ( this, SVX_RES( DLG_FILTERSEPIA_FT_SEPIA ) ),
 629     maMtrSepia          ( this, SVX_RES( DLG_FILTERSEPIA_MTR_SEPIA ) )
 630 {
 631     FreeResource();
 632
 633     maMtrSepia.SetValue( nSepiaPercent );
 634     maMtrSepia.SetModifyHdl( GetModifyHdl() );
 635
 636     maMtrSepia.GrabFocus();
 637 }
 638
 639 // -----------------------------------------------------------------------------
 640
 641 GraphicFilterSepia::~GraphicFilterSepia()
 642 {
 643 }
 644
 645 // -----------------------------------------------------------------------------
 646
 647 Graphic GraphicFilterSepia::GetFilteredGraphic( const Graphic& rGraphic,
 648                                                 double fScaleX, double fScaleY )
 649 {
 650     Graphic                     aRet;
 651     BmpFilterParam      aParam( GetSepiaPercent() );
 652
 653     if( rGraphic.IsAnimated() )
 654     {
 655         Animation aAnim( rGraphic.GetAnimation() );
 656
 657         if( aAnim.Filter( BMP_FILTER_SEPIA, &aParam ) )
 658             aRet = aAnim;
 659     }
 660     else
 661     {
 662         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 663
 664         if( aBmpEx.Filter( BMP_FILTER_SEPIA, &aParam ) )
 665             aRet = aBmpEx;
 666     }
 667
 668     return aRet;
 669 }
 670
 671 // -----------------------
 672 // - GraphicFilterPoster -
 673 // -----------------------
 674
 675 GraphicFilterPoster::GraphicFilterPoster( Window* pParent, const Graphic& rGraphic,
 676                                           USHORT nPosterCount ) :
 677     GraphicFilterDialog ( pParent, SVX_RES( RID_SVX_GRFFILTER_DLG_POSTER ), rGraphic ),
 678     maFtPoster          ( this, SVX_RES( DLG_FILTERPOSTER_FT_POSTER ) ),
 679     maNumPoster         ( this, SVX_RES( DLG_FILTERPOSTER_NUM_POSTER ) )
 680 {
 681     FreeResource();
 682
 683     maNumPoster.SetFirst( 2 );
 684     maNumPoster.SetLast( rGraphic.GetBitmapEx().GetBitCount() );
 685     maNumPoster.SetValue( nPosterCount );
 686     maNumPoster.SetModifyHdl( GetModifyHdl() );
 687     maNumPoster.GrabFocus();
 688 }
 689
 690 // -----------------------------------------------------------------------------
 691
 692 GraphicFilterPoster::~GraphicFilterPoster()
 693 {
 694 }
 695
 696 // -----------------------------------------------------------------------------
 697
 698 Graphic GraphicFilterPoster::GetFilteredGraphic( const Graphic& rGraphic,
 699                                                  double fScaleX, double fScaleY )
 700 {
 701     Graphic                     aRet;
 702     const USHORT        nPosterCount = GetPosterColorCount();
 703
 704     if( rGraphic.IsAnimated() )
 705     {
 706         Animation aAnim( rGraphic.GetAnimation() );
 707
 708         if( aAnim.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) )
 709             aRet = aAnim;
 710     }
 711     else
 712     {
 713         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 714
 715         if( aBmpEx.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) )
 716             aRet = aBmpEx;
 717     }
 718
 719     return aRet;
 720 }
 721
 722 // -----------------------
 723 // - GraphicFilterEmboss -
 724 // -----------------------
 725
 726 void GraphicFilterEmboss::EmbossControl::MouseButtonDown( const MouseEvent& rEvt )
 727 {
 728     const RECT_POINT eOldRP = GetActualRP();
 729
 730     SvxRectCtl::MouseButtonDown( rEvt );
 731
 732     if( GetActualRP() != eOldRP )
 733         maModifyHdl.Call( this );
 734 }
 735
 736 // -----------------------------------------------------------------------------
 737
 738 GraphicFilterEmboss::GraphicFilterEmboss( Window* pParent, const Graphic& rGraphic,
 739                                           RECT_POINT eLightSource ) :
 740     GraphicFilterDialog ( pParent, SVX_RES( RID_SVX_GRFFILTER_DLG_EMBOSS ), rGraphic ),
 741     maFtLight           ( this, SVX_RES( DLG_FILTEREMBOSS_FT_LIGHT ) ),
 742     maCtlLight          ( this, SVX_RES( DLG_FILTEREMBOSS_CTL_LIGHT ), eLightSource )
 743 {
 744     FreeResource();
 745
 746     maCtlLight.SetModifyHdl( GetModifyHdl() );
 747     maCtlLight.GrabFocus();
 748 }
 749
 750 // -----------------------------------------------------------------------------
 751
 752 GraphicFilterEmboss::~GraphicFilterEmboss()
 753 {
 754 }
 755
 756 // -----------------------------------------------------------------------------
 757
 758 Graphic GraphicFilterEmboss::GetFilteredGraphic( const Graphic& rGraphic,
 759                                                  double fScaleX, double fScaleY )
 760 {
 761     Graphic     aRet;
 762     USHORT      nAzim, nElev;
 763
 764     switch( maCtlLight.GetActualRP() )
 765     {
 766         case( RP_LT ): nAzim = 4500,    nElev = 4500; break;
 767         case( RP_MT ): nAzim = 9000,    nElev = 4500; break;
 768         case( RP_RT ): nAzim = 13500,   nElev = 4500; break;
 769         case( RP_LM ): nAzim = 0,               nElev = 4500; break;
 770         case( RP_MM ): nAzim = 0,               nElev = 9000; break;
 771         case( RP_RM ): nAzim = 18000,   nElev = 4500; break;
 772         case( RP_LB ): nAzim = 31500,   nElev = 4500; break;
 773         case( RP_MB ): nAzim = 27000,   nElev = 4500; break;
 774         case( RP_RB ): nAzim = 22500,   nElev = 4500; break;
 775     }
 776
 777     BmpFilterParam aParam( nAzim, nElev );
 778
 779     if( rGraphic.IsAnimated() )
 780     {
 781         Animation aAnim( rGraphic.GetAnimation() );
 782
 783         if( aAnim.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) )
 784             aRet = aAnim;
 785     }
 786     else
 787     {
 788         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 789
 790         if( aBmpEx.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) )
 791             aRet = aBmpEx;
 792     }
 793
 794     return aRet;
 795 }
 796 */