cui/source/dialogs/cuigrfflt.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <tools/shl.hxx>
  21 #include <vcl/msgbox.hxx>
  22 #include <sfx2/viewfrm.hxx>
  23 #include <sfx2/viewsh.hxx>
  24 #include <sfx2/objsh.hxx>
  25 #include <sfx2/request.hxx>
  26 #include <dialmgr.hxx>
  27 #include "cuigrfflt.hxx"
  28 #include "grfflt.hrc"
  29 #include <cuires.hrc>
  30 #include <svx/dialogs.hrc> // RID_SVX_GRFFILTER_DLG_...
  31
  32 // --------------------------------------
  33 // - GraphicFilterDialog::PreviewWindow -
  34 // --------------------------------------
  35
  36 GraphicFilterDialog::PreviewWindow::PreviewWindow( Window* pParent, const ResId& rResId ) :
  37     Control( pParent, rResId )
  38 {
  39 }
  40
  41 // -----------------------------------------------------------------------------
  42
  43 GraphicFilterDialog::PreviewWindow::~PreviewWindow()
  44 {
  45 }
  46
  47 // -----------------------------------------------------------------------------
  48
  49 void GraphicFilterDialog::PreviewWindow::Paint( const Rectangle& rRect )
  50 {
  51     Control::Paint( rRect );
  52
  53     const Size  aOutputSize( GetOutputSizePixel() );
  54
  55     if( maGraphic.IsAnimated() )
  56     {
  57         const Size  aGraphicSize( LogicToPixel( maGraphic.GetPrefSize(), maGraphic.GetPrefMapMode() ) );
  58         const Point aGraphicPosition( ( aOutputSize.Width()  - aGraphicSize.Width()  ) >> 1,
  59                                       ( aOutputSize.Height() - aGraphicSize.Height() ) >> 1 );
  60         maGraphic.StartAnimation( this, aGraphicPosition, aGraphicSize );
  61     }
  62     else
  63     {
  64         const Size  aGraphicSize( maGraphic.GetSizePixel() );
  65         const Point aGraphicPosition( ( aOutputSize.Width()  - aGraphicSize.Width()  ) >> 1,
  66                                       ( aOutputSize.Height() - aGraphicSize.Height() ) >> 1 );
  67         maGraphic.Draw( this, aGraphicPosition, aGraphicSize );
  68     }
  69 }
  70
  71 // -----------------------------------------------------------------------------
  72
  73 void GraphicFilterDialog::PreviewWindow::SetGraphic( const Graphic& rGraphic )
  74 {
  75     maGraphic = rGraphic;
  76
  77     if( maGraphic.IsAnimated() || maGraphic.IsTransparent() )
  78         Invalidate();
  79     else
  80         Paint( Rectangle( Point(), GetOutputSizePixel() ) );
  81 }
  82
  83 // -----------------------
  84 // - GraphicFilterDialog -
  85 // -----------------------
  86
  87 GraphicFilterDialog::GraphicFilterDialog( Window* pParent, const ResId& rResId, const Graphic& rGraphic ) :
  88     ModalDialog     ( pParent, rResId ),
  89     maModifyHdl     ( LINK( this, GraphicFilterDialog, ImplModifyHdl ) ),
  90     mfScaleX        ( 0.0 ),
  91     mfScaleY        ( 0.0 ),
  92     maSizePixel     ( LogicToPixel( rGraphic.GetPrefSize(), rGraphic.GetPrefMapMode() ) ),
  93     maPreview       ( this, CUI_RES( CTL_PREVIEW ) ),
  94     maBtnOK         ( this, CUI_RES( BTN_OK ) ),
  95     maBtnCancel     ( this, CUI_RES( BTN_CANCEL ) ),
  96     maBtnHelp       ( this, CUI_RES( BTN_HELP ) ),
  97     maFlParameter   ( this, CUI_RES( FL_PARAMETER ) )
  98 {
  99     const Size  aPreviewSize( maPreview.GetOutputSizePixel() );
 100     Size        aGrfSize( maSizePixel );
 101
 102     if( rGraphic.GetType() == GRAPHIC_BITMAP &&
 103         aPreviewSize.Width() && aPreviewSize.Height() &&
 104         aGrfSize.Width() && aGrfSize.Height() )
 105     {
 106         const double fGrfWH = (double) aGrfSize.Width() / aGrfSize.Height();
 107         const double fPreWH = (double) aPreviewSize.Width() / aPreviewSize.Height();
 108
 109         if( fGrfWH < fPreWH )
 110         {
 111             aGrfSize.Width()  = (long) ( aPreviewSize.Height() * fGrfWH );
 112             aGrfSize.Height() = aPreviewSize.Height();
 113         }
 114         else
 115         {
 116             aGrfSize.Width()  = aPreviewSize.Width();
 117             aGrfSize.Height() = (long) ( aPreviewSize.Width() / fGrfWH );
 118         }
 119
 120         mfScaleX = (double) aGrfSize.Width() / maSizePixel.Width();
 121         mfScaleY = (double) aGrfSize.Height() / maSizePixel.Height();
 122
 123         if( !rGraphic.IsAnimated() )
 124         {
 125             BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 126
 127             if( aBmpEx.Scale( aGrfSize, BMP_SCALE_DEFAULT ) )
 128                 maGraphic = aBmpEx;
 129         }
 130     }
 131
 132     maTimer.SetTimeoutHdl( LINK( this, GraphicFilterDialog, ImplPreviewTimeoutHdl ) );
 133     maTimer.SetTimeout( 100 );
 134     ImplModifyHdl( NULL );
 135 }
 136
 137 // -----------------------------------------------------------------------------
 138
 139 GraphicFilterDialog::~GraphicFilterDialog()
 140 {
 141 }
 142
 143 // -----------------------------------------------------------------------------
 144
 145 IMPL_LINK_NOARG(GraphicFilterDialog, ImplPreviewTimeoutHdl)
 146 {
 147     maTimer.Stop();
 148     maPreview.SetGraphic( GetFilteredGraphic( maGraphic, mfScaleX, mfScaleY ) );
 149
 150     return 0;
 151 }
 152
 153 // -----------------------------------------------------------------------------
 154
 155 IMPL_LINK_NOARG(GraphicFilterDialog, ImplModifyHdl)
 156 {
 157     if( maGraphic.GetType() == GRAPHIC_BITMAP )
 158     {
 159         maTimer.Stop();
 160         maTimer.Start();
 161     }
 162
 163     return 0;
 164 }
 165
 166 // ----------------
 167 // - FilterMosaic -
 168 // ----------------
 169
 170 GraphicFilterMosaic::GraphicFilterMosaic( Window* pParent, const Graphic& rGraphic,
 171                                           sal_uInt16 nTileWidth, sal_uInt16 nTileHeight, sal_Bool bEnhanceEdges ) :
 172     GraphicFilterDialog( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_MOSAIC ), rGraphic ),
 173     maFtWidth   ( this, CUI_RES( DLG_FILTERMOSAIC_FT_WIDTH ) ),
 174     maMtrWidth  ( this, CUI_RES( DLG_FILTERMOSAIC_MTR_WIDTH ) ),
 175     maFtHeight  ( this, CUI_RES( DLG_FILTERMOSAIC_FT_HEIGHT ) ),
 176     maMtrHeight ( this, CUI_RES( DLG_FILTERMOSAIC_MTR_HEIGHT ) ),
 177     maCbxEdges  ( this, CUI_RES( DLG_FILTERMOSAIC_CBX_EDGES ) )
 178 {
 179     FreeResource();
 180
 181     maMtrWidth.SetValue( nTileWidth );
 182     maMtrWidth.SetLast( GetGraphicSizePixel().Width() );
 183     maMtrWidth.SetModifyHdl( GetModifyHdl() );
 184
 185     maMtrHeight.SetValue( nTileHeight );
 186     maMtrHeight.SetLast( GetGraphicSizePixel().Height() );
 187     maMtrHeight.SetModifyHdl( GetModifyHdl() );
 188
 189     maCbxEdges.Check( bEnhanceEdges );
 190     maCbxEdges.SetToggleHdl( GetModifyHdl() );
 191
 192     maMtrWidth.GrabFocus();
 193
 194     maFtWidth.SetAccessibleRelationMemberOf(&maFlParameter);
 195     maMtrWidth.SetAccessibleRelationMemberOf(&maFlParameter);
 196     maFtHeight.SetAccessibleRelationMemberOf(&maFlParameter);
 197     maMtrHeight.SetAccessibleRelationMemberOf(&maFlParameter);
 198     maCbxEdges.SetAccessibleRelationMemberOf(&maFlParameter);
 199 }
 200
 201 // -----------------------------------------------------------------------------
 202
 203 GraphicFilterMosaic::~GraphicFilterMosaic()
 204 {
 205 }
 206
 207 // -----------------------------------------------------------------------------
 208
 209 Graphic GraphicFilterMosaic::GetFilteredGraphic( const Graphic& rGraphic,
 210                                                  double fScaleX, double fScaleY )
 211 {
 212     Graphic         aRet;
 213     const Size      aSize( std::max( FRound( GetTileWidth() * fScaleX ), 1L ),
 214                            std::max( FRound( GetTileHeight() * fScaleY ), 1L ) );
 215     BmpFilterParam  aParam( aSize );
 216
 217     if( rGraphic.IsAnimated() )
 218     {
 219         Animation aAnim( rGraphic.GetAnimation() );
 220
 221         if( aAnim.Filter( BMP_FILTER_MOSAIC, &aParam ) )
 222         {
 223             if( IsEnhanceEdges() )
 224                 aAnim.Filter( BMP_FILTER_SHARPEN );
 225
 226             aRet = aAnim;
 227         }
 228     }
 229     else
 230     {
 231         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 232
 233         if( aBmpEx.Filter( BMP_FILTER_MOSAIC, &aParam ) )
 234         {
 235             if( IsEnhanceEdges() )
 236                 aBmpEx.Filter( BMP_FILTER_SHARPEN );
 237
 238             aRet = aBmpEx;
 239         }
 240     }
 241
 242     return aRet;
 243 }
 244
 245 // ------------------
 246 // - GraphicFilterSmooth -
 247 // ------------------
 248
 249 GraphicFilterSmooth::GraphicFilterSmooth( Window* pParent, const Graphic& rGraphic, double nRadius) :
 250     GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_SMOOTH ), rGraphic ),
 251     maFtRadius   ( this, CUI_RES( DLG_FILTERSMOOTH_FT_RADIUS ) ),
 252     maMtrRadius  ( this, CUI_RES( DLG_FILTERSMOOTH_MTR_RADIUS ) )
 253 {
 254     FreeResource();
 255
 256     maMtrRadius.SetValue( nRadius* 10  );
 257     maMtrRadius.SetModifyHdl( GetModifyHdl() );
 258     maMtrRadius.GrabFocus();
 259 }
 260
 261 // -----------------------------------------------------------------------------
 262
 263 GraphicFilterSmooth::~GraphicFilterSmooth()
 264 {
 265 }
 266
 267 // -----------------------------------------------------------------------------
 268
 269 Graphic GraphicFilterSmooth::GetFilteredGraphic( const Graphic& rGraphic, double /*fScaleX*/, double /*fScaleY*/ )
 270 {
 271     Graphic         aRet;
 272     BmpFilterParam  aParam( GetRadius() );
 273
 274     if( rGraphic.IsAnimated() )
 275     {
 276         Animation aAnim( rGraphic.GetAnimation() );
 277
 278         if( aAnim.Filter( BMP_FILTER_SMOOTH, &aParam ) )
 279         {
 280             aRet = aAnim;
 281         }
 282     }
 283     else
 284     {
 285         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 286
 287         if( aBmpEx.Filter( BMP_FILTER_SMOOTH, &aParam ) )
 288         {
 289             aRet = aBmpEx;
 290         }
 291     }
 292
 293     return aRet;
 294 }
 295
 296 // ------------------
 297 // - GraphicFilterSolarize -
 298 // ------------------
 299
 300 GraphicFilterSolarize::GraphicFilterSolarize( Window* pParent, const Graphic& rGraphic,
 301                                               sal_uInt8 cGreyThreshold, sal_Bool bInvert ) :
 302     GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_SOLARIZE ), rGraphic ),
 303     maFtThreshold   ( this, CUI_RES( DLG_FILTERSOLARIZE_FT_THRESHOLD ) ),
 304     maMtrThreshold  ( this, CUI_RES( DLG_FILTERSOLARIZE_MTR_THRESHOLD ) ),
 305     maCbxInvert     ( this, CUI_RES( DLG_FILTERSOLARIZE_CBX_INVERT ) )
 306 {
 307     FreeResource();
 308
 309     maMtrThreshold.SetValue( FRound( cGreyThreshold / 2.55 ) );
 310     maMtrThreshold.SetModifyHdl( GetModifyHdl() );
 311
 312     maCbxInvert.Check( bInvert );
 313     maCbxInvert.SetToggleHdl( GetModifyHdl() );
 314
 315     maMtrThreshold.GrabFocus();
 316 }
 317
 318 // -----------------------------------------------------------------------------
 319
 320 GraphicFilterSolarize::~GraphicFilterSolarize()
 321 {
 322 }
 323
 324 // -----------------------------------------------------------------------------
 325
 326 Graphic GraphicFilterSolarize::GetFilteredGraphic( const Graphic& rGraphic,
 327                                                    double /*fScaleX*/, double /*fScaleY*/ )
 328 {
 329     Graphic         aRet;
 330     BmpFilterParam  aParam( GetGreyThreshold() );
 331
 332     if( rGraphic.IsAnimated() )
 333     {
 334         Animation aAnim( rGraphic.GetAnimation() );
 335
 336         if( aAnim.Filter( BMP_FILTER_SOLARIZE, &aParam ) )
 337         {
 338             if( IsInvert() )
 339                 aAnim.Invert();
 340
 341             aRet = aAnim;
 342         }
 343     }
 344     else
 345     {
 346         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 347
 348         if( aBmpEx.Filter( BMP_FILTER_SOLARIZE, &aParam ) )
 349         {
 350             if( IsInvert() )
 351                 aBmpEx.Invert();
 352
 353             aRet = aBmpEx;
 354         }
 355     }
 356
 357     return aRet;
 358 }
 359
 360 // ----------------------
 361 // - GraphicFilterSepia -
 362 // ----------------------
 363
 364 GraphicFilterSepia::GraphicFilterSepia( Window* pParent, const Graphic& rGraphic,
 365                                         sal_uInt16 nSepiaPercent ) :
 366     GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_SEPIA ), rGraphic ),
 367     maFtSepia       ( this, CUI_RES( DLG_FILTERSEPIA_FT_SEPIA ) ),
 368     maMtrSepia      ( this, CUI_RES( DLG_FILTERSEPIA_MTR_SEPIA ) )
 369 {
 370     FreeResource();
 371
 372     maMtrSepia.SetValue( nSepiaPercent );
 373     maMtrSepia.SetModifyHdl( GetModifyHdl() );
 374
 375     maMtrSepia.GrabFocus();
 376 }
 377
 378 // -----------------------------------------------------------------------------
 379
 380 GraphicFilterSepia::~GraphicFilterSepia()
 381 {
 382 }
 383
 384 // -----------------------------------------------------------------------------
 385
 386 Graphic GraphicFilterSepia::GetFilteredGraphic( const Graphic& rGraphic,
 387                                                 double /*fScaleX*/, double /*fScaleY*/ )
 388 {
 389     Graphic         aRet;
 390     BmpFilterParam  aParam( GetSepiaPercent() );
 391
 392     if( rGraphic.IsAnimated() )
 393     {
 394         Animation aAnim( rGraphic.GetAnimation() );
 395
 396         if( aAnim.Filter( BMP_FILTER_SEPIA, &aParam ) )
 397             aRet = aAnim;
 398     }
 399     else
 400     {
 401         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 402
 403         if( aBmpEx.Filter( BMP_FILTER_SEPIA, &aParam ) )
 404             aRet = aBmpEx;
 405     }
 406
 407     return aRet;
 408 }
 409
 410 // -----------------------
 411 // - GraphicFilterPoster -
 412 // -----------------------
 413
 414 GraphicFilterPoster::GraphicFilterPoster( Window* pParent, const Graphic& rGraphic,
 415                                           sal_uInt16 nPosterCount ) :
 416     GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_POSTER ), rGraphic ),
 417     maFtPoster      ( this, CUI_RES( DLG_FILTERPOSTER_FT_POSTER ) ),
 418     maNumPoster     ( this, CUI_RES( DLG_FILTERPOSTER_NUM_POSTER ) )
 419 {
 420     FreeResource();
 421
 422     maNumPoster.SetFirst( 2 );
 423     maNumPoster.SetLast( rGraphic.GetBitmapEx().GetBitCount() );
 424     maNumPoster.SetValue( nPosterCount );
 425     maNumPoster.SetModifyHdl( GetModifyHdl() );
 426     maNumPoster.GrabFocus();
 427 }
 428
 429 // -----------------------------------------------------------------------------
 430
 431 GraphicFilterPoster::~GraphicFilterPoster()
 432 {
 433 }
 434
 435 // -----------------------------------------------------------------------------
 436
 437 Graphic GraphicFilterPoster::GetFilteredGraphic( const Graphic& rGraphic,
 438                                                  double /*fScaleX*/, double /*fScaleY*/ )
 439 {
 440     Graphic         aRet;
 441     const sal_uInt16    nPosterCount = GetPosterColorCount();
 442
 443     if( rGraphic.IsAnimated() )
 444     {
 445         Animation aAnim( rGraphic.GetAnimation() );
 446
 447         if( aAnim.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) )
 448             aRet = aAnim;
 449     }
 450     else
 451     {
 452         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 453
 454         if( aBmpEx.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) )
 455             aRet = aBmpEx;
 456     }
 457
 458     return aRet;
 459 }
 460
 461 // -----------------------
 462 // - GraphicFilterEmboss -
 463 // -----------------------
 464
 465 void GraphicFilterEmboss::EmbossControl::MouseButtonDown( const MouseEvent& rEvt )
 466 {
 467     const RECT_POINT eOldRP = GetActualRP();
 468
 469     SvxRectCtl::MouseButtonDown( rEvt );
 470
 471     if( GetActualRP() != eOldRP )
 472         maModifyHdl.Call( this );
 473 }
 474
 475 // -----------------------------------------------------------------------------
 476
 477 GraphicFilterEmboss::GraphicFilterEmboss( Window* pParent, const Graphic& rGraphic,
 478                                           RECT_POINT eLightSource ) :
 479     GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_EMBOSS ), rGraphic ),
 480     maFtLight       ( this, CUI_RES( DLG_FILTEREMBOSS_FT_LIGHT ) ),
 481     maCtlLight      ( this, CUI_RES( DLG_FILTEREMBOSS_CTL_LIGHT ), eLightSource )
 482 {
 483     FreeResource();
 484
 485     maCtlLight.SetModifyHdl( GetModifyHdl() );
 486     maCtlLight.GrabFocus();
 487 }
 488
 489 // -----------------------------------------------------------------------------
 490
 491 GraphicFilterEmboss::~GraphicFilterEmboss()
 492 {
 493 }
 494
 495 // -----------------------------------------------------------------------------
 496
 497 Graphic GraphicFilterEmboss::GetFilteredGraphic( const Graphic& rGraphic,
 498                                                  double /*fScaleX*/, double /*fScaleY*/ )
 499 {
 500     Graphic aRet;
 501     sal_uInt16  nAzim, nElev;
 502
 503     switch( maCtlLight.GetActualRP() )
 504     {
 505         default:       OSL_FAIL("svx::GraphicFilterEmboss::GetFilteredGraphic(), unknown Reference Point!" );
 506         case( RP_LT ): nAzim = 4500,    nElev = 4500; break;
 507         case( RP_MT ): nAzim = 9000,    nElev = 4500; break;
 508         case( RP_RT ): nAzim = 13500,   nElev = 4500; break;
 509         case( RP_LM ): nAzim = 0,       nElev = 4500; break;
 510         case( RP_MM ): nAzim = 0,       nElev = 9000; break;
 511         case( RP_RM ): nAzim = 18000,   nElev = 4500; break;
 512         case( RP_LB ): nAzim = 31500,   nElev = 4500; break;
 513         case( RP_MB ): nAzim = 27000,   nElev = 4500; break;
 514         case( RP_RB ): nAzim = 22500,   nElev = 4500; break;
 515     }
 516
 517     BmpFilterParam aParam( nAzim, nElev );
 518
 519     if( rGraphic.IsAnimated() )
 520     {
 521         Animation aAnim( rGraphic.GetAnimation() );
 522
 523         if( aAnim.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) )
 524             aRet = aAnim;
 525     }
 526     else
 527     {
 528         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 529
 530         if( aBmpEx.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) )
 531             aRet = aBmpEx;
 532     }
 533
 534     return aRet;
 535 }
 536
 537 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */