| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_cui.hxx" |
| |
| #include <tools/shl.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/viewsh.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <sfx2/request.hxx> |
| #include <dialmgr.hxx> |
| #include "cuigrfflt.hxx" |
| #include "grfflt.hrc" |
| #include <cuires.hrc> |
| #include <svx/dialogs.hrc> // RID_SVX_GRFFILTER_DLG_... |
| |
| // -------------------- |
| // - SvxGraphicFilter - |
| // -------------------- |
| /* |
| sal_uLong SvxGraphicFilter::ExecuteGrfFilterSlot( SfxRequest& rReq, GraphicObject& rFilterObject ) |
| { |
| const Graphic& rGraphic = rFilterObject.GetGraphic(); |
| sal_uLong nRet; |
| |
| if( rGraphic.GetType() == GRAPHIC_BITMAP ) |
| { |
| SfxViewFrame* pViewFrame = SfxViewFrame::Current(); |
| SfxObjectShell* pShell = pViewFrame ? pViewFrame->GetObjectShell() : NULL; |
| Window* pWindow = ( pViewFrame && pViewFrame->GetViewShell() ) ? pViewFrame->GetViewShell()->GetWindow() : NULL; |
| Graphic aGraphic; |
| |
| switch( rReq.GetSlot() ) |
| { |
| case( SID_GRFFILTER_INVERT ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Invert() ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Invert() ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_SMOOTH ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Filter( BMP_FILTER_SMOOTH ) ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_SMOOTH ) ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_SHARPEN ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Filter( BMP_FILTER_SHARPEN ) ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_SHARPEN ) ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_REMOVENOISE ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Filter( BMP_FILTER_REMOVENOISE ) ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_REMOVENOISE ) ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_SOBEL ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Filter( BMP_FILTER_SOBEL_GREY ) ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_SOBEL_GREY ) ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_MOSAIC ): |
| { |
| GraphicFilterMosaic aDlg( pWindow, rGraphic, 4, 4, sal_False ); |
| |
| if( aDlg.Execute() == RET_OK ) |
| aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_EMBOSS ): |
| { |
| GraphicFilterEmboss aDlg( pWindow, rGraphic, RP_MM ); |
| |
| if( aDlg.Execute() == RET_OK ) |
| aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_POSTER ): |
| { |
| GraphicFilterPoster aDlg( pWindow, rGraphic, 16 ); |
| |
| if( aDlg.Execute() == RET_OK ) |
| aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_POPART ): |
| { |
| if( pShell ) |
| pShell->SetWaitCursor( sal_True ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnimation( rGraphic.GetAnimation() ); |
| |
| if( aAnimation.Filter( BMP_FILTER_POPART ) ) |
| aGraphic = aAnimation; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_POPART ) ) |
| aGraphic = aBmpEx; |
| } |
| |
| if( pShell ) |
| pShell->SetWaitCursor( sal_False ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_SEPIA ): |
| { |
| GraphicFilterSepia aDlg( pWindow, rGraphic, 10 ); |
| |
| if( aDlg.Execute() == RET_OK ) |
| aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 ); |
| } |
| break; |
| |
| case( SID_GRFFILTER_SOLARIZE ): |
| { |
| GraphicFilterSolarize aDlg( pWindow, rGraphic, 128, sal_False ); |
| |
| if( aDlg.Execute() == RET_OK ) |
| aGraphic = aDlg.GetFilteredGraphic( rGraphic, 1.0, 1.0 ); |
| } |
| break; |
| |
| default: |
| { |
| DBG_ERROR( "SvxGraphicFilter: selected filter slot not yet implemented" ); |
| nRet = SVX_GRAPHICFILTER_UNSUPPORTED_SLOT; |
| } |
| break; |
| } |
| |
| if( aGraphic.GetType() != GRAPHIC_NONE ) |
| { |
| rFilterObject.SetGraphic( aGraphic ); |
| nRet = SVX_GRAPHICFILTER_ERRCODE_NONE; |
| } |
| } |
| else |
| nRet = SVX_GRAPHICFILTER_UNSUPPORTED_GRAPHICTYPE; |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SvxGraphicFilter::DisableGraphicFilterSlots( SfxItemSet& rSet ) |
| { |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER ) ) |
| rSet.DisableItem( SID_GRFFILTER ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_INVERT ) ) |
| rSet.DisableItem( SID_GRFFILTER_INVERT ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SMOOTH ) ) |
| rSet.DisableItem( SID_GRFFILTER_SMOOTH ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SHARPEN ) ) |
| rSet.DisableItem( SID_GRFFILTER_SHARPEN ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_REMOVENOISE ) ) |
| rSet.DisableItem( SID_GRFFILTER_REMOVENOISE ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SOBEL ) ) |
| rSet.DisableItem( SID_GRFFILTER_SOBEL ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_MOSAIC ) ) |
| rSet.DisableItem( SID_GRFFILTER_MOSAIC ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_EMBOSS ) ) |
| rSet.DisableItem( SID_GRFFILTER_EMBOSS ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_POSTER ) ) |
| rSet.DisableItem( SID_GRFFILTER_POSTER ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_POPART ) ) |
| rSet.DisableItem( SID_GRFFILTER_POPART ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SEPIA ) ) |
| rSet.DisableItem( SID_GRFFILTER_SEPIA ); |
| |
| if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( SID_GRFFILTER_SOLARIZE ) ) |
| rSet.DisableItem( SID_GRFFILTER_SOLARIZE ); |
| }; |
| */ |
| // -------------------------------------- |
| // - GraphicFilterDialog::PreviewWindow - |
| // -------------------------------------- |
| |
| GraphicFilterDialog::PreviewWindow::PreviewWindow( Window* pParent, const ResId& rResId ) : |
| Control( pParent, rResId ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterDialog::PreviewWindow::~PreviewWindow() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GraphicFilterDialog::PreviewWindow::Paint( const Rectangle& rRect ) |
| { |
| Control::Paint( rRect ); |
| |
| const Size aGrfSize( LogicToPixel( maGraphic.GetPrefSize(), maGraphic.GetPrefMapMode() ) ); |
| const Size aOutSize( GetOutputSizePixel() ); |
| const Point aGrfPos( ( aOutSize.Width() - aGrfSize.Width() ) >> 1, |
| ( aOutSize.Height() - aGrfSize.Height() ) >> 1 ); |
| |
| if( maGraphic.IsAnimated() ) |
| maGraphic.StartAnimation( this , aGrfPos, aGrfSize ); |
| else |
| maGraphic.Draw( this, aGrfPos, aGrfSize ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GraphicFilterDialog::PreviewWindow::SetGraphic( const Graphic& rGraphic ) |
| { |
| maGraphic = rGraphic; |
| |
| if( maGraphic.IsAnimated() || maGraphic.IsTransparent() ) |
| Invalidate(); |
| else |
| Paint( Rectangle( Point(), GetOutputSizePixel() ) ); |
| } |
| |
| // ----------------------- |
| // - GraphicFilterDialog - |
| // ----------------------- |
| |
| GraphicFilterDialog::GraphicFilterDialog( Window* pParent, const ResId& rResId, const Graphic& rGraphic ) : |
| ModalDialog ( pParent, rResId ), |
| maModifyHdl ( LINK( this, GraphicFilterDialog, ImplModifyHdl ) ), |
| mfScaleX ( 0.0 ), |
| mfScaleY ( 0.0 ), |
| maSizePixel ( LogicToPixel( rGraphic.GetPrefSize(), rGraphic.GetPrefMapMode() ) ), |
| maPreview ( this, CUI_RES( CTL_PREVIEW ) ), |
| maBtnOK ( this, CUI_RES( BTN_OK ) ), |
| maBtnCancel ( this, CUI_RES( BTN_CANCEL ) ), |
| maBtnHelp ( this, CUI_RES( BTN_HELP ) ), |
| maFlParameter ( this, CUI_RES( FL_PARAMETER ) ) |
| { |
| const Size aPreviewSize( maPreview.GetOutputSizePixel() ); |
| Size aGrfSize( maSizePixel ); |
| |
| if( rGraphic.GetType() == GRAPHIC_BITMAP && |
| aPreviewSize.Width() && aPreviewSize.Height() && |
| aGrfSize.Width() && aGrfSize.Height() ) |
| { |
| const double fGrfWH = (double) aGrfSize.Width() / aGrfSize.Height(); |
| const double fPreWH = (double) aPreviewSize.Width() / aPreviewSize.Height(); |
| |
| if( fGrfWH < fPreWH ) |
| { |
| aGrfSize.Width() = (long) ( aPreviewSize.Height() * fGrfWH ); |
| aGrfSize.Height()= aPreviewSize.Height(); |
| } |
| else |
| { |
| aGrfSize.Width() = aPreviewSize.Width(); |
| aGrfSize.Height()= (long) ( aPreviewSize.Width() / fGrfWH); |
| } |
| |
| mfScaleX = (double) aGrfSize.Width() / maSizePixel.Width(); |
| mfScaleY = (double) aGrfSize.Height() / maSizePixel.Height(); |
| |
| if( !rGraphic.IsAnimated() ) |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Scale( aGrfSize, BMP_SCALE_INTERPOLATE ) ) |
| maGraphic = aBmpEx; |
| } |
| } |
| |
| maTimer.SetTimeoutHdl( LINK( this, GraphicFilterDialog, ImplPreviewTimeoutHdl ) ); |
| maTimer.SetTimeout( 100 ); |
| ImplModifyHdl( NULL ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterDialog::~GraphicFilterDialog() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GraphicFilterDialog, ImplPreviewTimeoutHdl, Timer*, EMPTYARG ) |
| { |
| maTimer.Stop(); |
| maPreview.SetGraphic( GetFilteredGraphic( maGraphic, mfScaleX, mfScaleY ) ); |
| |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GraphicFilterDialog, ImplModifyHdl, void*, EMPTYARG ) |
| { |
| if( maGraphic.GetType() == GRAPHIC_BITMAP ) |
| { |
| maTimer.Stop(); |
| maTimer.Start(); |
| } |
| |
| return 0; |
| } |
| |
| // ---------------- |
| // - FilterMosaic - |
| // ---------------- |
| |
| GraphicFilterMosaic::GraphicFilterMosaic( Window* pParent, const Graphic& rGraphic, |
| sal_uInt16 nTileWidth, sal_uInt16 nTileHeight, sal_Bool bEnhanceEdges ) : |
| GraphicFilterDialog( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_MOSAIC ), rGraphic ), |
| maFtWidth ( this, CUI_RES( DLG_FILTERMOSAIC_FT_WIDTH ) ), |
| maMtrWidth ( this, CUI_RES( DLG_FILTERMOSAIC_MTR_WIDTH ) ), |
| maFtHeight ( this, CUI_RES( DLG_FILTERMOSAIC_FT_HEIGHT ) ), |
| maMtrHeight ( this, CUI_RES( DLG_FILTERMOSAIC_MTR_HEIGHT ) ), |
| maCbxEdges ( this, CUI_RES( DLG_FILTERMOSAIC_CBX_EDGES ) ) |
| { |
| FreeResource(); |
| |
| maMtrWidth.SetValue( nTileWidth ); |
| maMtrWidth.SetLast( GetGraphicSizePixel().Width() ); |
| maMtrWidth.SetModifyHdl( GetModifyHdl() ); |
| |
| maMtrHeight.SetValue( nTileHeight ); |
| maMtrHeight.SetLast( GetGraphicSizePixel().Height() ); |
| maMtrHeight.SetModifyHdl( GetModifyHdl() ); |
| |
| maCbxEdges.Check( bEnhanceEdges ); |
| maCbxEdges.SetToggleHdl( GetModifyHdl() ); |
| |
| maMtrWidth.GrabFocus(); |
| |
| maFtWidth.SetAccessibleRelationMemberOf(&maFlParameter); |
| maMtrWidth.SetAccessibleRelationMemberOf(&maFlParameter); |
| maFtHeight.SetAccessibleRelationMemberOf(&maFlParameter); |
| maMtrHeight.SetAccessibleRelationMemberOf(&maFlParameter); |
| maCbxEdges.SetAccessibleRelationMemberOf(&maFlParameter); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterMosaic::~GraphicFilterMosaic() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GraphicFilterMosaic::GetFilteredGraphic( const Graphic& rGraphic, |
| double fScaleX, double fScaleY ) |
| { |
| Graphic aRet; |
| const Size aSize( Max( FRound( GetTileWidth() * fScaleX ), 1L ), |
| Max( FRound( GetTileHeight() * fScaleY ), 1L ) ); |
| BmpFilterParam aParam( aSize ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnim( rGraphic.GetAnimation() ); |
| |
| if( aAnim.Filter( BMP_FILTER_MOSAIC, &aParam ) ) |
| { |
| if( IsEnhanceEdges() ) |
| aAnim.Filter( BMP_FILTER_SHARPEN ); |
| |
| aRet = aAnim; |
| } |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_MOSAIC, &aParam ) ) |
| { |
| if( IsEnhanceEdges() ) |
| aBmpEx.Filter( BMP_FILTER_SHARPEN ); |
| |
| aRet = aBmpEx; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| // ------------------ |
| // - GraphicFilterSolarize - |
| // ------------------ |
| |
| GraphicFilterSolarize::GraphicFilterSolarize( Window* pParent, const Graphic& rGraphic, |
| sal_uInt8 cGreyThreshold, sal_Bool bInvert ) : |
| GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_SOLARIZE ), rGraphic ), |
| maFtThreshold ( this, CUI_RES( DLG_FILTERSOLARIZE_FT_THRESHOLD ) ), |
| maMtrThreshold ( this, CUI_RES( DLG_FILTERSOLARIZE_MTR_THRESHOLD ) ), |
| maCbxInvert ( this, CUI_RES( DLG_FILTERSOLARIZE_CBX_INVERT ) ) |
| { |
| FreeResource(); |
| |
| maMtrThreshold.SetValue( FRound( cGreyThreshold / 2.55 ) ); |
| maMtrThreshold.SetModifyHdl( GetModifyHdl() ); |
| |
| maCbxInvert.Check( bInvert ); |
| maCbxInvert.SetToggleHdl( GetModifyHdl() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterSolarize::~GraphicFilterSolarize() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GraphicFilterSolarize::GetFilteredGraphic( const Graphic& rGraphic, |
| double /*fScaleX*/, double /*fScaleY*/ ) |
| { |
| Graphic aRet; |
| BmpFilterParam aParam( GetGreyThreshold() ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnim( rGraphic.GetAnimation() ); |
| |
| if( aAnim.Filter( BMP_FILTER_SOLARIZE, &aParam ) ) |
| { |
| if( IsInvert() ) |
| aAnim.Invert(); |
| |
| aRet = aAnim; |
| } |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_SOLARIZE, &aParam ) ) |
| { |
| if( IsInvert() ) |
| aBmpEx.Invert(); |
| |
| aRet = aBmpEx; |
| } |
| } |
| |
| return aRet; |
| } |
| |
| // ---------------------- |
| // - GraphicFilterSepia - |
| // ---------------------- |
| |
| GraphicFilterSepia::GraphicFilterSepia( Window* pParent, const Graphic& rGraphic, |
| sal_uInt16 nSepiaPercent ) : |
| GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_SEPIA ), rGraphic ), |
| maFtSepia ( this, CUI_RES( DLG_FILTERSEPIA_FT_SEPIA ) ), |
| maMtrSepia ( this, CUI_RES( DLG_FILTERSEPIA_MTR_SEPIA ) ) |
| { |
| FreeResource(); |
| |
| maMtrSepia.SetValue( nSepiaPercent ); |
| maMtrSepia.SetModifyHdl( GetModifyHdl() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterSepia::~GraphicFilterSepia() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GraphicFilterSepia::GetFilteredGraphic( const Graphic& rGraphic, |
| double /*fScaleX*/, double /*fScaleY*/ ) |
| { |
| Graphic aRet; |
| BmpFilterParam aParam( GetSepiaPercent() ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnim( rGraphic.GetAnimation() ); |
| |
| if( aAnim.Filter( BMP_FILTER_SEPIA, &aParam ) ) |
| aRet = aAnim; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_SEPIA, &aParam ) ) |
| aRet = aBmpEx; |
| } |
| |
| return aRet; |
| } |
| |
| // ----------------------- |
| // - GraphicFilterPoster - |
| // ----------------------- |
| |
| GraphicFilterPoster::GraphicFilterPoster( Window* pParent, const Graphic& rGraphic, |
| sal_uInt16 nPosterCount ) : |
| GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_POSTER ), rGraphic ), |
| maFtPoster ( this, CUI_RES( DLG_FILTERPOSTER_FT_POSTER ) ), |
| maNumPoster ( this, CUI_RES( DLG_FILTERPOSTER_NUM_POSTER ) ) |
| { |
| FreeResource(); |
| |
| maNumPoster.SetFirst( 2 ); |
| maNumPoster.SetLast( rGraphic.GetBitmapEx().GetBitCount() ); |
| maNumPoster.SetValue( nPosterCount ); |
| maNumPoster.SetModifyHdl( GetModifyHdl() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterPoster::~GraphicFilterPoster() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GraphicFilterPoster::GetFilteredGraphic( const Graphic& rGraphic, |
| double /*fScaleX*/, double /*fScaleY*/ ) |
| { |
| Graphic aRet; |
| const sal_uInt16 nPosterCount = GetPosterColorCount(); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnim( rGraphic.GetAnimation() ); |
| |
| if( aAnim.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) ) |
| aRet = aAnim; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.ReduceColors( nPosterCount, BMP_REDUCE_POPULAR ) ) |
| aRet = aBmpEx; |
| } |
| |
| return aRet; |
| } |
| |
| // ----------------------- |
| // - GraphicFilterEmboss - |
| // ----------------------- |
| |
| void GraphicFilterEmboss::EmbossControl::MouseButtonDown( const MouseEvent& rEvt ) |
| { |
| const RECT_POINT eOldRP = GetActualRP(); |
| |
| SvxRectCtl::MouseButtonDown( rEvt ); |
| |
| if( GetActualRP() != eOldRP ) |
| maModifyHdl.Call( this ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterEmboss::GraphicFilterEmboss( Window* pParent, const Graphic& rGraphic, |
| RECT_POINT eLightSource ) : |
| GraphicFilterDialog ( pParent, CUI_RES( RID_SVX_GRFFILTER_DLG_EMBOSS ), rGraphic ), |
| maFtLight ( this, CUI_RES( DLG_FILTEREMBOSS_FT_LIGHT ) ), |
| maCtlLight ( this, CUI_RES( DLG_FILTEREMBOSS_CTL_LIGHT ), eLightSource ) |
| { |
| FreeResource(); |
| |
| maCtlLight.SetModifyHdl( GetModifyHdl() ); |
| maCtlLight.GrabFocus(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GraphicFilterEmboss::~GraphicFilterEmboss() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GraphicFilterEmboss::GetFilteredGraphic( const Graphic& rGraphic, |
| double /*fScaleX*/, double /*fScaleY*/ ) |
| { |
| Graphic aRet; |
| sal_uInt16 nAzim, nElev; |
| |
| switch( maCtlLight.GetActualRP() ) |
| { |
| default: DBG_ERROR("svx::GraphicFilterEmboss::GetFilteredGraphic(), unknown Reference Point!" ); |
| case( RP_LT ): nAzim = 4500, nElev = 4500; break; |
| case( RP_MT ): nAzim = 9000, nElev = 4500; break; |
| case( RP_RT ): nAzim = 13500, nElev = 4500; break; |
| case( RP_LM ): nAzim = 0, nElev = 4500; break; |
| case( RP_MM ): nAzim = 0, nElev = 9000; break; |
| case( RP_RM ): nAzim = 18000, nElev = 4500; break; |
| case( RP_LB ): nAzim = 31500, nElev = 4500; break; |
| case( RP_MB ): nAzim = 27000, nElev = 4500; break; |
| case( RP_RB ): nAzim = 22500, nElev = 4500; break; |
| } |
| |
| BmpFilterParam aParam( nAzim, nElev ); |
| |
| if( rGraphic.IsAnimated() ) |
| { |
| Animation aAnim( rGraphic.GetAnimation() ); |
| |
| if( aAnim.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) ) |
| aRet = aAnim; |
| } |
| else |
| { |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| |
| if( aBmpEx.Filter( BMP_FILTER_EMBOSS_GREY, &aParam ) ) |
| aRet = aBmpEx; |
| } |
| |
| return aRet; |
| } |