/************************************************************************* * * $RCSfile: transfrm.cxx,v $ * * $Revision: 1.18 $ * * last change: $Author: kz $ $Date: 2005-01-21 16:54:37 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ #ifdef SVX_DLLIMPLEMENTATION #undef SVX_DLLIMPLEMENTATION #endif // include --------------------------------------------------------------- #define ITEMID_SIZE 0 #ifndef _SHL_HXX //autogen #include #endif #ifndef _SFXAPP_HXX //autogen #include #endif #ifndef _SVDVIEW_HXX //autogen #include "svdview.hxx" #endif #ifndef _SVDOBJ_HXX //autogen #include "svdobj.hxx" #endif #ifndef _SVDPAGV_HXX //autogen #include "svdpagv.hxx" #endif #ifndef _SVDOTEXT_HXX //autogen #include "svdotext.hxx" #endif #ifndef _SDERITM_HXX //autogen #include "sderitm.hxx" #endif #include #include "dialogs.hrc" #include "transfrm.hrc" #include "sizeitem.hxx" #include "transfrm.hxx" #include "dialmgr.hxx" #include "dlgutil.hxx" #include "svxenum.hxx" #include "anchorid.hxx" #ifndef _SFXMODULE_HXX #include #endif #ifndef _SFXRECTITEM_HXX //autogen #include #endif #ifndef _AEITEM_HXX //autogen #include #endif #ifndef _SVX_SWPOSSIZETABPAGE_HXX #include #endif // Toleranz fuer WorkingArea #define DIFF 1000 // static ---------------------------------------------------------------- static USHORT pPosRanges[] = { SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_POS_Y, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_ANCHOR, SID_ATTR_TRANSFORM_VERT_ORIENT, 0 }; static USHORT pSizeRanges[] = { SID_ATTR_TRANSFORM_WIDTH, SID_ATTR_TRANSFORM_SIZE_POINT, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_AUTOWIDTH, SID_ATTR_TRANSFORM_AUTOHEIGHT, 0 }; static USHORT pPosSizeRanges[] = { SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_POS_Y, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_ANCHOR, SID_ATTR_TRANSFORM_VERT_ORIENT, SID_ATTR_TRANSFORM_WIDTH, SID_ATTR_TRANSFORM_SIZE_POINT, SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_AUTOWIDTH, SID_ATTR_TRANSFORM_AUTOHEIGHT, 0 }; static USHORT pAngleRanges[] = { SID_ATTR_TRANSFORM_ROT_X, SID_ATTR_TRANSFORM_ANGLE, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN, 0 }; static USHORT pSlantRanges[] = { SDRATTR_ECKENRADIUS, SDRATTR_ECKENRADIUS, SID_ATTR_TRANSFORM_SHEAR, SID_ATTR_TRANSFORM_SHEAR_VERTICAL, SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN, 0 }; // Funktion ConvertRect Rectangle lcl_ConvertRect( const Rectangle& rInRect, USHORT nDigits, MapUnit ePoolUnit, FieldUnit eDlgUnit ) { Rectangle aRect; aRect.Left() = MetricField::ConvertValue( rInRect.Left(), nDigits, ePoolUnit, eDlgUnit ); aRect.Right() = MetricField::ConvertValue( rInRect.Right(), nDigits, ePoolUnit, eDlgUnit ); aRect.Top() = MetricField::ConvertValue( rInRect.Top(), nDigits, ePoolUnit, eDlgUnit ); aRect.Bottom() = MetricField::ConvertValue( rInRect.Bottom(), nDigits, ePoolUnit, eDlgUnit ); return( aRect ); } // Funktion ConvertPoint Point lcl_ConvertPoint( Point aInPt, USHORT nDigits, MapUnit ePoolUnit, FieldUnit eDlgUnit ) { Point aPt; aPt.X() = MetricField::ConvertValue( aInPt.X(), nDigits, ePoolUnit, eDlgUnit ); aPt.Y() = MetricField::ConvertValue( aInPt.Y(), nDigits, ePoolUnit, eDlgUnit ); return( aPt ); } // Funktion ScaleRect (Beruecksichtigung des Massstabes) void lcl_ScaleRect( Rectangle& aRect, Fraction aUIScale ) { aRect.Left() = Fraction( aRect.Left() ) / aUIScale; aRect.Right() = Fraction( aRect.Right() ) / aUIScale; aRect.Top() = Fraction( aRect.Top() ) / aUIScale; aRect.Bottom() = Fraction( aRect.Bottom() ) / aUIScale; } // Funktion ScalePoint (Beruecksichtigung des Massstabes) void lcl_ScalePoint( Point& aPt, Fraction aUIScale ) { aPt.X() = Fraction( aPt.X() ) / aUIScale; aPt.Y() = Fraction( aPt.Y() ) / aUIScale; } /************************************************************************* |* |* Konstruktor des Tab-Dialogs: Fuegt die Seiten zum Dialog hinzu |* \************************************************************************/ SvxTransformTabDialog::SvxTransformTabDialog( Window* pParent, const SfxItemSet* pAttr, const SdrView* pSdrView, USHORT nAnchorTypes ) : SfxTabDialog( pParent, ResId( RID_SVXDLG_TRANSFORM, DIALOG_MGR() ), pAttr ), pView ( pSdrView ), nAnchorCtrls(nAnchorTypes) { FreeResource(); DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" ); //different positioning page in Writer if(nAnchorCtrls & 0x00ff ) { AddTabPage( RID_SVXPAGE_SWPOSSIZE, SvxSwPosSizeTabPage::Create, SvxSwPosSizeTabPage::GetRanges ); RemoveTabPage( RID_SVXPAGE_POSITION_SIZE); } else { AddTabPage( RID_SVXPAGE_POSITION_SIZE, SvxPositionSizeTabPage::Create, SvxPositionSizeTabPage::GetRanges ); RemoveTabPage( RID_SVXPAGE_SWPOSSIZE ); } AddTabPage( RID_SVXPAGE_ANGLE, SvxAngleTabPage::Create, SvxAngleTabPage::GetRanges ); AddTabPage( RID_SVXPAGE_SLANT, SvxSlantTabPage::Create, SvxSlantTabPage::GetRanges ); } // ----------------------------------------------------------------------- SvxTransformTabDialog::~SvxTransformTabDialog() { } // ----------------------------------------------------------------------- void SvxTransformTabDialog::PageCreated( USHORT nId, SfxTabPage &rPage ) { switch( nId ) { case RID_SVXPAGE_POSITION_SIZE: ( (SvxPositionSizeTabPage&) rPage ).SetView( pView ); ( (SvxPositionSizeTabPage&) rPage ).Construct(); if( nAnchorCtrls & SVX_OBJ_NORESIZE ) ( (SvxPositionSizeTabPage&) rPage ).DisableResize(); if( nAnchorCtrls & SVX_OBJ_NOPROTECT ) ( (SvxPositionSizeTabPage&) rPage ).DisableProtect(); // if(nAnchorCtrls & 0x00ff ) // ( (SvxPositionSizeTabPage&) rPage ).ShowAnchorCtrls(nAnchorCtrls); break; case RID_SVXPAGE_SWPOSSIZE : { SvxSwPosSizeTabPage& rSwPos = static_cast(rPage); rSwPos.EnableAnchorTypes(nAnchorCtrls); rSwPos.SetValidateFramePosLink( aValidateLink ); rSwPos.SetView( pView ); } break; case RID_SVXPAGE_ANGLE: ( (SvxAngleTabPage&) rPage ).SetView( pView ); ( (SvxAngleTabPage&) rPage ).Construct(); break; case RID_SVXPAGE_SLANT: ( (SvxSlantTabPage&) rPage ).SetView( pView ); ( (SvxSlantTabPage&) rPage ).Construct(); break; } } /*-- 05.03.2004 11:47:36--------------------------------------------------- link for the Writer to validate positions -----------------------------------------------------------------------*/ void SvxTransformTabDialog::SetValidateFramePosLink( const Link& rLink ) { aValidateLink = rLink; } /************************************************************************* |* |* Dialog zum Aendern der Position des Drehwinkels und des Drehwinkels |* der Grafikobjekte |* \************************************************************************/ SvxAngleTabPage::SvxAngleTabPage( Window* pParent, const SfxItemSet& rInAttrs ) : SvxTabPage ( pParent, ResId( RID_SVXPAGE_ANGLE, DIALOG_MGR() ), rInAttrs ), aFlPosition ( this, ResId( FL_POSITION ) ), aFtPosX ( this, ResId( FT_POS_X ) ), aMtrPosX ( this, ResId( MTR_FLD_POS_X ) ), aFtPosY ( this, ResId( FT_POS_Y ) ), aMtrPosY ( this, ResId( MTR_FLD_POS_Y ) ), aFtPosPresets ( this, ResId(FT_POSPRESETS) ), aCtlRect ( this, ResId( CTL_RECT ) ), aFlAngle ( this, ResId( FL_ANGLE ) ), aFtAngle ( this, ResId( FT_ANGLE ) ), aMtrAngle ( this, ResId( MTR_FLD_ANGLE ) ), aFtAnglePresets ( this, ResId(FT_ANGLEPRESETS) ), aCtlAngle ( this, ResId( CTL_ANGLE ), RP_RB, 200, 80, CS_ANGLE ), rOutAttrs ( rInAttrs ) { FreeResource(); // diese Page braucht ExchangeSupport //! SetExchangeSupport(); noch nicht // PoolUnit ermitteln SfxItemPool* pPool = rOutAttrs.GetPool(); DBG_ASSERT( pPool, "Wo ist der Pool" ); ePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X ); aMtrAngle.SetModifyHdl( LINK( this, SvxAngleTabPage, ModifiedHdl ) ); } // ----------------------------------------------------------------------- void SvxAngleTabPage::Construct() { // Setzen des Rechtecks DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" ); eDlgUnit = GetModuleFieldUnit( &GetItemSet() ); SetFieldUnit( aMtrPosX, eDlgUnit, TRUE ); SetFieldUnit( aMtrPosY, eDlgUnit, TRUE ); if( eDlgUnit == FUNIT_MILE || eDlgUnit == FUNIT_KM ) { aMtrPosX.SetDecimalDigits( 3 ); aMtrPosY.SetDecimalDigits( 3 ); } aRect = pView->GetAllMarkedRect(); pView->GetPageViewPvNum( 0 )->LogicToPagePos( aRect ); // Ankerposition beachten (Writer) const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); if( rMarkList.GetMarkCount() >= 1 ) { const SdrObject* pObj = rMarkList.GetMark( 0 )->GetObj(); aAnchorPos = pObj->GetAnchorPos(); if( aAnchorPos != Point( 0, 0 ) ) // -> Writer { aRect.Left() -= aAnchorPos.X(); aRect.Right() -= aAnchorPos.X(); aRect.Top() -= aAnchorPos.Y(); aRect.Bottom() -= aAnchorPos.Y(); } } // Massstab Fraction aUIScale = pView->GetModel()->GetUIScale(); lcl_ScaleRect( aRect, aUIScale ); // Umrechnung auf UI-Unit int nDigits = aMtrPosX.GetDecimalDigits(); aRect = lcl_ConvertRect( aRect, nDigits, (MapUnit) ePoolUnit, eDlgUnit ); if( !pView->IsRotateAllowed() ) { aFlPosition.Disable(); aFtPosX.Disable(); aMtrPosX.Disable(); aFtPosY.Disable(); aMtrPosY.Disable(); aFtPosPresets.Disable(); aCtlRect.Disable(); aFlAngle.Disable(); aFtAngle.Disable(); aMtrAngle.Disable(); aFtAnglePresets.Disable(); aCtlAngle.Disable(); } } // ----------------------------------------------------------------------- BOOL SvxAngleTabPage::FillItemSet( SfxItemSet& rOutAttrs ) { BOOL bModified = FALSE; if(aMtrAngle.IsValueModified() || aMtrPosX.IsValueModified() || aMtrPosY.IsValueModified()) { rOutAttrs.Put( SfxInt32Item( GetWhich( SID_ATTR_TRANSFORM_ANGLE ), aMtrAngle.GetValue() ) ); Fraction aUIScale = pView->GetModel()->GetUIScale(); long nTmp = GetCoreValue( aMtrPosX, ePoolUnit ); nTmp += aAnchorPos.X(); nTmp = Fraction( nTmp ) * aUIScale; rOutAttrs.Put( SfxInt32Item( GetWhich( SID_ATTR_TRANSFORM_ROT_X ), nTmp ) ); nTmp = GetCoreValue( aMtrPosY, ePoolUnit ); nTmp += aAnchorPos.Y(); nTmp = Fraction( nTmp ) * aUIScale; rOutAttrs.Put( SfxInt32Item( GetWhich( SID_ATTR_TRANSFORM_ROT_Y ), nTmp ) ); bModified |= TRUE; } return bModified; } // ----------------------------------------------------------------------- void SvxAngleTabPage::Reset( const SfxItemSet& rAttrs ) { const SfxPoolItem* pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_ROT_X ); Fraction aUIScale = pView->GetModel()->GetUIScale(); if ( pItem ) { long nTmp = ( (const SfxInt32Item*)pItem )->GetValue() - aAnchorPos.X();; nTmp = Fraction( nTmp ) / aUIScale; SetMetricValue( aMtrPosX, nTmp, ePoolUnit ); } else aMtrPosX.SetText( String() ); pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_ROT_Y ); if ( pItem ) { long nTmp = ( (const SfxInt32Item*)pItem )->GetValue() - aAnchorPos.Y();; nTmp = Fraction( nTmp ) / aUIScale; SetMetricValue( aMtrPosY, nTmp, ePoolUnit ); } else aMtrPosX.SetText( String() ); pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_ANGLE ); if ( pItem ) aMtrAngle.SetValue( ( (const SfxInt32Item*)pItem )->GetValue() ); else aMtrAngle.SetText( String() ); aMtrAngle.SaveValue(); ModifiedHdl( this ); } // ----------------------------------------------------------------------- SfxTabPage* SvxAngleTabPage::Create( Window* pWindow, const SfxItemSet& rOutAttrs ) { return( new SvxAngleTabPage( pWindow, rOutAttrs ) ); } //------------------------------------------------------------------------ USHORT* SvxAngleTabPage::GetRanges() { return( pAngleRanges ); } // ----------------------------------------------------------------------- void SvxAngleTabPage::ActivatePage( const SfxItemSet& rSet ) { } // ----------------------------------------------------------------------- int SvxAngleTabPage::DeactivatePage( SfxItemSet* pSet ) { if( pSet ) FillItemSet( *pSet ); return( LEAVE_PAGE ); } //------------------------------------------------------------------------ void SvxAngleTabPage::PointChanged( Window* pWindow, RECT_POINT eRP ) { if( pWindow == &aCtlRect ) { switch( eRP ) { case RP_LT: aMtrPosX.SetUserValue( aRect.Left(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Top(), FUNIT_NONE ); break; case RP_MT: aMtrPosX.SetUserValue( aRect.Center().X(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Top(), FUNIT_NONE ); break; case RP_RT: aMtrPosX.SetUserValue( aRect.Right(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Top(), FUNIT_NONE ); break; case RP_LM: aMtrPosX.SetUserValue( aRect.Left(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Center().Y(), FUNIT_NONE ); break; case RP_MM: aMtrPosX.SetUserValue( aRect.Center().X(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Center().Y(), FUNIT_NONE ); break; case RP_RM: aMtrPosX.SetUserValue( aRect.Right(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Center().Y(), FUNIT_NONE ); break; case RP_LB: aMtrPosX.SetUserValue( aRect.Left(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Bottom(), FUNIT_NONE ); break; case RP_MB: aMtrPosX.SetUserValue( aRect.Center().X(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Bottom(), FUNIT_NONE ); break; case RP_RB: aMtrPosX.SetUserValue( aRect.Right(), FUNIT_NONE ); aMtrPosY.SetUserValue( aRect.Bottom(), FUNIT_NONE ); break; } } else if( pWindow == &aCtlAngle ) { switch( eRP ) { case RP_LT: aMtrAngle.SetUserValue( 13500, FUNIT_NONE ); break; case RP_MT: aMtrAngle.SetUserValue( 9000, FUNIT_NONE ); break; case RP_RT: aMtrAngle.SetUserValue( 4500, FUNIT_NONE ); break; case RP_LM: aMtrAngle.SetUserValue( 18000, FUNIT_NONE ); break; case RP_RM: aMtrAngle.SetUserValue( 0, FUNIT_NONE ); break; case RP_LB: aMtrAngle.SetUserValue( 22500, FUNIT_NONE ); break; case RP_MB: aMtrAngle.SetUserValue( 27000, FUNIT_NONE ); break; case RP_RB: aMtrAngle.SetUserValue( 31500, FUNIT_NONE ); break; } } } //------------------------------------------------------------------------ IMPL_LINK( SvxAngleTabPage, ModifiedHdl, void *, p ) { // Setzen des Winkels im AngleControl switch( aMtrAngle.GetValue() ) { case 13500: aCtlAngle.SetActualRP( RP_LT ); break; case 9000: aCtlAngle.SetActualRP( RP_MT ); break; case 4500: aCtlAngle.SetActualRP( RP_RT ); break; case 18000: aCtlAngle.SetActualRP( RP_LM ); break; case 0: aCtlAngle.SetActualRP( RP_RM ); break; case 22500: aCtlAngle.SetActualRP( RP_LB ); break; case 27000: aCtlAngle.SetActualRP( RP_MB ); break; case 31500: aCtlAngle.SetActualRP( RP_RB ); break; default: aCtlAngle.SetActualRP( RP_MM ); break; } return( 0L ); } /************************************************************************* |* |* Dialog zum Aendern des Eckenradius und zum Schraegstellen |* \************************************************************************/ SvxSlantTabPage::SvxSlantTabPage( Window* pParent, const SfxItemSet& rInAttrs ) : SvxTabPage ( pParent, ResId( RID_SVXPAGE_SLANT, DIALOG_MGR() ), rInAttrs ), aFlRadius ( this, ResId( FL_RADIUS ) ), aFtRadius ( this, ResId( FT_RADIUS ) ), aMtrRadius ( this, ResId( MTR_FLD_RADIUS ) ), aFlAngle ( this, ResId( FL_SLANT ) ), aFtAngle ( this, ResId( FT_ANGLE ) ), aMtrAngle ( this, ResId( MTR_FLD_ANGLE ) ), rOutAttrs ( rInAttrs ) { FreeResource(); // diese Page braucht ExchangeSupport SetExchangeSupport(); // PoolUnit ermitteln SfxItemPool* pPool = rOutAttrs.GetPool(); DBG_ASSERT( pPool, "Wo ist der Pool" ); ePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X ); } // ----------------------------------------------------------------------- void SvxSlantTabPage::Construct() { // Setzen des Rechtecks DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" ); eDlgUnit = GetModuleFieldUnit( &GetItemSet() ); SetFieldUnit( aMtrRadius, eDlgUnit, TRUE ); aRect = pView->GetAllMarkedRect(); pView->GetPageViewPvNum( 0 )->LogicToPagePos( aRect ); } //------------------------------------------------------------------------ IMPL_LINK_INLINE_START( SvxSlantTabPage, ModifiedHdl, void *, p ) { return( 0L ); } IMPL_LINK_INLINE_END( SvxSlantTabPage, ModifiedHdl, void *, p ) // ----------------------------------------------------------------------- BOOL SvxSlantTabPage::FillItemSet( SfxItemSet& rAttrs ) { BOOL bModified = FALSE; INT32 nValue = 0L; String aStr = aMtrRadius.GetText(); if( aStr != aMtrRadius.GetSavedValue() ) { Fraction aUIScale = pView->GetModel()->GetUIScale(); long nTmp = GetCoreValue( aMtrRadius, ePoolUnit ); nTmp = Fraction( nTmp ) * aUIScale; rAttrs.Put( SdrEckenradiusItem( nTmp ) ); bModified = TRUE; } aStr = aMtrAngle.GetText(); if( aStr != aMtrAngle.GetSavedValue() ) { nValue = aMtrAngle.GetValue(); rAttrs.Put( SfxInt32Item( SID_ATTR_TRANSFORM_SHEAR, nValue ) ); bModified = TRUE; } if( bModified ) { // Referenzpunkt setzen // #75897# Rectangle aObjectRect(pView->GetAllMarkedRect()); pView->GetPageViewPvNum(0)->LogicToPagePos(aObjectRect); Point aPt = aObjectRect.Center(); rAttrs.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X, aPt.X())); rAttrs.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y, aPt.Y())); // Referenzpunkt setzen // Point aPt = aRect.Center(); // rAttrs.Put( SfxInt32Item( SID_ATTR_TRANSFORM_SHEAR_X, aPt.X() ) ); // rAttrs.Put( SfxInt32Item( SID_ATTR_TRANSFORM_SHEAR_Y, aPt.Y() ) ); rAttrs.Put( SfxBoolItem( SID_ATTR_TRANSFORM_SHEAR_VERTICAL, FALSE ) ); } return( bModified ); } // ----------------------------------------------------------------------- void SvxSlantTabPage::Reset( const SfxItemSet& rAttrs ) { // Wenn die View selektierte Objekte besitzt, muessen entspr. Items, // die SFX_ITEM_DEFAULT sind, disabled werden BOOL bMarkedObj = pView->AreObjectsMarked(); const SfxPoolItem* pItem; // Eckenradius //A if( bMarkedObj && SFX_ITEM_DEFAULT == rAttrs.GetItemState( SDRATTR_ECKENRADIUS ) ) //A { if( !pView->IsEdgeRadiusAllowed() ) { aFlRadius.Disable(); aFtRadius.Disable(); aMtrRadius.Disable(); aMtrRadius.SetText( String() ); } else { pItem = GetItem( rAttrs, SDRATTR_ECKENRADIUS ); if( pItem ) { Fraction aUIScale = pView->GetModel()->GetUIScale(); long nTmp = ( (const SdrEckenradiusItem*)pItem )->GetValue(); nTmp = Fraction( nTmp ) / aUIScale; SetMetricValue( aMtrRadius, nTmp, ePoolUnit ); } else aMtrRadius.SetText( String() ); } aMtrRadius.SaveValue(); // Schraegstellen: Winkel //SfxItemState eState = rAttrs.GetItemState( SID_ATTR_TRANSFORM_SHEAR ); //if( ( bMarkedObj && SFX_ITEM_DEFAULT == eState ) || if( !pView->IsShearAllowed() ) { aFlAngle.Disable(); aFtAngle.Disable(); aMtrAngle.Disable(); aMtrAngle.SetText( String() ); } else { pItem = GetItem( rAttrs, SID_ATTR_TRANSFORM_SHEAR ); if( pItem ) aMtrAngle.SetValue( ( (const SfxInt32Item*)pItem )->GetValue() ); else aMtrAngle.SetText( String() ); } aMtrAngle.SaveValue(); ModifiedHdl( this ); } // ----------------------------------------------------------------------- SfxTabPage* SvxSlantTabPage::Create( Window* pWindow, const SfxItemSet& rOutAttrs ) { return( new SvxSlantTabPage( pWindow, rOutAttrs ) ); } //------------------------------------------------------------------------ USHORT* SvxSlantTabPage::GetRanges() { return( pSlantRanges ); } // ----------------------------------------------------------------------- void SvxSlantTabPage::ActivatePage( const SfxItemSet& rSet ) { SfxRectangleItem* pRectItem = NULL; if( SFX_ITEM_SET == rSet.GetItemState( GetWhich( SID_ATTR_TRANSFORM_INTERN ) , FALSE, (const SfxPoolItem**) &pRectItem ) ) { aRect = pRectItem->GetValue(); } } // ----------------------------------------------------------------------- int SvxSlantTabPage::DeactivatePage( SfxItemSet* pSet ) { if( pSet ) FillItemSet( *pSet ); return( LEAVE_PAGE ); } //------------------------------------------------------------------------ void SvxSlantTabPage::PointChanged( Window* pWindow, RECT_POINT eRP ) { } /************************************************************************* |* |* Dialog for changing position and size of graphic objects |* \************************************************************************/ SvxPositionSizeTabPage::SvxPositionSizeTabPage( Window* pParent, const SfxItemSet& rInAttrs ) : SvxTabPage ( pParent, ResId( RID_SVXPAGE_POSITION_SIZE, DIALOG_MGR() ), rInAttrs ), maFlPosition ( this, ResId( FL_POSITION ) ), maFtPosX ( this, ResId( FT_POS_X ) ), maMtrPosX ( this, ResId( MTR_FLD_POS_X ) ), maFtPosY ( this, ResId( FT_POS_Y ) ), maMtrPosY ( this, ResId( MTR_FLD_POS_Y ) ), maFlProtect ( this, ResId( FL_PROTECT) ), maTsbPosProtect ( this, ResId( TSB_POSPROTECT ) ), maFtPosReference ( this, ResId( FT_POSREFERENCE ) ), maCtlPos ( this, ResId( CTL_POSRECT ), RP_LT ), // maAnchorBox ( this, ResId( FL_ANCHOR ) ), // maFtAnchor ( this, ResId( FT_ANCHOR ) ), // maDdLbAnchor ( this, ResId( LB_ANCHOR ) ), // maFtOrient ( this, ResId( FT_ORIENT ) ), // maDdLbOrient ( this, ResId( LB_ORIENT ) ), mbPageDisabled ( FALSE ), maFlSize ( this, ResId( FL_SIZE ) ), maFtWidth ( this, ResId( FT_WIDTH ) ), maMtrWidth ( this, ResId( MTR_FLD_WIDTH ) ), maFtHeight ( this, ResId( FT_HEIGHT ) ), maMtrHeight ( this, ResId( MTR_FLD_HEIGHT ) ), maCbxScale ( this, ResId( CBX_SCALE ) ), maTsbSizeProtect ( this, ResId( TSB_SIZEPROTECT ) ), maFtSizeReference ( this, ResId( FT_SIZEREFERENCE) ), maCtlSize ( this, ResId( CTL_SIZERECT ), RP_LT ), maFlAdjust ( this, ResId( FL_ADJUST ) ), maTsbAutoGrowWidth ( this, ResId( TSB_AUTOGROW_WIDTH ) ), maTsbAutoGrowHeight ( this, ResId( TSB_AUTOGROW_HEIGHT ) ), maFlDivider (this, ResId( FL_DIVIDER ) ), mnProtectSizeState( STATE_NOCHECK ), mbProtectDisabled( false ), mbSizeDisabled( false ), mrOutAttrs ( rInAttrs ) { FreeResource(); // diese Page braucht ExchangeSupport SetExchangeSupport(); // PoolUnit ermitteln SfxItemPool* pPool = mrOutAttrs.GetPool(); DBG_ASSERT( pPool, "Wo ist der Pool" ); mePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X ); // maDdLbAnchor.SetSelectHdl( LINK( this, SvxPositionSizeTabPage, SetAnchorHdl ) ); // maDdLbOrient.SetSelectHdl( LINK( this, SvxPositionSizeTabPage, SetOrientHdl ) ); meRP = RP_LT; // s.o. maMtrWidth.SetModifyHdl( LINK( this, SvxPositionSizeTabPage, ChangeWidthHdl ) ); maMtrHeight.SetModifyHdl( LINK( this, SvxPositionSizeTabPage, ChangeHeightHdl ) ); maCbxScale.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickAutoHdl ) ); maTsbAutoGrowWidth.Disable(); maTsbAutoGrowHeight.Disable(); maFlAdjust.Disable(); // #i2379# disable controls when protected maTsbPosProtect.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ChangePosProtectHdl ) ); maTsbSizeProtect.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ChangeSizeProtectHdl ) ); } // ----------------------------------------------------------------------- void SvxPositionSizeTabPage::Construct() { // Setzen des Rechtecks und der Workingarea DBG_ASSERT( mpView, "Keine gueltige View Uebergeben!" ); meDlgUnit = GetModuleFieldUnit( &GetItemSet() ); SetFieldUnit( maMtrPosX, meDlgUnit, TRUE ); SetFieldUnit( maMtrPosY, meDlgUnit, TRUE ); SetFieldUnit( maMtrWidth, meDlgUnit, TRUE ); SetFieldUnit( maMtrHeight, meDlgUnit, TRUE ); if( meDlgUnit == FUNIT_MILE || meDlgUnit == FUNIT_KM ) { maMtrPosX.SetDecimalDigits( 3 ); maMtrPosY.SetDecimalDigits( 3 ); maMtrWidth.SetDecimalDigits( 3 ); maMtrHeight.SetDecimalDigits( 3 ); } maRect = mpView->GetAllMarkedRect(); mpView->GetPageViewPvNum( 0 )->LogicToPagePos( maRect ); // WorkArea holen und umrechnen: maWorkArea = mpView->GetWorkArea(); // Beruecksichtigung Ankerposition (bei Writer) const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); if( rMarkList.GetMarkCount() >= 1 ) { const SdrObject* pObj = rMarkList.GetMark( 0 )->GetObj(); maAnchorPos = pObj->GetAnchorPos(); if( maAnchorPos != Point(0,0) ) // -> Writer { for( USHORT i = 1; i < rMarkList.GetMarkCount(); i++ ) { pObj = rMarkList.GetMark( i )->GetObj(); if( maAnchorPos != pObj->GetAnchorPos() ) { // Unterschiedliche Ankerpositionen maFtPosX.Disable(); maMtrPosX.Disable(); maMtrPosX.SetText( String() ); maFtPosY.Disable(); maMtrPosY.Disable(); maMtrPosY.SetText( String() ); maFlPosition.Disable(); maFtPosReference.Disable(); maCtlPos.Disable(); maTsbPosProtect.Disable(); mbPageDisabled = TRUE; return; } } } Point aPt = maAnchorPos * -1; Point aPt2 = aPt; aPt += maWorkArea.TopLeft(); maWorkArea.SetPos( aPt ); aPt2 += maRect.TopLeft(); maRect.SetPos( aPt2 ); } // this should happen via SID_ATTR_TRANSFORM_AUTOSIZE if( rMarkList.GetMarkCount() == 1 ) { const SdrObject* pObj = rMarkList.GetMark( 0 )->GetObj(); SdrObjKind eKind = (SdrObjKind) pObj->GetObjIdentifier(); if( ( pObj->GetObjInventor() == SdrInventor ) && ( eKind==OBJ_TEXT || eKind==OBJ_TITLETEXT || eKind==OBJ_OUTLINETEXT) && ( (SdrTextObj*) pObj )->HasText() ) { maFlAdjust.Enable(); maTsbAutoGrowWidth.Enable(); maTsbAutoGrowHeight.Enable(); maTsbAutoGrowWidth.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) ); maTsbAutoGrowHeight.SetClickHdl( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) ); // Wird als Flag benutzt, um zu ermitteln, ob anwaehlbar ist maTsbAutoGrowWidth.EnableTriState( FALSE ); maTsbAutoGrowHeight.EnableTriState( FALSE ); } } // use page offset and recalculate Point aPt( mpView->GetPageViewPvNum( 0 )->GetPageOrigin() ); // Massstab Fraction aUIScale = mpView->GetModel()->GetUIScale(); lcl_ScaleRect( maWorkArea, aUIScale ); lcl_ScaleRect( maRect, aUIScale ); lcl_ScalePoint( aPt, aUIScale ); // Metrik konvertieren int nDigits = maMtrPosX.GetDecimalDigits(); aPt = lcl_ConvertPoint( aPt, nDigits, (MapUnit) mePoolUnit, meDlgUnit ); maWorkArea = lcl_ConvertRect( maWorkArea, nDigits, (MapUnit) mePoolUnit, meDlgUnit ); maRect = lcl_ConvertRect( maRect, nDigits, (MapUnit) mePoolUnit, meDlgUnit ); // use page offset aPt *= -1; aPt += maWorkArea.TopLeft(); maWorkArea.SetPos( aPt ); SetMinMaxPosition(); } // ----------------------------------------------------------------------- BOOL SvxPositionSizeTabPage::FillItemSet( SfxItemSet& rOutAttrs ) { if ( maMtrWidth.HasFocus() ) ChangeWidthHdl( this ); if ( maMtrHeight.HasFocus() ) ChangeHeightHdl( this ); BOOL bModified = FALSE; if( !mbPageDisabled ) { if ( maMtrPosX.IsValueModified() || maMtrPosY.IsValueModified() ) { long lX = GetCoreValue( maMtrPosX, mePoolUnit ); long lY = GetCoreValue( maMtrPosY, mePoolUnit ); // Altes Rechteck mit CoreUnit maRect = mpView->GetAllMarkedRect(); mpView->GetPageViewPvNum( 0 )->LogicToPagePos( maRect ); Fraction aUIScale = mpView->GetModel()->GetUIScale(); lX += maAnchorPos.X(); lX = Fraction( lX ) * aUIScale; lY += maAnchorPos.Y(); lY = Fraction( lY ) * aUIScale; // #101581# GetTopLeftPosition(...) needs coordinates // after UI scaling, in real PagePositions. GetTopLeftPosition( lX, lY, maRect ); rOutAttrs.Put( SfxInt32Item( GetWhich( SID_ATTR_TRANSFORM_POS_X ), (INT32) lX ) ); rOutAttrs.Put( SfxInt32Item( GetWhich( SID_ATTR_TRANSFORM_POS_Y ), (INT32) lY ) ); bModified |= TRUE; } if ( maTsbPosProtect.GetState() != maTsbPosProtect.GetSavedValue() ) { if( maTsbPosProtect.GetState() == STATE_DONTKNOW ) rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_POS ); else rOutAttrs.Put( SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_PROTECT_POS ), maTsbPosProtect.GetState() == STATE_CHECK ? TRUE : FALSE ) ); bModified |= TRUE; } /* if(maAnchorBox.IsVisible()) //nur fuer den Writer { if(maDdLbAnchor.GetSavedValue() != maDdLbAnchor.GetSelectEntryPos()) { bModified |= TRUE; rOutAttrs.Put(SfxUInt16Item( SID_ATTR_TRANSFORM_ANCHOR, (USHORT)(ULONG)maDdLbAnchor.GetEntryData(maDdLbAnchor.GetSelectEntryPos()))); } if(maDdLbOrient.GetSavedValue() != maDdLbOrient.GetSelectEntryPos()) { bModified |= TRUE; rOutAttrs.Put(SfxUInt16Item( SID_ATTR_TRANSFORM_VERT_ORIENT, maDdLbOrient.GetSelectEntryPos())); } } */ } if ( maMtrWidth.IsValueModified() || maMtrHeight.IsValueModified() ) { Fraction aUIScale = mpView->GetModel()->GetUIScale(); // get Width double nWidth = maMtrWidth.GetValue( meDlgUnit ); nWidth = MetricField::ConvertDoubleValue( nWidth, maMtrWidth.GetBaseValue(), maMtrWidth.GetDecimalDigits(), meDlgUnit, FUNIT_100TH_MM ); long lWidth = nWidth * (double)aUIScale; lWidth = OutputDevice::LogicToLogic( lWidth, MAP_100TH_MM, (MapUnit)mePoolUnit ); lWidth = maMtrWidth.Denormalize( lWidth ); // get Height double nHeight = maMtrHeight.GetValue( meDlgUnit ); nHeight = MetricField::ConvertDoubleValue( nHeight, maMtrHeight.GetBaseValue(), maMtrHeight.GetDecimalDigits(), meDlgUnit, FUNIT_100TH_MM ); long lHeight = nHeight * (double)aUIScale; lHeight = OutputDevice::LogicToLogic( lHeight, MAP_100TH_MM, (MapUnit)mePoolUnit ); lHeight = maMtrWidth.Denormalize( lHeight ); // put Width & Height to itemset rOutAttrs.Put( SfxUInt32Item( GetWhich( SID_ATTR_TRANSFORM_WIDTH ), (UINT32) lWidth ) ); rOutAttrs.Put( SfxUInt32Item( GetWhich( SID_ATTR_TRANSFORM_HEIGHT ), (UINT32) lHeight ) ); rOutAttrs.Put( SfxAllEnumItem( GetWhich( SID_ATTR_TRANSFORM_SIZE_POINT ), meRP ) ); bModified |= TRUE; } if ( maTsbSizeProtect.GetState() != maTsbSizeProtect.GetSavedValue() ) { if ( maTsbSizeProtect.GetState() == STATE_DONTKNOW ) rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_SIZE ); else rOutAttrs.Put( SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_PROTECT_SIZE ), maTsbSizeProtect.GetState() == STATE_CHECK ? TRUE : FALSE ) ); bModified |= TRUE; } if ( maTsbAutoGrowWidth.GetState() != maTsbAutoGrowWidth.GetSavedValue() ) { if ( !maTsbAutoGrowWidth.IsTriStateEnabled() ) { if( maTsbAutoGrowWidth.GetState() == STATE_DONTKNOW ) rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_AUTOWIDTH ); else rOutAttrs.Put( SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_AUTOWIDTH ), maTsbAutoGrowWidth.GetState() == STATE_CHECK ? TRUE : FALSE ) ); } bModified |= TRUE; } if ( maTsbAutoGrowHeight.GetState() != maTsbAutoGrowHeight.GetSavedValue() ) { if ( !maTsbAutoGrowHeight.IsTriStateEnabled() ) { if( maTsbAutoGrowHeight.GetState() == STATE_DONTKNOW ) rOutAttrs.InvalidateItem( SID_ATTR_TRANSFORM_AUTOHEIGHT ); else rOutAttrs.Put( SfxBoolItem( GetWhich( SID_ATTR_TRANSFORM_AUTOHEIGHT ), maTsbAutoGrowHeight.GetState() == STATE_CHECK ? TRUE : FALSE ) ); } bModified |= TRUE; } return bModified; } // ----------------------------------------------------------------------- void SvxPositionSizeTabPage::Reset( const SfxItemSet& rOutAttrs ) { const SfxPoolItem* pItem; if ( !mbPageDisabled ) { pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_X ); Fraction aUIScale = mpView->GetModel()->GetUIScale(); if ( pItem ) { long nTmp = ( (const SfxInt32Item*)pItem )->GetValue() - maAnchorPos.X(); nTmp = Fraction( nTmp ) / aUIScale; SetMetricValue( maMtrPosX, nTmp, mePoolUnit ); } pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_Y ); if ( pItem ) { long nTmp = ( (const SfxInt32Item*)pItem )->GetValue() - maAnchorPos.Y(); nTmp = Fraction( nTmp ) / aUIScale; SetMetricValue( maMtrPosY, nTmp, mePoolUnit ); } pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_PROTECT_POS ); if ( pItem ) { sal_Bool bProtected = ( ( const SfxBoolItem* )pItem )->GetValue(); maTsbPosProtect.SetState( bProtected ? STATE_CHECK : STATE_NOCHECK ); maTsbPosProtect.EnableTriState( FALSE ); maTsbSizeProtect.Enable( !mbProtectDisabled & !bProtected ); } else { maTsbPosProtect.SetState( STATE_DONTKNOW ); maTsbSizeProtect.Enable( !mbProtectDisabled ); } maTsbPosProtect.SaveValue(); maCtlPos.Reset(); // #i2379# Disable controls for protected objects ChangePosProtectHdl( this ); /* if(maAnchorBox.IsVisible()) //nur fuer den Writer { pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_ANCHOR ); USHORT nAnchorPos = 0; if(pItem) { nAnchorPos = ((const SfxUInt16Item*)pItem)->GetValue(); for (USHORT i = 0; i < maDdLbAnchor.GetEntryCount(); i++) { if ((ULONG)maDdLbAnchor.GetEntryData(i) == (ULONG)nAnchorPos) { maDdLbAnchor.SelectEntryPos(i); break; } } maDdLbAnchor.SaveValue(); SetAnchorHdl(&maDdLbAnchor); } if(nAnchorPos == (USHORT)SVX_FLY_IN_CNTNT) { maCtlPos.Disable(); pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_VERT_ORIENT ); if(pItem) { maDdLbOrient.SelectEntryPos(((const SfxUInt16Item*)pItem)->GetValue()); } } else { maDdLbOrient.SelectEntryPos( (USHORT)SVX_VERT_LINE_CENTER ); } maDdLbOrient.SaveValue(); SetOrientHdl(&maDdLbOrient); maCtlPos.Invalidate(); } */ } pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_WIDTH ); mlOldWidth = Max( pItem ? ( (const SfxUInt32Item*)pItem )->GetValue() : 0, (UINT32)1 ); pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_HEIGHT ); mlOldHeight = Max( pItem ? ( (const SfxUInt32Item*)pItem )->GetValue() : 0, (UINT32)1 ); Fraction aUIScale = mpView->GetModel()->GetUIScale(); // set Width & Height double nTmpWidth = (double)OutputDevice::LogicToLogic( mlOldWidth, (MapUnit)mePoolUnit, MAP_100TH_MM ); double nTmpHeight = (double)OutputDevice::LogicToLogic( mlOldHeight, (MapUnit)mePoolUnit, MAP_100TH_MM ); nTmpWidth = Fraction( nTmpWidth ) / aUIScale; nTmpHeight = Fraction( nTmpHeight ) / aUIScale; UINT32 nNorm = 10; int i; for( i = 0; i < maMtrWidth.GetDecimalDigits()-1; i++ ) nNorm*=10; nTmpWidth*=(double)nNorm; nNorm = 10; for( i=0; iGetValue() ? STATE_CHECK : STATE_NOCHECK ); maTsbSizeProtect.EnableTriState( FALSE ); } else maTsbSizeProtect.SetState( STATE_DONTKNOW ); pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOWIDTH ); if ( pItem ) { maTsbAutoGrowWidth.SetState( ( ( const SfxBoolItem* )pItem )->GetValue() ? STATE_CHECK : STATE_NOCHECK ); } else maTsbAutoGrowWidth.SetState( STATE_DONTKNOW ); pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOHEIGHT ); if ( pItem ) { maTsbAutoGrowHeight.SetState( ( ( const SfxBoolItem* )pItem )->GetValue() ? STATE_CHECK : STATE_NOCHECK ); } else maTsbAutoGrowHeight.SetState( STATE_DONTKNOW ); // Ist Abgleich gesetzt? String aStr = GetUserData(); maCbxScale.Check( (BOOL)aStr.ToInt32() ); maTsbSizeProtect.SaveValue(); maTsbAutoGrowWidth.SaveValue(); maTsbAutoGrowHeight.SaveValue(); ClickSizeProtectHdl( NULL ); // #i2379# Disable controls for protected objects ChangeSizeProtectHdl( this ); } // ----------------------------------------------------------------------- SfxTabPage* SvxPositionSizeTabPage::Create( Window* pWindow, const SfxItemSet& rOutAttrs ) { return( new SvxPositionSizeTabPage( pWindow, rOutAttrs ) ); } //------------------------------------------------------------------------ USHORT* SvxPositionSizeTabPage::GetRanges() { return( pPosSizeRanges ); } // ----------------------------------------------------------------------- void SvxPositionSizeTabPage::ActivatePage( const SfxItemSet& rSet ) { SfxRectangleItem* pRectItem = NULL; if( SFX_ITEM_SET == rSet.GetItemState( GetWhich( SID_ATTR_TRANSFORM_INTERN ) , FALSE, (const SfxPoolItem**) &pRectItem ) ) { // Setzen der MinMax-Position maRect = pRectItem->GetValue(); SetMinMaxPosition(); } } // ----------------------------------------------------------------------- int SvxPositionSizeTabPage::DeactivatePage( SfxItemSet* pSet ) { if( pSet ) { INT32 lX = maMtrPosX.GetValue(); INT32 lY = maMtrPosY.GetValue(); // #106330# // The below BugFix assumed that GetTopLeftPosition() // needs special coordinate systems. This is not true, // GetTopLeftPosition() just needs all parameters in one // coor system. Thus, this part below is not necessary and // leads to this new bug. Thus, i remove it again. // I checked that #106330# works and #101581# is fixed, too. // // // #101581# GetTopLeftPosition(...) needs coordinates // // after UI scaling, in real PagePositions. Thus I added // // that calculation here // Fraction aUIScale = mpView->GetModel()->GetUIScale(); // lX += maAnchorPos.X(); // lX = Fraction( lX ) * aUIScale; // lY += maAnchorPos.Y(); // lY = Fraction( lY ) * aUIScale; GetTopLeftPosition( lX, lY, maRect ); maRect.SetPos( Point( lX, lY ) ); pSet->Put( SfxRectangleItem( SID_ATTR_TRANSFORM_INTERN, maRect ) ); FillItemSet( *pSet ); } return( LEAVE_PAGE ); } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ChangePosProtectHdl, void *, p ) { maTsbSizeProtect.Enable( !mbProtectDisabled & (maTsbPosProtect.GetState() != STATE_CHECK) ); // #106572# Remember user's last choice maTsbSizeProtect.SetState( maTsbPosProtect.GetState() == STATE_CHECK ? STATE_CHECK : mnProtectSizeState ); DisableSizeControls(); if( maTsbPosProtect.GetState() == STATE_CHECK ) { maFlPosition.Disable(); maFtPosX.Disable(); maMtrPosX.Disable(); maFtPosY.Disable(); maMtrPosY.Disable(); maFtPosReference.Disable(); maCtlPos.Disable(); maCtlPos.Invalidate(); } else { maFlPosition.Enable(); maFtPosX.Enable(); maMtrPosX.Enable(); maFtPosY.Enable(); maMtrPosY.Enable(); maFtPosReference.Enable(); maCtlPos.Enable(); maCtlPos.Invalidate(); } return( 0L ); } //------------------------------------------------------------------------ void SvxPositionSizeTabPage::DisableSizeControls() { if( maTsbSizeProtect.GetState() == STATE_CHECK ) { maFlSize.Disable(); maFtWidth.Disable(); maMtrWidth.Disable(); maFtHeight.Disable(); maMtrHeight.Disable(); maCbxScale.Disable(); maFtSizeReference.Disable(); maCtlSize.Disable(); maCtlSize.Invalidate(); } else { maFlSize.Enable(); maFtWidth.Enable(); maMtrWidth.Enable(); maFtHeight.Enable(); maMtrHeight.Enable(); maCbxScale.Enable(); maFtSizeReference.Enable(); maCtlSize.Enable(); maCtlSize.Invalidate(); } } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ChangeSizeProtectHdl, void *, p ) { if( maTsbSizeProtect.IsEnabled() ) { // #106572# Remember user's last choice // Note: this works only as long as the dialog is open. When // the user closes the dialog, there is no way to remember // whether size was enabled or disabled befor pos protect was // clicked. Thus, if pos protect is selected, the dialog is // closed and reopened again, unchecking pos protect will // always uncheck size protect, too. That's life. mnProtectSizeState = maTsbSizeProtect.GetState(); } DisableSizeControls(); return( 0L ); } //------------------------------------------------------------------------ IMPL_LINK_INLINE_START( SvxPositionSizeTabPage, ChangePosXHdl, void *, EMPTYARG ) { return( 0L ); } IMPL_LINK_INLINE_END( SvxPositionSizeTabPage, ChangePosXHdl, void *, EMPTYARG ) //------------------------------------------------------------------------ IMPL_LINK_INLINE_START( SvxPositionSizeTabPage, ChangePosYHdl, void *, EMPTYARG ) { return( 0L ); } IMPL_LINK_INLINE_END( SvxPositionSizeTabPage, ChangePosYHdl, void *, EMPTYARG ) //------------------------------------------------------------------------ void SvxPositionSizeTabPage::SetMinMaxPosition() { // position Rectangle aTmpRect = maWorkArea; switch ( maCtlPos.GetActualRP() ) { case RP_LT: aTmpRect.Right() -= maRect.Right() - maRect.Left(); aTmpRect.Bottom() -= maRect.Bottom() - maRect.Top(); break; case RP_MT: aTmpRect.Left() += maRect.Center().X() - maRect.Left(); aTmpRect.Right() -= maRect.Center().X() - maRect.Left(); aTmpRect.Bottom() -= maRect.Bottom() - maRect.Top(); break; case RP_RT: aTmpRect.Left() += maRect.Right() - maRect.Left(); aTmpRect.Bottom() -= maRect.Bottom() - maRect.Top(); break; case RP_LM: aTmpRect.Right() -= maRect.Right() - maRect.Left(); aTmpRect.Top() += maRect.Center().Y() - maRect.Top(); aTmpRect.Bottom() -= maRect.Center().Y() - maRect.Top(); break; case RP_MM: aTmpRect.Left() += maRect.Center().X() - maRect.Left(); aTmpRect.Right() -= maRect.Center().X() - maRect.Left(); aTmpRect.Top() += maRect.Center().Y() - maRect.Top(); aTmpRect.Bottom() -= maRect.Center().Y() - maRect.Top(); break; case RP_RM: aTmpRect.Left() += maRect.Right() - maRect.Left(); aTmpRect.Top() += maRect.Center().Y() - maRect.Top(); aTmpRect.Bottom() -= maRect.Center().Y() - maRect.Top(); break; case RP_LB: aTmpRect.Right() -= maRect.Right() - maRect.Left(); aTmpRect.Top() += maRect.Bottom() - maRect.Top(); break; case RP_MB: aTmpRect.Left() += maRect.Center().X() - maRect.Left(); aTmpRect.Right() -= maRect.Center().X() - maRect.Left(); aTmpRect.Top() += maRect.Bottom() - maRect.Top(); break; case RP_RB: aTmpRect.Left() += maRect.Right() - maRect.Left(); aTmpRect.Top() += maRect.Bottom() - maRect.Top(); break; } long nMaxLong = MetricField::ConvertValue( LONG_MAX, 0, MAP_100TH_MM, meDlgUnit ) - 1L; if( Abs( aTmpRect.Left() ) > nMaxLong ) { long nMult = aTmpRect.Left() < 0 ? -1 : 1; aTmpRect.Left() = nMaxLong * nMult; } if( Abs( aTmpRect.Right() ) > nMaxLong ) { long nMult = aTmpRect.Right() < 0 ? -1 : 1; aTmpRect.Right() = nMaxLong * nMult; } if( Abs( aTmpRect.Top() ) > nMaxLong ) { long nMult = aTmpRect.Top() < 0 ? -1 : 1; aTmpRect.Top() = nMaxLong * nMult; } if( Abs( aTmpRect.Bottom() ) > nMaxLong ) { long nMult = aTmpRect.Bottom() < 0 ? -1 : 1; aTmpRect.Bottom() = nMaxLong * nMult; } maMtrPosX.SetMin( aTmpRect.Left() ); maMtrPosX.SetFirst( aTmpRect.Left() ); maMtrPosX.SetMax( aTmpRect.Right() ); maMtrPosX.SetLast( aTmpRect.Right() ); maMtrPosY.SetMin( aTmpRect.Top() ); maMtrPosY.SetFirst( aTmpRect.Top() ); maMtrPosY.SetMax( aTmpRect.Bottom() ); maMtrPosY.SetLast( aTmpRect.Bottom() ); // size aTmpRect = maWorkArea; switch ( maCtlSize.GetActualRP() ) { case RP_LT: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( maRect.Left() - aTmpRect.Left() ), aTmpRect.GetHeight() - ( maRect.Top() - aTmpRect.Top() ) ) ); break; case RP_MT: aTmpRect.SetSize( Size( Min( maRect.Center().X() - aTmpRect.Left(), aTmpRect.Right() - maRect.Center().X() ) * 2, aTmpRect.GetHeight() - ( maRect.Top() - aTmpRect.Top() ) ) ); break; case RP_RT: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( aTmpRect.Right() - maRect.Right() ), aTmpRect.GetHeight() - ( maRect.Top() - aTmpRect.Top() ) ) ); break; case RP_LM: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( maRect.Left() - aTmpRect.Left() ), Min( maRect.Center().Y() - aTmpRect.Top(), aTmpRect.Bottom() - maRect.Center().Y() ) * 2 ) ); break; case RP_MM: { long n1, n2, n3, n4, n5, n6; n1 = maRect.Center().X() - aTmpRect.Left(); n2 = aTmpRect.Right() - maRect.Center().X(); n3 = Min( n1, n2 ); n4 = maRect.Center().Y() - aTmpRect.Top(); n5 = aTmpRect.Bottom() - maRect.Center().Y(); n6 = Min( n4, n5 ); aTmpRect.SetSize( Size( n3 * 2, n6 * 3 ) ); break; } case RP_RM: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( aTmpRect.Right() - maRect.Right() ), Min( maRect.Center().Y() - aTmpRect.Top(), aTmpRect.Bottom() - maRect.Center().Y() ) * 2 ) ); break; case RP_LB: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( maRect.Left() - aTmpRect.Left() ), aTmpRect.GetHeight() - ( aTmpRect.Bottom() - maRect.Bottom() ) ) ); break; case RP_MB: aTmpRect.SetSize( Size( Min( maRect.Center().X() - aTmpRect.Left(), aTmpRect.Right() - maRect.Center().X() ) * 2, aTmpRect.GetHeight() - ( maRect.Bottom() - aTmpRect.Bottom() ) ) ); break; case RP_RB: aTmpRect.SetSize( Size( aTmpRect.GetWidth() - ( aTmpRect.Right() - maRect.Right() ), aTmpRect.GetHeight() - ( aTmpRect.Bottom() - maRect.Bottom() ) ) ); break; } maMtrWidth.SetMax( aTmpRect.GetWidth() ); maMtrWidth.SetLast( aTmpRect.GetWidth() ); maMtrHeight.SetMax( aTmpRect.GetHeight() ); maMtrHeight.SetLast( aTmpRect.GetHeight() ); } //------------------------------------------------------------------------ void SvxPositionSizeTabPage::GetTopLeftPosition( INT32& rX, INT32& rY, const Rectangle& rRect ) { switch ( maCtlPos.GetActualRP() ) { case RP_LT: break; case RP_MT: rX = rX- ( rRect.Center().X() - rRect.Left() ); break; case RP_RT: rX = rX- ( rRect.Right() - rRect.Left() ); break; case RP_LM: rY = rY- ( rRect.Center().Y() - rRect.Top() ); break; case RP_MM: rX = rX- ( rRect.Center().X() - rRect.Left() ); rY = rY- ( rRect.Center().Y() - rRect.Top() ); break; case RP_RM: rX = rX- ( rRect.Right() - rRect.Left() ); rY = rY- ( rRect.Center().Y() - rRect.Top() ); break; case RP_LB: rY = rY- ( rRect.Bottom() - rRect.Top() ); break; case RP_MB: rX = rX- ( rRect.Center().X() - rRect.Left() ); rY = rY- ( rRect.Bottom() - rRect.Top() ); break; case RP_RB: rX = rX- ( rRect.Right() - rRect.Left() ); rY = rY- ( rRect.Bottom() - rRect.Top() ); break; } } //------------------------------------------------------------------------ void SvxPositionSizeTabPage::PointChanged( Window* pWindow, RECT_POINT eRP ) { if( pWindow == &maCtlPos ) { SetMinMaxPosition(); switch( eRP ) { case RP_LT: maMtrPosX.SetValue( maRect.Left() ); maMtrPosY.SetValue( maRect.Top() ); break; case RP_MT: maMtrPosX.SetValue( maRect.Center().X() ); maMtrPosY.SetValue( maRect.Top() ); break; case RP_RT: maMtrPosX.SetValue( maRect.Right() ); maMtrPosY.SetValue( maRect.Top() ); break; case RP_LM: maMtrPosX.SetValue( maRect.Left() ); maMtrPosY.SetValue( maRect.Center().Y() ); break; case RP_MM: maMtrPosX.SetValue( maRect.Center().X() ); maMtrPosY.SetValue( maRect.Center().Y() ); break; case RP_RM: maMtrPosX.SetValue( maRect.Right() ); maMtrPosY.SetValue( maRect.Center().Y() ); break; case RP_LB: maMtrPosX.SetValue( maRect.Left() ); maMtrPosY.SetValue( maRect.Bottom() ); break; case RP_MB: maMtrPosX.SetValue( maRect.Center().X() ); maMtrPosY.SetValue( maRect.Bottom() ); break; case RP_RB: maMtrPosX.SetValue( maRect.Right() ); maMtrPosY.SetValue( maRect.Bottom() ); break; } } else { meRP = eRP; Rectangle aTmpRect( GetRect() ); SetMinMaxPosition(); } } //------------------------------------------------------------------------ /*void SvxPositionSizeTabPage::ShowAnchorCtrls(USHORT nAnchorCtrls) { maTsbAutoGrowWidth.Hide(); maTsbAutoGrowHeight.Hide(); maFlAdjust.Hide(); maAnchorBox .Show(); maFtAnchor .Show(); maFtOrient .Show(); maDdLbOrient .Show(); for (USHORT i = 0; i < maDdLbAnchor.GetEntryCount(); i++) maDdLbAnchor.SetEntryData(i, (void *)(long)i); if (!(nAnchorCtrls & SVX_OBJ_AT_FLY)) maDdLbAnchor.RemoveEntry(3); if (!(nAnchorCtrls & SVX_OBJ_PAGE)) maDdLbAnchor.RemoveEntry(2); if (!(nAnchorCtrls & SVX_OBJ_IN_CNTNT)) maDdLbAnchor.RemoveEntry(1); if (!(nAnchorCtrls & SVX_OBJ_AT_CNTNT)) maDdLbAnchor.RemoveEntry(0); maDdLbAnchor .Show(); };*/ //------------------------------------------------------------------------ void SvxPositionSizeTabPage::DisableResize() { maFlSize.Disable(); maFtWidth.Disable(); maMtrWidth.Disable(); maFtHeight.Disable(); maMtrHeight.Disable(); maCbxScale.Disable(); maFtSizeReference.Disable(); maCtlSize.Disable(); mbSizeDisabled = true; } //------------------------------------------------------------------------ void SvxPositionSizeTabPage::DisableProtect() { maFlProtect.Disable(); maTsbPosProtect.Disable(); maTsbSizeProtect.Disable(); mbProtectDisabled = true; } //------------------------------------------------------------------------ /*IMPL_LINK( SvxPositionSizeTabPage, SetAnchorHdl, ListBox *, pBox) { BOOL bDisable = TRUE; switch( (ULONG)pBox->GetEntryData(pBox->GetSelectEntryPos()) ) { case SVX_FLY_AT_CNTNT: case SVX_FLY_PAGE: break; case SVX_FLY_IN_CNTNT: bDisable = FALSE; break; } maCtlPos.Enable(bDisable); maCtlPos.Invalidate(); if(bDisable) { maDdLbOrient.Disable(); maFtOrient.Disable(); maMtrPosX.Enable(); maMtrPosY.Enable(); } else { maMtrPosX.Disable(); maDdLbOrient.Enable(); maFtOrient.Enable(); SetOrientHdl(&maDdLbOrient); } return 0; } */ //------------------------------------------------------------------------ /*IMPL_LINK( SvxPositionSizeTabPage, SetOrientHdl, ListBox *, pBox ) { if(pBox->IsEnabled()) switch( pBox->GetSelectEntryPos() ) { case SVX_VERT_TOP :  case SVX_VERT_CENTER : case SVX_VERT_BOTTOM : case SVX_VERT_LINE_TOP : case SVX_VERT_LINE_CENTER : case SVX_VERT_LINE_BOTTOM : maMtrPosY.Disable(); break; case SVX_VERT_NONE: maMtrPosY.Enable(); break; } return 0; }*/ Rectangle SvxPositionSizeTabPage::GetRect() { Rectangle aTmpRect( maRect ); aTmpRect.SetSize( Size( maMtrWidth.GetValue(), maMtrHeight.GetValue() ) ); switch ( maCtlSize.GetActualRP() ) { case RP_LT: // nichts! break; case RP_MT: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ) / 2, maRect.Top() ) ); break; case RP_RT: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ), maRect.Top() ) ); break; case RP_LM: aTmpRect.SetPos( Point( maRect.Left(), maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) / 2 ) ); break; case RP_MM: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ) / 2, maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) / 2 ) ); break; case RP_RM: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ), maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) / 2 ) ); break; case RP_LB: aTmpRect.SetPos( Point( maRect.Left(), maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) ) ); break; case RP_MB: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ) / 2, maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) ) ); break; case RP_RB: aTmpRect.SetPos( Point( maRect.Left() - ( aTmpRect.Right() - maRect.Right() ), maRect.Top() - ( aTmpRect.Bottom() - maRect.Bottom() ) ) ); break; } return( aTmpRect ); } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ChangeWidthHdl, void *, EMPTYARG ) { if( maCbxScale.IsChecked() && maCbxScale.IsEnabled() ) { long nHeight = (long) ( ((double) mlOldHeight * (double) maMtrWidth.GetValue()) / (double) mlOldWidth ); if( nHeight <= maMtrHeight.GetMax( FUNIT_NONE ) ) { maMtrHeight.SetUserValue( nHeight, FUNIT_NONE ); } else { nHeight = maMtrHeight.GetMax( FUNIT_NONE ); maMtrHeight.SetUserValue( nHeight ); const long nWidth = (long) ( ((double) mlOldWidth * (double) nHeight) / (double) mlOldHeight ); maMtrWidth.SetUserValue( nWidth, FUNIT_NONE ); } } return( 0L ); } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ChangeHeightHdl, void *, EMPTYARG ) { if( maCbxScale.IsChecked() && maCbxScale.IsEnabled() ) { long nWidth = (long) ( ((double) mlOldWidth * (double) maMtrHeight.GetValue()) / (double) mlOldHeight ); if( nWidth <= maMtrWidth.GetMax( FUNIT_NONE ) ) { maMtrWidth.SetUserValue( nWidth, FUNIT_NONE ); } else { nWidth = maMtrWidth.GetMax( FUNIT_NONE ); maMtrWidth.SetUserValue( nWidth ); const long nHeight = (long) ( ((double) mlOldHeight * (double) nWidth) / (double) mlOldWidth ); maMtrHeight.SetUserValue( nHeight, FUNIT_NONE ); } } return( 0L ); } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ClickSizeProtectHdl, void *, p ) { if( !mbSizeDisabled ) { BOOL bHeightChecked = !maTsbAutoGrowHeight.IsTriStateEnabled() && maTsbAutoGrowHeight.GetState() == STATE_CHECK; BOOL bWidthChecked = !maTsbAutoGrowWidth.IsTriStateEnabled() && maTsbAutoGrowWidth.GetState() == STATE_CHECK; if( p == &maTsbAutoGrowHeight || p == NULL ) { if( bHeightChecked ) { maFtHeight.Disable(); maMtrHeight.Disable(); maCbxScale.Disable(); } else { maFtHeight.Enable(); maMtrHeight.Enable(); if( !bWidthChecked ) maCbxScale.Enable(); } } if( p == &maTsbAutoGrowWidth || p == NULL ) { if( bWidthChecked ) { maFtWidth.Disable(); maMtrWidth.Disable(); maCbxScale.Disable(); } else { maFtWidth.Enable(); maMtrWidth.Enable(); if( !bHeightChecked ) maCbxScale.Enable(); } } } return( 0L ); } //------------------------------------------------------------------------ IMPL_LINK( SvxPositionSizeTabPage, ClickAutoHdl, void *, p ) { if( maCbxScale.IsChecked() ) { mlOldWidth = Max( GetCoreValue( maMtrWidth, mePoolUnit ), 1L ); mlOldHeight = Max( GetCoreValue( maMtrHeight, mePoolUnit ), 1L ); } return( 0L ); } //------------------------------------------------------------------------ void SvxPositionSizeTabPage::FillUserData() { // Abgleich wird in der Ini-Datei festgehalten UniString aStr = UniString::CreateFromInt32( (sal_Int32) maCbxScale.IsChecked() ); SetUserData( aStr ); }