| /************************************************************** | |
| * | |
| * 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; | |
| } |