| /************************************************************** |
| * |
| * 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_svx.hxx" |
| #include <vcl/wrkwin.hxx> |
| #include <sot/factory.hxx> |
| #include <tools/shl.hxx> |
| #include <vcl/salbtype.hxx> // FRound |
| #include <vcl/msgbox.hxx> |
| #include <svl/eitem.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <svtools/miscopt.hxx> |
| #include <unotools/localedatawrapper.hxx> |
| #ifndef _UNOTOOLS_PROCESSFACTORY_HXX |
| #include <comphelper/processfactory.hxx> |
| #endif |
| |
| #define _SDR_NOITEMS |
| #define _SDR_NOTOUCH |
| #define _SDR_NOTRANSFORM |
| #define _SDR_NOOBJECTS |
| #define _SDR_NOVIEWMARKER |
| #define _SDR_NODRAGMETHODS |
| #define _SDR_NOUNDO |
| #define _SDR_NOXOUTDEV |
| #define _XOUTBMP_STATICS_ONLY |
| |
| #include <svx/dialmgr.hxx> |
| #include "svx/xoutbmp.hxx" |
| #include <svx/dialogs.hrc> |
| #include <svx/svxids.hrc> |
| #include <svx/contdlg.hxx> |
| #include "contimp.hxx" |
| #include "contdlg.hrc" |
| #include "contwnd.hxx" |
| #include <svx/svdtrans.hxx> |
| #include <svx/svdopath.hxx> |
| #include "svx/dlgutil.hxx" |
| #include <vcl/svapp.hxx> |
| |
| /******************************************************************************/ |
| |
| inline String GetUnitString( long nVal_100, FieldUnit eFieldUnit, sal_Unicode cSep ) |
| { |
| String aVal = UniString::CreateFromInt64( MetricField::ConvertValue( nVal_100, 2, MAP_100TH_MM, eFieldUnit ) ); |
| |
| while( aVal.Len() < 3 ) |
| aVal.Insert( sal_Unicode('0'), 0 ); |
| |
| aVal.Insert( cSep, aVal.Len() - 2 ); |
| aVal += sal_Unicode(' '); |
| aVal += SdrFormatter::GetUnitStr( eFieldUnit ); |
| |
| return aVal; |
| } |
| |
| |
| /******************************************************************************/ |
| |
| |
| SFX_IMPL_FLOATINGWINDOW( SvxContourDlgChildWindow, SID_CONTOUR_DLG ); |
| |
| |
| /******************************************************************************/ |
| |
| |
| /************************************************************************* |
| |* |
| |* ControllerItem |
| |* |
| \************************************************************************/ |
| |
| SvxContourDlgItem::SvxContourDlgItem( sal_uInt16 _nId, SvxSuperContourDlg& rContourDlg, SfxBindings& rBindings ) : |
| SfxControllerItem ( _nId, rBindings ), |
| rDlg ( rContourDlg ) |
| { |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxContourDlgItem::StateChanged( sal_uInt16 nSID, SfxItemState /*eState*/, const SfxPoolItem* pItem ) |
| { |
| if ( pItem && ( SID_CONTOUR_EXEC == nSID ) ) |
| { |
| const SfxBoolItem* pStateItem = PTR_CAST( SfxBoolItem, pItem ); |
| |
| DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem erwartet"); |
| |
| rDlg.SetExecState( !pStateItem->GetValue() ); |
| } |
| } |
| |
| |
| /******************************************************************************/ |
| |
| |
| /************************************************************************* |
| |* |
| |* Contour-Float |
| |* |
| \************************************************************************/ |
| |
| SvxContourDlgChildWindow::SvxContourDlgChildWindow( Window* _pParent, sal_uInt16 nId, |
| SfxBindings* pBindings, SfxChildWinInfo* pInfo ) : |
| SfxChildWindow( _pParent, nId ) |
| { |
| SvxSuperContourDlg* pDlg = new SvxSuperContourDlg( pBindings, this, _pParent, CONT_RESID( RID_SVXDLG_CONTOUR ) ); |
| pWindow = pDlg; |
| |
| if ( pInfo->nFlags & SFX_CHILDWIN_ZOOMIN ) |
| pDlg->RollUp(); |
| |
| eChildAlignment = SFX_ALIGN_NOALIGNMENT; |
| |
| pDlg->Initialize( pInfo ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxContourDlgChildWindow::UpdateContourDlg( const Graphic& rGraphic, sal_Bool bGraphicLinked, |
| const PolyPolygon* pPolyPoly, void* pEditingObj ) |
| { |
| if ( SfxViewFrame::Current() && |
| SfxViewFrame::Current()->HasChildWindow( SvxContourDlgChildWindow::GetChildWindowId() ) ) |
| SVXCONTOURDLG()->Update( rGraphic, bGraphicLinked, pPolyPoly, pEditingObj ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| SvxContourDlg::SvxContourDlg( SfxBindings* _pBindings, SfxChildWindow* pCW, |
| Window* _pParent, const ResId& rResId ) : |
| |
| SfxFloatingWindow ( _pBindings, pCW, _pParent, rResId ) |
| |
| { |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| SvxContourDlg::~SvxContourDlg() |
| { |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic, |
| const Rectangle* pRect, |
| const sal_uIntPtr nFlags ) |
| { |
| Bitmap aBmp; |
| sal_uIntPtr nContourFlags = XOUTBMP_CONTOUR_HORZ; |
| |
| if ( rGraphic.GetType() == GRAPHIC_BITMAP ) |
| { |
| if( rGraphic.IsAnimated() ) |
| { |
| VirtualDevice aVDev; |
| MapMode aTransMap; |
| PolyPolygon aAnimPolyPoly; |
| const Animation aAnim( rGraphic.GetAnimation() ); |
| const Size& rSizePix = aAnim.GetDisplaySizePixel(); |
| const sal_uInt16 nCount = aAnim.Count(); |
| |
| if ( aVDev.SetOutputSizePixel( rSizePix ) ) |
| { |
| aVDev.SetLineColor( Color( COL_BLACK ) ); |
| aVDev.SetFillColor( Color( COL_BLACK ) ); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| { |
| const AnimationBitmap& rStepBmp = aAnim.Get( i ); |
| |
| // Polygonausgabe an die richtige Stelle schieben; |
| // dies ist der Offset des Teilbildes innerhalb |
| // der Gesamtanimation |
| aTransMap.SetOrigin( Point( rStepBmp.aPosPix.X(), rStepBmp.aPosPix.Y() ) ); |
| aVDev.SetMapMode( aTransMap ); |
| aVDev.DrawPolyPolygon( CreateAutoContour( rStepBmp.aBmpEx, pRect, nFlags ) ); |
| } |
| |
| aTransMap.SetOrigin( Point() ); |
| aVDev.SetMapMode( aTransMap ); |
| aBmp = aVDev.GetBitmap( Point(), rSizePix ); |
| aBmp.Convert( BMP_CONVERSION_1BIT_THRESHOLD ); |
| } |
| } |
| else if( rGraphic.IsTransparent() ) |
| aBmp = rGraphic.GetBitmapEx().GetMask(); |
| else |
| { |
| aBmp = rGraphic.GetBitmap(); |
| nContourFlags |= XOUTBMP_CONTOUR_EDGEDETECT; |
| } |
| } |
| else if( rGraphic.GetType() != GRAPHIC_NONE ) |
| { |
| const Graphic aTmpGrf( rGraphic.GetGDIMetaFile().GetMonochromeMtf( Color( COL_BLACK ) ) ); |
| VirtualDevice aVDev; |
| Size aSizePix( aVDev.LogicToPixel( aTmpGrf.GetPrefSize(), aTmpGrf.GetPrefMapMode() ) ); |
| |
| if( aSizePix.Width() && aSizePix.Height() && ( aSizePix.Width() > 512 || aSizePix.Height() > 512 ) ) |
| { |
| double fWH = (double) aSizePix.Width() / aSizePix.Height(); |
| |
| if( fWH <= 1.0 ) |
| aSizePix.Width() = FRound( ( aSizePix.Height() = 512 ) * fWH ); |
| else |
| aSizePix.Height() = FRound( ( aSizePix.Width() = 512 ) / fWH ); |
| } |
| |
| if( aVDev.SetOutputSizePixel( aSizePix ) ) |
| { |
| const Point aPt; |
| aTmpGrf.Draw( &aVDev, aPt, aSizePix ); |
| aBmp = aVDev.GetBitmap( aPt, aSizePix ); |
| } |
| |
| nContourFlags |= XOUTBMP_CONTOUR_EDGEDETECT; |
| } |
| |
| aBmp.SetPrefSize( rGraphic.GetPrefSize() ); |
| aBmp.SetPrefMapMode( rGraphic.GetPrefMapMode() ); |
| |
| return PolyPolygon( XOutBitmap::GetCountour( aBmp, nContourFlags, 128, pRect ) ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxContourDlg::ScaleContour( PolyPolygon& rContour, const Graphic& rGraphic, |
| const MapUnit eUnit, const Size& rDisplaySize ) |
| { |
| DBG_ASSERT( rGraphic.GetType() != GRAPHIC_NONE, "Graphic is not valid!" ); |
| |
| OutputDevice* pOutDev = Application::GetDefaultDevice(); |
| const MapMode aDispMap( eUnit ); |
| const MapMode aGrfMap( rGraphic.GetPrefMapMode() ); |
| const Size aGrfSize( rGraphic.GetPrefSize() ); |
| double fScaleX; |
| double fScaleY; |
| Size aOrgSize; |
| Point aNewPoint; |
| sal_Bool bPixelMap = aGrfMap.GetMapUnit() == MAP_PIXEL; |
| |
| if ( bPixelMap ) |
| aOrgSize = pOutDev->PixelToLogic( aGrfSize, aDispMap ); |
| else |
| aOrgSize = pOutDev->LogicToLogic( aGrfSize, aGrfMap, aDispMap ); |
| |
| if ( aOrgSize.Width() && aOrgSize.Height() ) |
| { |
| fScaleX = (double) rDisplaySize.Width() / aOrgSize.Width(); |
| fScaleY = (double) rDisplaySize.Height() / aOrgSize.Height(); |
| |
| for ( sal_uInt16 j = 0, nPolyCount = rContour.Count(); j < nPolyCount; j++ ) |
| { |
| Polygon& rPoly = rContour[ j ]; |
| |
| for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) |
| { |
| if ( bPixelMap ) |
| aNewPoint = pOutDev->PixelToLogic( rPoly[ i ], aDispMap ); |
| else |
| aNewPoint = pOutDev->LogicToLogic( rPoly[ i ], aGrfMap, aDispMap ); |
| |
| rPoly[ i ] = Point( FRound( aNewPoint.X() * fScaleX ), FRound( aNewPoint.Y() * fScaleY ) ); |
| } |
| } |
| } |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Durchschleifen an SuperClass; keine virt. Methoden, um |
| |* bei IF-Aenderungen nicht inkompatibel zu werden |
| |* |
| \************************************************************************/ |
| |
| void SvxContourDlg::SetExecState( sal_Bool bEnable ) |
| { |
| pSuperClass->SetExecState( bEnable ); |
| } |
| |
| void SvxContourDlg::SetGraphic( const Graphic& rGraphic ) |
| { |
| pSuperClass->SetGraphic( rGraphic ); |
| } |
| |
| void SvxContourDlg::SetGraphicLinked( sal_Bool bGraphicLinked ) |
| { |
| pSuperClass->SetGraphicLinked( bGraphicLinked ); |
| } |
| |
| const Graphic& SvxContourDlg::GetGraphic() const |
| { |
| return pSuperClass->GetGraphic(); |
| } |
| |
| sal_Bool SvxContourDlg::IsGraphicChanged() const |
| { |
| return pSuperClass->IsGraphicChanged(); |
| } |
| |
| void SvxContourDlg::SetPolyPolygon( const PolyPolygon& rPolyPoly ) |
| { |
| pSuperClass->SetPolyPolygon( rPolyPoly ); |
| } |
| |
| PolyPolygon SvxContourDlg::GetPolyPolygon() |
| { |
| return pSuperClass->GetPolyPolygon( sal_True ); |
| } |
| |
| void SvxContourDlg::SetEditingObject( void* pObj ) |
| { |
| pSuperClass->SetEditingObject( pObj ); |
| } |
| |
| const void* SvxContourDlg::GetEditingObject() const |
| { |
| return pSuperClass->GetEditingObject(); |
| } |
| |
| void SvxContourDlg::Update( const Graphic& rGraphic, sal_Bool bGraphicLinked, |
| const PolyPolygon* pPolyPoly, void* pEditingObj ) |
| { |
| pSuperClass->UpdateGraphic( rGraphic, bGraphicLinked, pPolyPoly, pEditingObj ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| SvxSuperContourDlg::SvxSuperContourDlg( SfxBindings *_pBindings, SfxChildWindow *pCW, |
| Window* _pParent, const ResId& rResId ) : |
| SvxContourDlg ( _pBindings, pCW, _pParent, rResId ), |
| pCheckObj ( NULL ), |
| aContourItem ( SID_CONTOUR_EXEC, *this, *_pBindings ), |
| aTbx1 ( this, ResId( TBX1, *rResId.GetResMgr() ) ), |
| aMtfTolerance ( this, ResId( MTF_TOLERANCE, *rResId.GetResMgr() ) ), |
| aContourWnd ( this, ResId( CTL_CONTOUR, *rResId.GetResMgr() ) ), |
| aStbStatus ( this, WB_BORDER | WB_3DLOOK | WB_LEFT ), |
| nGrfChanged ( 0UL ), |
| bExecState ( sal_False ), |
| bGraphicLinked ( sal_False ), |
| maImageList ( SVX_RES( CD_IMAPDLG ) ), |
| maImageListH ( SVX_RES( CDH_IMAPDLG ) ) |
| { |
| ApplyImageList(); |
| |
| FreeResource(); |
| |
| SvxContourDlg::SetSuperClass( *this ); |
| |
| aContourWnd.SetMousePosLink( LINK( this, SvxSuperContourDlg, MousePosHdl ) ); |
| aContourWnd.SetGraphSizeLink( LINK( this, SvxSuperContourDlg, GraphSizeHdl ) ); |
| aContourWnd.SetUpdateLink( LINK( this, SvxSuperContourDlg, StateHdl ) ); |
| aContourWnd.SetPipetteHdl( LINK( this, SvxSuperContourDlg, PipetteHdl ) ); |
| aContourWnd.SetPipetteClickHdl( LINK( this, SvxSuperContourDlg, PipetteClickHdl ) ); |
| aContourWnd.SetWorkplaceClickHdl( LINK( this, SvxSuperContourDlg, WorkplaceClickHdl ) ); |
| |
| const Size aTbxSize( aTbx1.CalcWindowSizePixel() ); |
| Point aPos( aTbx1.GetPosPixel() ); |
| SvtMiscOptions aMiscOptions; |
| |
| aMiscOptions.AddListenerLink( LINK( this, SvxSuperContourDlg, MiscHdl ) ); |
| |
| aTbx1.SetOutStyle( aMiscOptions.GetToolboxStyle() ); |
| aTbx1.SetSizePixel( aTbxSize ); |
| aTbx1.SetSelectHdl( LINK( this, SvxSuperContourDlg, Tbx1ClickHdl ) ); |
| |
| aPos.X() += aTbxSize.Width() + LogicToPixel( Size( 3, 0 ), MapMode( MAP_APPFONT ) ).Width(); |
| aMtfTolerance.SetPosPixel( aPos ); |
| aMtfTolerance.SetValue( 10L ); |
| |
| SetMinOutputSizePixel( aLastSize = GetOutputSizePixel() ); |
| |
| aStbStatus.InsertItem( 1, 130, SIB_LEFT | SIB_IN | SIB_AUTOSIZE ); |
| aStbStatus.InsertItem( 2, 10 + GetTextWidth( String::CreateFromAscii( " 9999,99 cm / 9999,99 cm " ) ), SIB_CENTER | SIB_IN ); |
| aStbStatus.InsertItem( 3, 10 + GetTextWidth( String::CreateFromAscii( " 9999,99 cm x 9999,99 cm " ) ), SIB_CENTER | SIB_IN ); |
| aStbStatus.InsertItem( 4, 20, SIB_CENTER | SIB_IN ); |
| |
| Resize(); |
| |
| aUpdateTimer.SetTimeout( 100 ); |
| aUpdateTimer.SetTimeoutHdl( LINK( this, SvxSuperContourDlg, UpdateHdl ) ); |
| |
| aCreateTimer.SetTimeout( 50 ); |
| aCreateTimer.SetTimeoutHdl( LINK( this, SvxSuperContourDlg, CreateHdl ) ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Dtor |
| |* |
| \************************************************************************/ |
| |
| SvxSuperContourDlg::~SvxSuperContourDlg() |
| { |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Resize-Methode |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::Resize() |
| { |
| SfxFloatingWindow::Resize(); |
| |
| Size aMinSize( GetMinOutputSizePixel() ); |
| Size aNewSize( GetOutputSizePixel() ); |
| |
| if ( aNewSize.Height() >= aMinSize.Height() ) |
| { |
| Size _aSize( aStbStatus.GetSizePixel() ); |
| Point aPoint( 0, aNewSize.Height() - _aSize.Height() ); |
| |
| // StatusBar positionieren |
| aStbStatus.SetPosSizePixel( aPoint, Size( aNewSize.Width(), _aSize.Height() ) ); |
| aStbStatus.Show(); |
| |
| // EditWindow positionieren |
| _aSize.Width() = aNewSize.Width() - 18; |
| _aSize.Height() = aPoint.Y() - aContourWnd.GetPosPixel().Y() - 6; |
| aContourWnd.SetSizePixel( _aSize ); |
| |
| aLastSize = aNewSize; |
| } |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Close-Methode |
| |* |
| \************************************************************************/ |
| |
| sal_Bool SvxSuperContourDlg::Close() |
| { |
| sal_Bool bRet = sal_True; |
| |
| if ( aTbx1.IsItemEnabled( TBI_APPLY ) ) |
| { |
| QueryBox aQBox( this, WB_YES_NO_CANCEL | WB_DEF_YES, |
| String( CONT_RESID( STR_CONTOURDLG_MODIFY ) ) ); |
| const long nRet = aQBox.Execute(); |
| |
| if ( nRet == RET_YES ) |
| { |
| SfxBoolItem aBoolItem( SID_CONTOUR_EXEC, sal_True ); |
| GetBindings().GetDispatcher()->Execute( |
| SID_CONTOUR_EXEC, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aBoolItem, 0L ); |
| } |
| else if ( nRet == RET_CANCEL ) |
| bRet = sal_False; |
| } |
| |
| return( bRet ? SfxFloatingWindow::Close() : sal_False ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Enabled oder disabled alle Controls |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::SetExecState( sal_Bool bEnable ) |
| { |
| bExecState = bEnable; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::SetGraphic( const Graphic& rGraphic ) |
| { |
| aUndoGraphic = aRedoGraphic = Graphic(); |
| aGraphic = rGraphic; |
| nGrfChanged = 0UL; |
| aContourWnd.SetGraphic( aGraphic ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::SetPolyPolygon( const PolyPolygon& rPolyPoly ) |
| { |
| DBG_ASSERT( aContourWnd.GetGraphic().GetType() != GRAPHIC_NONE, "Graphic must've been set first!" ); |
| |
| PolyPolygon aPolyPoly( rPolyPoly ); |
| const MapMode aMap100( MAP_100TH_MM ); |
| const MapMode aGrfMap( aGraphic.GetPrefMapMode() ); |
| OutputDevice* pOutDev = Application::GetDefaultDevice(); |
| sal_Bool bPixelMap = aGrfMap.GetMapUnit() == MAP_PIXEL; |
| |
| for ( sal_uInt16 j = 0, nPolyCount = aPolyPoly.Count(); j < nPolyCount; j++ ) |
| { |
| Polygon& rPoly = aPolyPoly[ j ]; |
| |
| for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) |
| { |
| Point& rPt = rPoly[ i ]; |
| |
| if ( !bPixelMap ) |
| rPt = pOutDev->LogicToPixel( rPt, aGrfMap ); |
| |
| rPt = pOutDev->PixelToLogic( rPt, aMap100 ); |
| } |
| } |
| |
| aContourWnd.SetPolyPolygon( aPolyPoly ); |
| aContourWnd.GetSdrModel()->SetChanged( sal_True ); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| PolyPolygon SvxSuperContourDlg::GetPolyPolygon( sal_Bool bRescaleToGraphic ) |
| { |
| PolyPolygon aRetPolyPoly( aContourWnd.GetPolyPolygon() ); |
| |
| if ( bRescaleToGraphic ) |
| { |
| const MapMode aMap100( MAP_100TH_MM ); |
| const MapMode aGrfMap( aGraphic.GetPrefMapMode() ); |
| OutputDevice* pOutDev = Application::GetDefaultDevice(); |
| sal_Bool bPixelMap = aGrfMap.GetMapUnit() == MAP_PIXEL; |
| |
| for ( sal_uInt16 j = 0, nPolyCount = aRetPolyPoly.Count(); j < nPolyCount; j++ ) |
| { |
| Polygon& rPoly = aRetPolyPoly[ j ]; |
| |
| for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) |
| { |
| Point& rPt = rPoly[ i ]; |
| |
| rPt = pOutDev->LogicToPixel( rPt, aMap100 ); |
| |
| if ( !bPixelMap ) |
| rPt = pOutDev->PixelToLogic( rPt, aGrfMap ); |
| } |
| } |
| } |
| |
| return aRetPolyPoly; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::UpdateGraphic( const Graphic& rGraphic, sal_Bool _bGraphicLinked, |
| const PolyPolygon* pPolyPoly, void* pEditingObj ) |
| { |
| aUpdateGraphic = rGraphic; |
| bUpdateGraphicLinked = _bGraphicLinked; |
| pUpdateEditingObject = pEditingObj; |
| |
| if ( pPolyPoly ) |
| aUpdatePolyPoly = *pPolyPoly; |
| else |
| aUpdatePolyPoly = PolyPolygon(); |
| |
| aUpdateTimer.Start(); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| sal_Bool SvxSuperContourDlg::IsUndoPossible() const |
| { |
| return aUndoGraphic.GetType() != GRAPHIC_NONE; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| sal_Bool SvxSuperContourDlg::IsRedoPossible() const |
| { |
| return aRedoGraphic.GetType() != GRAPHIC_NONE; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::DoAutoCreate() |
| { |
| aCreateTimer.Start(); |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| void SvxSuperContourDlg::ReducePoints( const long nTol ) |
| { |
| PolyPolygon aPolyPoly( GetPolyPolygon( sal_False ) ); |
| |
| if ( aPolyPoly.Count() ) |
| { |
| const MapMode aMapMode( MAP_100TH_MM ); |
| const long nTol2 = nTol * nTol; |
| Polygon& rPoly = aPolyPoly[ 0 ]; |
| OutputDevice* pOutDev = Application::GetDefaultDevice(); |
| Point aPtPix; |
| const sal_uInt16 nSize = rPoly.GetSize(); |
| sal_uInt16 nCounter = 0; |
| |
| if ( nSize ) |
| aPtPix = pOutDev->LogicToPixel( rPoly[ 0 ], aMapMode ); |
| |
| for( sal_uInt16 i = 1; i < nSize; i++ ) |
| { |
| const Point& rNewPt = rPoly[ i ]; |
| const Point aNewPtPix( pOutDev->LogicToPixel( rNewPt, aMapMode ) ); |
| |
| const long nDistX = aNewPtPix.X() - aPtPix.X(); |
| const long nDistY = aNewPtPix.Y() - aPtPix.Y(); |
| |
| if( ( nDistX * nDistX + nDistY * nDistY ) >= nTol2 ) |
| { |
| rPoly[ ++nCounter ] = rNewPt; |
| aPtPix = aNewPtPix; |
| } |
| } |
| |
| rPoly.SetSize( nCounter ); |
| aContourWnd.SetPolyPolygon( aPolyPoly ); |
| aContourWnd.GetSdrModel()->SetChanged( sal_True ); |
| } |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Click-Hdl fuer ToolBox |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, Tbx1ClickHdl, ToolBox*, pTbx ) |
| { |
| sal_uInt16 nNewItemId = pTbx->GetCurItemId(); |
| |
| switch( pTbx->GetCurItemId() ) |
| { |
| case( TBI_APPLY ): |
| { |
| SfxBoolItem aBoolItem( SID_CONTOUR_EXEC, sal_True ); |
| GetBindings().GetDispatcher()->Execute( |
| SID_CONTOUR_EXEC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aBoolItem, 0L ); |
| } |
| break; |
| |
| case( TBI_WORKPLACE ): |
| { |
| if ( aTbx1.IsItemChecked( TBI_WORKPLACE ) ) |
| { |
| QueryBox aQBox( this, WB_YES_NO | WB_DEF_NO, String( CONT_RESID( STR_CONTOURDLG_WORKPLACE ) ) ); |
| |
| if ( !aContourWnd.IsContourChanged() || ( aQBox.Execute() == RET_YES ) ) |
| aContourWnd.SetWorkplaceMode( sal_True ); |
| else |
| aTbx1.CheckItem( TBI_WORKPLACE, sal_False ); |
| } |
| else |
| aContourWnd.SetWorkplaceMode( sal_False ); |
| } |
| break; |
| |
| case( TBI_SELECT ): |
| { |
| pTbx->CheckItem( nNewItemId, sal_True ); |
| aContourWnd.SetEditMode( sal_True ); |
| } |
| break; |
| |
| case( TBI_RECT ): |
| { |
| pTbx->CheckItem( nNewItemId, sal_True ); |
| aContourWnd.SetObjKind( OBJ_RECT ); |
| } |
| break; |
| |
| case( TBI_CIRCLE ): |
| { |
| pTbx->CheckItem( nNewItemId, sal_True ); |
| aContourWnd.SetObjKind( OBJ_CIRC ); |
| |
| } |
| break; |
| |
| case( TBI_POLY ): |
| { |
| pTbx->CheckItem( nNewItemId, sal_True ); |
| aContourWnd.SetObjKind( OBJ_POLY ); |
| } |
| break; |
| |
| case( TBI_FREEPOLY ): |
| { |
| pTbx->CheckItem( nNewItemId, sal_True ); |
| aContourWnd.SetObjKind( OBJ_FREEFILL ); |
| } |
| break; |
| |
| case( TBI_POLYEDIT ): |
| aContourWnd.SetPolyEditMode( pTbx->IsItemChecked( TBI_POLYEDIT ) ? SID_BEZIER_MOVE : 0 ); |
| break; |
| |
| case( TBI_POLYMOVE ): |
| aContourWnd.SetPolyEditMode( SID_BEZIER_MOVE ); |
| break; |
| |
| case( TBI_POLYINSERT ): |
| aContourWnd.SetPolyEditMode( SID_BEZIER_INSERT ); |
| break; |
| |
| case( TBI_POLYDELETE ): |
| aContourWnd.GetSdrView()->DeleteMarkedPoints(); |
| break; |
| |
| case( TBI_UNDO ): |
| { |
| nGrfChanged = nGrfChanged ? nGrfChanged-- : 0UL; |
| aRedoGraphic = aGraphic; |
| aGraphic = aUndoGraphic; |
| aUndoGraphic = Graphic(); |
| aContourWnd.SetGraphic( aGraphic, sal_False ); |
| } |
| break; |
| |
| case( TBI_REDO ): |
| { |
| nGrfChanged++; |
| aUndoGraphic = aGraphic; |
| aGraphic = aRedoGraphic; |
| aRedoGraphic = Graphic(); |
| aContourWnd.SetGraphic( aGraphic, sal_False ); |
| } |
| break; |
| |
| case( TBI_AUTOCONTOUR ): |
| aCreateTimer.Start(); |
| break; |
| |
| case( TBI_PIPETTE ): |
| { |
| sal_Bool bPipette = aTbx1.IsItemChecked( TBI_PIPETTE ); |
| |
| if ( !bPipette ) |
| aStbStatus.Invalidate(); |
| else if ( bGraphicLinked ) |
| { |
| QueryBox aQBox( this, WB_YES_NO | WB_DEF_YES, String( CONT_RESID( STR_CONTOURDLG_LINKED ) ) ); |
| |
| if ( aQBox.Execute() != RET_YES ) |
| { |
| aTbx1.CheckItem( TBI_PIPETTE, bPipette = sal_False ); |
| aStbStatus.Invalidate(); |
| } |
| } |
| |
| aContourWnd.SetPipetteMode( bPipette ); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, MousePosHdl, ContourWindow*, pWnd ) |
| { |
| String aStr; |
| const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); |
| const Point& rMousePos = pWnd->GetMousePos(); |
| LocaleDataWrapper aLocaleWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() ); |
| const sal_Unicode cSep = aLocaleWrapper.getNumDecimalSep().GetChar(0); |
| |
| aStr.Assign( GetUnitString( rMousePos.X(), eFieldUnit, cSep ) ); |
| aStr.Append( String::CreateFromAscii( " / " ) ); |
| aStr.Append( GetUnitString( rMousePos.Y(), eFieldUnit, cSep ) ); |
| |
| aStbStatus.SetItemText( 2, aStr ); |
| |
| return 0L; |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, GraphSizeHdl, ContourWindow*, pWnd ) |
| { |
| String aStr; |
| const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); |
| const Size& rSize = pWnd->GetGraphicSize(); |
| LocaleDataWrapper aLocaleWrapper( ::comphelper::getProcessServiceFactory(), Application::GetSettings().GetLocale() ); |
| const sal_Unicode cSep = aLocaleWrapper.getNumDecimalSep().GetChar(0); |
| |
| aStr.Assign( GetUnitString( rSize.Width(), eFieldUnit, cSep ) ); |
| aStr.Append( String::CreateFromAscii( " x " ) ); |
| aStr.Append( GetUnitString( rSize.Height(), eFieldUnit, cSep ) ); |
| |
| aStbStatus.SetItemText( 3, aStr ); |
| |
| return 0L; |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, UpdateHdl, Timer*, EMPTYARG ) |
| { |
| aUpdateTimer.Stop(); |
| |
| if ( pUpdateEditingObject != pCheckObj ) |
| { |
| if( !GetEditingObject() ) |
| aContourWnd.GrabFocus(); |
| |
| SetGraphic( aUpdateGraphic ); |
| SetPolyPolygon( aUpdatePolyPoly ); |
| SetEditingObject( pUpdateEditingObject ); |
| bGraphicLinked = bUpdateGraphicLinked; |
| |
| aUpdateGraphic = Graphic(); |
| aUpdatePolyPoly = PolyPolygon(); |
| bUpdateGraphicLinked = sal_False; |
| |
| aContourWnd.GetSdrModel()->SetChanged( sal_False ); |
| } |
| |
| GetBindings().Invalidate( SID_CONTOUR_EXEC ); |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, CreateHdl, Timer*, EMPTYARG ) |
| { |
| aCreateTimer.Stop(); |
| |
| const Rectangle aWorkRect = aContourWnd.LogicToPixel( aContourWnd.GetWorkRect(), MapMode( MAP_100TH_MM ) ); |
| const Graphic& rGraphic = aContourWnd.GetGraphic(); |
| const sal_Bool bValid = aWorkRect.Left() != aWorkRect.Right() && aWorkRect.Top() != aWorkRect.Bottom(); |
| |
| EnterWait(); |
| SetPolyPolygon( CreateAutoContour( rGraphic, bValid ? &aWorkRect : NULL ) ); |
| LeaveWait(); |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, StateHdl, ContourWindow*, pWnd ) |
| { |
| const SdrObject* pObj = pWnd->GetSelectedSdrObject(); |
| const SdrView* pView = pWnd->GetSdrView(); |
| const sal_Bool bPolyEdit = ( pObj != NULL ) && pObj->ISA( SdrPathObj ); |
| const sal_Bool bDrawEnabled = !( bPolyEdit && aTbx1.IsItemChecked( TBI_POLYEDIT ) ); |
| const sal_Bool bPipette = aTbx1.IsItemChecked( TBI_PIPETTE ); |
| const sal_Bool bWorkplace = aTbx1.IsItemChecked( TBI_WORKPLACE ); |
| const sal_Bool bDontHide = !( bPipette || bWorkplace ); |
| const sal_Bool bBitmap = pWnd->GetGraphic().GetType() == GRAPHIC_BITMAP; |
| |
| aTbx1.EnableItem( TBI_APPLY, bDontHide && bExecState && pWnd->IsChanged() ); |
| |
| aTbx1.EnableItem( TBI_WORKPLACE, !bPipette && bDrawEnabled ); |
| |
| aTbx1.EnableItem( TBI_SELECT, bDontHide && bDrawEnabled ); |
| aTbx1.EnableItem( TBI_RECT, bDontHide && bDrawEnabled ); |
| aTbx1.EnableItem( TBI_CIRCLE, bDontHide && bDrawEnabled ); |
| aTbx1.EnableItem( TBI_POLY, bDontHide && bDrawEnabled ); |
| aTbx1.EnableItem( TBI_FREEPOLY, bDontHide && bDrawEnabled ); |
| |
| aTbx1.EnableItem( TBI_POLYEDIT, bDontHide && bPolyEdit ); |
| aTbx1.EnableItem( TBI_POLYMOVE, bDontHide && !bDrawEnabled ); |
| aTbx1.EnableItem( TBI_POLYINSERT, bDontHide && !bDrawEnabled ); |
| aTbx1.EnableItem( TBI_POLYDELETE, bDontHide && !bDrawEnabled && pView->IsDeleteMarkedPointsPossible() ); |
| |
| aTbx1.EnableItem( TBI_AUTOCONTOUR, bDontHide && bDrawEnabled ); |
| aTbx1.EnableItem( TBI_PIPETTE, !bWorkplace && bDrawEnabled && bBitmap ); |
| |
| aTbx1.EnableItem( TBI_UNDO, bDontHide && IsUndoPossible() ); |
| aTbx1.EnableItem( TBI_REDO, bDontHide && IsRedoPossible() ); |
| |
| if ( bPolyEdit ) |
| { |
| sal_uInt16 nId = 0; |
| |
| switch( pWnd->GetPolyEditMode() ) |
| { |
| case( SID_BEZIER_MOVE ): nId = TBI_POLYMOVE; break; |
| case( SID_BEZIER_INSERT ): nId = TBI_POLYINSERT; break; |
| |
| default: |
| break; |
| } |
| |
| aTbx1.CheckItem( nId, sal_True ); |
| } |
| else |
| { |
| aTbx1.CheckItem( TBI_POLYEDIT, sal_False ); |
| aTbx1.CheckItem( TBI_POLYMOVE, sal_True ); |
| aTbx1.CheckItem( TBI_POLYINSERT, sal_False ); |
| pWnd->SetPolyEditMode( 0 ); |
| } |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, PipetteHdl, ContourWindow*, pWnd ) |
| { |
| const Color& rOldLineColor = aStbStatus.GetLineColor(); |
| const Color& rOldFillColor = aStbStatus.GetFillColor(); |
| |
| Rectangle aRect( aStbStatus.GetItemRect( 4 ) ); |
| const Color& rColor = pWnd->GetPipetteColor(); |
| |
| aStbStatus.SetLineColor( rColor ); |
| aStbStatus.SetFillColor( rColor ); |
| |
| aRect.Left() += 4; |
| aRect.Top() += 4; |
| aRect.Right() -= 4; |
| aRect.Bottom() -= 4; |
| |
| aStbStatus.DrawRect( aRect ); |
| |
| aStbStatus.SetLineColor( rOldLineColor ); |
| aStbStatus.SetFillColor( rOldFillColor ); |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, PipetteClickHdl, ContourWindow*, pWnd ) |
| { |
| if ( pWnd->IsClickValid() ) |
| { |
| Bitmap aMask; |
| const Color& rColor = pWnd->GetPipetteColor(); |
| |
| EnterWait(); |
| |
| if( aGraphic.GetType() == GRAPHIC_BITMAP ) |
| { |
| Bitmap aBmp( aGraphic.GetBitmap() ); |
| const long nTol = static_cast<long>(aMtfTolerance.GetValue() * 255L / 100L); |
| |
| aMask = aBmp.CreateMask( rColor, nTol ); |
| |
| if( aGraphic.IsTransparent() ) |
| aMask.CombineSimple( aGraphic.GetBitmapEx().GetMask(), BMP_COMBINE_OR ); |
| |
| if( !!aMask ) |
| { |
| QueryBox aQBox( this, WB_YES_NO | WB_DEF_YES, String( CONT_RESID( STR_CONTOURDLG_NEWPIPETTE ) ) ); |
| sal_Bool bNewContour; |
| |
| aRedoGraphic = Graphic(); |
| aUndoGraphic = aGraphic; |
| aGraphic = Graphic( BitmapEx( aBmp, aMask ) ); |
| nGrfChanged++; |
| |
| bNewContour = ( aQBox.Execute() == RET_YES ); |
| pWnd->SetGraphic( aGraphic, bNewContour ); |
| |
| if( bNewContour ) |
| aCreateTimer.Start(); |
| } |
| } |
| |
| LeaveWait(); |
| } |
| |
| aTbx1.CheckItem( TBI_PIPETTE, sal_False ); |
| pWnd->SetPipetteMode( sal_False ); |
| aStbStatus.Invalidate(); |
| |
| return 0L; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, WorkplaceClickHdl, ContourWindow*, pWnd ) |
| { |
| aTbx1.CheckItem( TBI_WORKPLACE, sal_False ); |
| aTbx1.CheckItem( TBI_SELECT, sal_True ); |
| pWnd->SetWorkplaceMode( sal_False ); |
| |
| return 0L; |
| } |
| |
| void SvxSuperContourDlg::ApplyImageList() |
| { |
| bool bHighContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); |
| |
| ImageList& rImgLst = bHighContrast ? maImageListH : maImageList; |
| |
| aTbx1.SetImageList( rImgLst ); |
| } |
| |
| void SvxSuperContourDlg::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| SfxFloatingWindow::DataChanged( rDCEvt ); |
| |
| if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) ) |
| ApplyImageList(); |
| } |
| |
| /************************************************************************* |
| |* |
| |* |
| |* |
| \************************************************************************/ |
| |
| IMPL_LINK( SvxSuperContourDlg, MiscHdl, void*, EMPTYARG ) |
| { |
| SvtMiscOptions aMiscOptions; |
| aTbx1.SetOutStyle( aMiscOptions.GetToolboxStyle() ); |
| |
| return 0L; |
| } |
| |