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