You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by al...@apache.org on 2013/10/04 19:20:26 UTC
svn commit: r1529226 [3/4] - in /openoffice/branches/alg/aw080/main:
basegfx/inc/basegfx/matrix/ basegfx/source/matrix/ filter/source/msfilter/
offapi/com/sun/star/drawing/ sd/inc/pch/ sd/source/ui/dlg/
sd/source/ui/func/ sd/source/ui/inc/ sd/source/ui...
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdglev.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdglev.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdglev.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdglev.cxx Fri Oct 4 17:20:25 2013
@@ -30,7 +30,7 @@
#include "svx/svdstr.hrc" // Namen aus der Resource
#include "svx/svdglob.hxx" // StringCache
#include <svx/svdpagv.hxx>
-#include <svx/svdglue.hxx>
+#include <svx/sdrglue.hxx>
#include <svx/svdtrans.hxx>
#include <svx/svdobj.hxx>
#include <svx/svdlegacy.hxx>
@@ -50,76 +50,79 @@ SdrGlueEditView::~SdrGlueEditView()
void SdrGlueEditView::ImpDoMarkedGluePoints(PGlueDoFunc pDoFunc, bool bConst, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5)
{
- if(areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
- {
- SdrObject* pObj = aSelection[nm];
- const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
-
- if(aMarkedGluePoints.size())
- {
- SdrGluePointList* pGPL = 0;
-
- if(bConst)
- {
- pGPL = const_cast< SdrGluePointList* >(pObj->GetGluePointList());
- }
- else
- {
- pGPL=pObj->ForceGluePointList();
- }
+ if(areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+
+ for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
+ {
+ SdrObject* pObj = aSelection[nm];
+ const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+
+ if(aMarkedGluePoints.size())
+ {
+ sdr::glue::List* pGPL = pObj->GetGluePointList(!bConst); // 0;
+
+ //if(bConst)
+ //{
+ // pGPL = const_cast< sdr::glue::List* >(pObj->GetGluePointList());
+ //}
+ //else
+ //{
+ // pGPL = pObj->GetGluePointList(true);
+ //}
- if(pGPL)
- {
- const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
-
- if(!bConst && IsUndoEnabled() )
- {
- AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
- }
-
- for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
- aCurrent != aMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nPtId(*aCurrent);
- const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
-
- if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
- {
- SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
-
- (*pDoFunc)(rGP,pObj,p1,p2,p3,p4,p5);
- }
- }
-
- if (!bConst)
- {
- pObj->SetChanged();
- }
- }
- }
- }
+ if(pGPL)
+ {
+ const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
- if(!bConst && aSelection.size())
- {
- getSdrModelFromSdrView().SetChanged();
- }
- }
+ if(!bConst && IsUndoEnabled() )
+ {
+ AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
+ }
+
+ for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
+ aCurrent != aMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nPtId(*aCurrent);
+ sdr::glue::Point* pCandidate = pGPL->findByID(nPtId);
+ // TTTT:GLUE
+ //const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
+
+ if(pCandidate)
+ //if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
+ {
+ //sdr::glue::Point& rGP=(*pGPL)[nGlueIdx];
+
+ (*pDoFunc)(*pCandidate, pObj, p1, p2, p3, p4, p5);
+ }
+ }
+
+ if (!bConst)
+ {
+ pObj->SetChanged();
+ }
+ }
+ }
+ }
+
+ if(!bConst && aSelection.size())
+ {
+ getSdrModelFromSdrView().SetChanged();
+ }
+ }
}
////////////////////////////////////////////////////////////////////////////////////////////////////
-static void ImpGetEscDir(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnThisEsc, const void* pnRet, const void*, const void*)
+static void ImpGetEscDir(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnThisEsc, const void* pnRet, const void*, const void*)
{
sal_uInt16& nRet=*(sal_uInt16*)pnRet;
bool& bFirst = *(bool*)pbFirst;
if(FUZZY != nRet)
{
- const sal_uInt16 nEsc(rGP.GetEscDir());
+ const sal_uInt16 nEsc(rGP.getEscapeDirections());
bool bOn(nEsc & *(sal_uInt16*)pnThisEsc);
if(bFirst)
@@ -142,9 +145,9 @@ TRISTATE SdrGlueEditView::IsMarkedGluePo
return (TRISTATE)nRet;
}
-static void ImpSetEscDir(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pnThisEsc, const void* pbOn, const void*, const void*, const void*)
+static void ImpSetEscDir(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pnThisEsc, const void* pbOn, const void*, const void*, const void*)
{
- sal_uInt16 nEsc=rGP.GetEscDir();
+ sal_uInt16 nEsc=rGP.getEscapeDirections();
if(*(bool*)pbOn)
{
@@ -155,7 +158,7 @@ static void ImpSetEscDir(SdrGluePoint& r
nEsc &= ~*(sal_uInt16*)pnThisEsc;
}
- rGP.SetEscDir(nEsc);
+ rGP.setEscapeDirections(nEsc);
}
void SdrGlueEditView::SetMarkedGluePointsEscDir(sal_uInt16 nThisEsc, bool bOn)
@@ -167,42 +170,44 @@ void SdrGlueEditView::SetMarkedGluePoint
////////////////////////////////////////////////////////////////////////////////////////////////////
-static void ImpGetPercent(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnRet, const void*, const void*, const void*)
+static void ImpGetPercent(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnRet, const void*, const void*, const void*)
{
- sal_uInt16& nRet=*(sal_uInt16*)pnRet;
- bool& bFirst = *(bool*)pbFirst;
+ sal_uInt16& nRet=*(sal_uInt16*)pnRet;
+ bool& bFirst = *(bool*)pbFirst;
- if(FUZZY != nRet)
- {
- bool bOn(rGP.IsPercent());
-
- if(bFirst)
- {
- nRet = bOn ? 1 : 0;
- bFirst = false;
- }
- else if((0 == nRet && bOn) || (1 == nRet && !bOn))
- {
- nRet = FUZZY;
- }
- }
+ if(FUZZY != nRet)
+ {
+ bool bOn(rGP.getRelative());
+
+ if(bFirst)
+ {
+ nRet = bOn ? 1 : 0;
+ bFirst = false;
+ }
+ else if((0 == nRet && bOn) || (1 == nRet && !bOn))
+ {
+ nRet = FUZZY;
+ }
+ }
}
TRISTATE SdrGlueEditView::IsMarkedGluePointsPercent() const
{
- bool bFirst(true);
- sal_uInt16 nRet(true);
- ((SdrGlueEditView*)this)->ImpDoMarkedGluePoints(ImpGetPercent, true, &bFirst, &nRet);
- return (TRISTATE)nRet;
+ bool bFirst(true);
+ sal_uInt16 nRet(true);
+ ((SdrGlueEditView*)this)->ImpDoMarkedGluePoints(ImpGetPercent, true, &bFirst, &nRet);
+ return (TRISTATE)nRet;
}
-static void ImpSetPercent(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbOn, const void*, const void*, const void*, const void*)
+static void ImpSetPercent(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pbOn, const void*, const void*, const void*, const void*)
{
- const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
- const basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
-
- rGP.SetPercent(*(bool*)pbOn);
- rGP.SetAbsolutePos(aPos, aObjectRange);
+ //const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
+ //const basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
+
+ // TTTT:GLUE
+ rGP.setRelative(*(bool*)pbOn);
+ //rGP.SetPercent(*(bool*)pbOn);
+ //rGP.SetAbsolutePos(aPos, aObjectRange);
}
void SdrGlueEditView::SetMarkedGluePointsPercent(bool bOn)
@@ -214,364 +219,435 @@ void SdrGlueEditView::SetMarkedGluePoint
////////////////////////////////////////////////////////////////////////////////////////////////////
-static void ImpGetAlign(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pbDontCare, const void* pbVert, const void* pnRet, const void*)
+static void ImpGetAlign(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pbDontCare, const void* pbVert, const void* pnRet, const void*)
{
- sal_uInt16& nRet=*(sal_uInt16*)pnRet;
- bool& bFirst = *(bool*)pbFirst;
- bool& bDontCare = *(bool*)pbDontCare;
- bool bVert = *(bool*)pbVert;
-
- if(!bDontCare)
- {
- sal_uInt16 nAlg(0);
-
- if(bVert)
- {
- nAlg=rGP.GetVertAlign();
- }
- else
- {
- nAlg=rGP.GetHorzAlign();
- }
-
- if(bFirst)
- {
- nRet = nAlg;
- bFirst = false;
- }
- else if(nRet != nAlg)
- {
- if(bVert)
- {
- nRet=SDRVERTALIGN_DONTCARE;
- }
- else
- {
- nRet=SDRHORZALIGN_DONTCARE;
- }
-
- bDontCare = true;
- }
- }
-}
-
-sal_uInt16 SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const
-{
- bool bFirst(true);
- bool bDontCare(false);
- sal_uInt16 nRet(0);
- const_cast< SdrGlueEditView* >(this)->ImpDoMarkedGluePoints(ImpGetAlign, true, &bFirst, &bDontCare, &bVert, &nRet);
- return nRet;
-}
-
-static void ImpSetAlign(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbVert, const void* pnAlign, const void*, const void*, const void*)
-{
- const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
- const basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
-
- if(*(bool*)pbVert)
- {
- // bVert?
- rGP.SetVertAlign(*(sal_uInt16*)pnAlign);
- }
- else
- {
- rGP.SetHorzAlign(*(sal_uInt16*)pnAlign);
- }
-
- rGP.SetAbsolutePos(aPos, aObjectRange);
-}
-
-void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, sal_uInt16 nAlign)
-{
- BegUndo(ImpGetResStr(STR_EditSetGlueAlign), getSelectedGluesDescription());
- ImpDoMarkedGluePoints(ImpSetAlign, false, &bVert, &nAlign);
- EndUndo();
+ sdr::glue::Point::Alignment& nRet=*(sdr::glue::Point::Alignment*)pnRet;
+ bool& bFirst = *(bool*)pbFirst;
+ bool& bDontCare = *(bool*)pbDontCare;
+ bool bVert = *(bool*)pbVert;
+
+ if(!bDontCare)
+ {
+ sdr::glue::Point::Alignment nAlg(sdr::glue::Point::Alignment_Center);
+
+ if(bVert)
+ {
+ nAlg = rGP.getVerticalAlignment();
+ }
+ else
+ {
+ nAlg = rGP.getHorizontalAlignment();
+ }
+
+ if(bFirst)
+ {
+ nRet = nAlg;
+ bFirst = false;
+ }
+ else if(nRet != nAlg)
+ {
+ bDontCare = true;
+ }
+ }
+}
+
+sdr::glue::Point::Alignment SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const
+{
+ bool bFirst(true);
+ bool bDontCare(false);
+ sdr::glue::Point::Alignment nRet(sdr::glue::Point::Alignment_Center);
+ const_cast< SdrGlueEditView* >(this)->ImpDoMarkedGluePoints(ImpGetAlign, true, &bFirst, &bDontCare, &bVert, &nRet);
+ return nRet;
+}
+
+static void ImpSetAlign(sdr::glue::Point& rGP, const SdrObject* /*pObj*/, const void* pbVert, const void* pnAlign, const void*, const void*, const void*)
+{
+ //const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
+ //const basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
+
+ if(*(bool*)pbVert)
+ {
+ rGP.setVerticalAlignment(*(sdr::glue::Point::Alignment *)pnAlign);
+ }
+ else
+ {
+ rGP.setHorizontalAlignment(*(sdr::glue::Point::Alignment *)pnAlign);
+ }
+
+ //rGP.SetAbsolutePos(aPos, aObjectRange);
+}
+
+void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, sdr::glue::Point::Alignment nAlign)
+{
+ BegUndo(ImpGetResStr(STR_EditSetGlueAlign), getSelectedGluesDescription());
+ ImpDoMarkedGluePoints(ImpSetAlign, false, &bVert, &nAlign);
+ EndUndo();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrGlueEditView::DeleteMarkedGluePoints()
{
- BrkAction();
+ BrkAction();
- if(areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
- const bool bUndo(IsUndoEnabled());
-
- if( bUndo )
- {
- BegUndo(ImpGetResStr(STR_EditDelete), getSelectedGluesDescription(), SDRREPFUNC_OBJ_DELETE);
- }
-
- for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
- {
- SdrObject* pObj = aSelection[nm];
- const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
-
- if(!aMarkedGluePoints.empty())
- {
- SdrGluePointList* pGPL=pObj->ForceGluePointList();
-
- if(pGPL)
- {
- const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
-
- if( bUndo )
- {
- AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
- }
-
- for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
- aCurrent != aMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nPtId(*aCurrent);
- const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
-
- if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
- {
- pGPL->Delete(nGlueIdx);
- }
- }
-
- pObj->SetChanged();
- }
- }
- }
+ if(areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+ const bool bUndo(IsUndoEnabled());
+
+ if( bUndo )
+ {
+ BegUndo(ImpGetResStr(STR_EditDelete), getSelectedGluesDescription(), SDRREPFUNC_OBJ_DELETE);
+ }
+
+ for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
+ {
+ SdrObject* pObj = aSelection[nm];
+ const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+
+ if(!aMarkedGluePoints.empty())
+ {
+ sdr::glue::List* pGPL = pObj->GetGluePointList(false);
- if( bUndo )
- {
- EndUndo();
- }
-
- MarkGluePoints(0, true);
+ if(pGPL)
+ {
+ const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
- if(aSelection.size())
- {
- getSdrModelFromSdrView().SetChanged();
- }
- }
+ if( bUndo )
+ {
+ AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
+ }
+
+ for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
+ aCurrent != aMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nPtId(*aCurrent);
+ sdr::glue::Point* pCandidate = pGPL->findByID(nPtId);
+
+ if(pCandidate)
+ {
+ pGPL->remove(*pCandidate);
+ }
+
+ // TTTT:GLUE
+ //const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
+ //
+ //if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
+ //{
+ // pGPL->Delete(nGlueIdx);
+ //}
+ }
+
+ pObj->SetChanged();
+ }
+ }
+ }
+
+ if( bUndo )
+ {
+ EndUndo();
+ }
+
+ MarkGluePoints(0, true);
+
+ if(aSelection.size())
+ {
+ getSdrModelFromSdrView().SetChanged();
+ }
+ }
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void SdrGlueEditView::ImpCopyMarkedGluePoints()
{
- if(areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
- const bool bUndo(IsUndoEnabled());
-
- if( bUndo )
- {
- BegUndo();
- }
-
- for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
- {
- SdrObject* pObj = aSelection[nm];
- sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
- bool bMarkedGluePointsChanged(false);
- SdrGluePointList* pGPL=pObj->ForceGluePointList();
-
- if(!aMarkedGluePoints.empty() && pGPL)
- {
- if( bUndo )
- {
- AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
- }
-
- for(sdr::selection::Indices::iterator aCurrent(aMarkedGluePoints.begin());
- aCurrent != aMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nPtId(*aCurrent);
- const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
-
- if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
- {
- SdrGluePoint aNewGP((*pGPL)[nGlueIdx]);
- const sal_uInt32 nNewIdx(pGPL->Insert(aNewGP));
- const sal_uInt32 nNewId((*pGPL)[nNewIdx].GetId());
-
- sdr::selection::Indices::iterator aNext(aCurrent);
- aNext++;
- aMarkedGluePoints.erase(aCurrent);
- aMarkedGluePoints.insert(nNewId);
- bMarkedGluePointsChanged = true;
- aCurrent = aNext;
- }
- }
- }
-
- if(bMarkedGluePointsChanged)
- {
- setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
- }
- }
-
- if( bUndo )
- {
- EndUndo();
- }
-
- if(aSelection.size())
- {
- getSdrModelFromSdrView().SetChanged();
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void SdrGlueEditView::ImpTransformMarkedGluePoints(PGlueTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5)
-{
- if(areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
- {
- SdrObject* pObj = aSelection[nm];
- const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
-
- if(!aMarkedGluePoints.empty())
- {
- SdrGluePointList* pGPL=pObj->ForceGluePointList();
-
- if(pGPL)
- {
- const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
-
- if( IsUndoEnabled() )
- {
- AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
- }
-
- for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
- aCurrent != aMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nPtId(*aCurrent);
- const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
-
- if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
- {
- SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
- const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
- basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
- (*pTrFunc)(aPos,p1,p2,p3,p4,p5);
- rGP.SetAbsolutePos(aPos, aObjectRange);
- }
- }
-
- pObj->SetChanged();
- }
- }
- }
-
- if(aSelection.size())
- {
- getSdrModelFromSdrView().SetChanged();
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static void ImpMove(basegfx::B2DPoint& rPt, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/)
-{
- rPt += *(static_cast< const basegfx::B2DVector* >(p1));
-}
-
-void SdrGlueEditView::MoveMarkedGluePoints(const basegfx::B2DVector& rDelta, bool bCopy)
-{
- XubString aStr(ImpGetResStr(STR_EditMove));
-
- if(bCopy)
- {
- aStr += ImpGetResStr(STR_EditWithCopy);
- }
-
- BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_MOVE);
-
- if(bCopy)
- {
- ImpCopyMarkedGluePoints();
- }
-
- ImpTransformMarkedGluePoints(ImpMove, &rDelta);
- EndUndo();
- RecreateAllMarkHandles();
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static void ImpResize(basegfx::B2DPoint& rPt, const void* p1, const void* p2, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/)
-{
- const basegfx::B2DPoint* pRef = static_cast< const basegfx::B2DPoint* >(p1);
- const basegfx::B2DVector* pScale = static_cast< const basegfx::B2DVector* >(p2);
-
- rPt = ((rPt - (*pRef)) * (*pScale)) + (*pRef);
-}
-
-void SdrGlueEditView::ResizeMarkedGluePoints(const basegfx::B2DPoint& rRef, const basegfx::B2DVector& rScale, bool bCopy)
-{
- XubString aStr(ImpGetResStr(STR_EditResize));
-
- if(bCopy)
- {
- aStr += ImpGetResStr(STR_EditWithCopy);
- }
-
- BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_RESIZE);
-
- if(bCopy)
- {
- ImpCopyMarkedGluePoints();
- }
-
- ImpTransformMarkedGluePoints(ImpResize, &rRef, &rScale);
- EndUndo();
- RecreateAllMarkHandles();
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static void ImpRotate(basegfx::B2DPoint& rPt, const void* p1, const void* /*p2*/, const void* p3, const void* p4, const void* /*p5*/)
-{
- const basegfx::B2DPoint* pRef = static_cast< const basegfx::B2DPoint* >(p1);
- const double* pSin = static_cast< const double* >(p3);
- const double* pCos = static_cast< const double* >(p4);
- const double fDx(rPt.getX() - pRef->getX());
- const double fDy(rPt.getX() - pRef->getX());
-
- rPt.setX(pRef->getX() + fDx * (*pCos) + fDy * (*pSin));
- rPt.setY(pRef->getY() + fDy * (*pCos) - fDx * (*pSin));
-}
-
-void SdrGlueEditView::RotateMarkedGluePoints(const basegfx::B2DPoint& rRef, double fAngle, bool bCopy)
-{
- XubString aStr(ImpGetResStr(STR_EditRotate));
-
- if(bCopy)
- {
- aStr += ImpGetResStr(STR_EditWithCopy);
- }
+ if(areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+ const bool bUndo(IsUndoEnabled());
+
+ if( bUndo )
+ {
+ BegUndo();
+ }
+
+ for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
+ {
+ SdrObject* pObj = aSelection[nm];
+ sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+ bool bMarkedGluePointsChanged(false);
+ sdr::glue::List* pGPL = pObj->GetGluePointList(false);
+
+ if(!aMarkedGluePoints.empty() && pGPL)
+ {
+ if( bUndo )
+ {
+ AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
+ }
- BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_ROTATE);
+ for(sdr::selection::Indices::iterator aCurrent(aMarkedGluePoints.begin());
+ aCurrent != aMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nPtId(*aCurrent);
+ sdr::glue::Point* pCandidate = pGPL->findByID(nPtId);
- if(bCopy)
- {
- ImpCopyMarkedGluePoints();
- }
+ if(pCandidate)
+ {
+ const sdr::glue::Point& rNew = pGPL->add(*pCandidate);
+ sdr::selection::Indices::iterator aNext(aCurrent);
+
+ aNext++;
+ aMarkedGluePoints.erase(aCurrent);
+ aMarkedGluePoints.insert(rNew.getID());
+ bMarkedGluePointsChanged = true;
+ aCurrent = aNext;
+ }
+
+ // TTTT:GLUE
+ //const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
+ //
+ //if(SDRGLUEPOINT_NOTFOUND != nGlueIdx)
+ //{
+ // sdr::glue::Point aNewGP((*pGPL)[nGlueIdx]);
+ // const sal_uInt32 nNewIdx(pGPL->Insert(aNewGP));
+ // const sal_uInt32 nNewId((*pGPL)[nNewIdx].GetId());
+ //
+ // sdr::selection::Indices::iterator aNext(aCurrent);
+ // aNext++;
+ // aMarkedGluePoints.erase(aCurrent);
+ // aMarkedGluePoints.insert(nNewId);
+ // bMarkedGluePointsChanged = true;
+ // aCurrent = aNext;
+ //}
+ }
+ }
+
+ if(bMarkedGluePointsChanged)
+ {
+ setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
+ }
+ }
+
+ if( bUndo )
+ {
+ EndUndo();
+ }
+
+ if(aSelection.size())
+ {
+ getSdrModelFromSdrView().SetChanged();
+ }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void SdrGlueEditView::ImpTransformMarkedGluePoints(const basegfx::B2DHomMatrix& rTransform)
+{
+ if(areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+
+ for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
+ {
+ SdrObject* pObj = aSelection[nm];
+ const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+
+ if(!aMarkedGluePoints.empty())
+ {
+ sdr::glue::List* pGPL = pObj->GetGluePointList(false);
- const double fSin(sin(fAngle));
- const double fCos(cos(fAngle));
+ if(pGPL)
+ {
+ const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*pObj);
- ImpTransformMarkedGluePoints(ImpRotate, &rRef, &fAngle, &fSin, &fCos);
- EndUndo();
- RecreateAllMarkHandles();
-}
+ if( IsUndoEnabled() )
+ {
+ AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
+ }
+
+ // Get ObjectMatrix, but take care for objects with zero width/height
+ const basegfx::B2DHomMatrix aCorrectedObjectTransformation(basegfx::tools::guaranteeMinimalScaling(pObj->getSdrObjectTransformation()));
+
+ // prepare inverse and get unit position of moved point
+ basegfx::B2DHomMatrix aInverseCorrectedObjectTransformation(aCorrectedObjectTransformation);
+
+ aInverseCorrectedObjectTransformation.invert();
+
+ for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
+ aCurrent != aMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nPtId(*aCurrent);
+ sdr::glue::Point* pCandidate = pGPL->findByID(nPtId);
+
+ if(pCandidate)
+ {
+ const basegfx::B2DPoint aAbsolutePos(aCorrectedObjectTransformation * pCandidate->getUnitPosition());
+ const basegfx::B2DPoint aTransformedPos(rTransform * aAbsolutePos);
+
+ pCandidate->setUnitPosition(aInverseCorrectedObjectTransformation * aTransformedPos);
+ }
+
+ // TTTT:GLUE
+ //const sal_uInt32 nGlueIdx(pGPL->FindGluePoint(nPtId));
+ //
+ //if(sdr::glue::Pointz_NOTFOUND != nGlueIdx)
+ //{
+ // sdr::glue::Point& rGP=(*pGPL)[nGlueIdx];
+ // const basegfx::B2DRange aObjectRange(sdr::legacy::GetSnapRange(*pObj));
+ // basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjectRange));
+ // (*pTrFunc)(aPos,p1,p2,p3,p4,p5);
+ // rGP.SetAbsolutePos(aPos, aObjectRange);
+ //}
+ }
+
+ pObj->SetChanged();
+ }
+ }
+ }
+
+ if(aSelection.size())
+ {
+ getSdrModelFromSdrView().SetChanged();
+ }
+ }
+}
+
+void SdrGlueEditView::TransformMarkedGluePoints(const basegfx::B2DHomMatrix& rTransformation, const SdrRepeatFunc aRepFunc, bool bCopy)
+{
+ if(areGluesSelected() && !rTransformation.isIdentity())
+ {
+ XubString aStr;
+
+ switch(aRepFunc)
+ {
+ default: //case SDRREPFUNC_OBJ_MOVE:
+ aStr = ImpGetResStr(STR_EditMove);
+ break;
+ case SDRREPFUNC_OBJ_RESIZE:
+ aStr = ImpGetResStr(STR_EditResize);
+ break;
+ case SDRREPFUNC_OBJ_ROTATE:
+ aStr = ImpGetResStr(STR_EditRotate); // no own string for rotate ?!?
+ break;
+ }
+
+ if(bCopy)
+ {
+ aStr += ImpGetResStr(STR_EditWithCopy);
+ }
+
+ BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_MOVE);
+
+ if(bCopy)
+ {
+ ImpCopyMarkedGluePoints();
+ }
+
+ ImpTransformMarkedGluePoints(rTransformation);
+
+ EndUndo();
+ RecreateAllMarkHandles();
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// TTTT:GLUE
+
+//static void ImpMove(basegfx::B2DPoint& rPt, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/)
+//{
+// rPt += *(static_cast< const basegfx::B2DVector* >(p1));
+//}
+
+//void SdrGlueEditView::MoveMarkedGluePoints(const basegfx::B2DVector& rDelta, bool bCopy)
+//{
+// XubString aStr(ImpGetResStr(STR_EditMove));
+//
+// if(bCopy)
+// {
+// aStr += ImpGetResStr(STR_EditWithCopy);
+// }
+//
+// BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_MOVE);
+//
+// if(bCopy)
+// {
+// ImpCopyMarkedGluePoints();
+// }
+//
+// ImpTransformMarkedGluePoints(ImpMove, &rDelta);
+// EndUndo();
+// RecreateAllMarkHandles();
+//}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//static void ImpResize(basegfx::B2DPoint& rPt, const void* p1, const void* p2, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/)
+//{
+// const basegfx::B2DPoint* pRef = static_cast< const basegfx::B2DPoint* >(p1);
+// const basegfx::B2DVector* pScale = static_cast< const basegfx::B2DVector* >(p2);
+//
+// rPt = ((rPt - (*pRef)) * (*pScale)) + (*pRef);
+//}
+
+//void SdrGlueEditView::ResizeMarkedGluePoints(const basegfx::B2DPoint& rRef, const basegfx::B2DVector& rScale, bool bCopy)
+//{
+// XubString aStr(ImpGetResStr(STR_EditResize));
+//
+// if(bCopy)
+// {
+// aStr += ImpGetResStr(STR_EditWithCopy);
+// }
+//
+// BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_RESIZE);
+//
+// if(bCopy)
+// {
+// ImpCopyMarkedGluePoints();
+// }
+//
+// ImpTransformMarkedGluePoints(ImpResize, &rRef, &rScale);
+// EndUndo();
+// RecreateAllMarkHandles();
+//}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//static void ImpRotate(basegfx::B2DPoint& rPt, const void* p1, const void* /*p2*/, const void* p3, const void* p4, const void* /*p5*/)
+//{
+// const basegfx::B2DPoint* pRef = static_cast< const basegfx::B2DPoint* >(p1);
+// const double* pSin = static_cast< const double* >(p3);
+// const double* pCos = static_cast< const double* >(p4);
+// const double fDx(rPt.getX() - pRef->getX());
+// const double fDy(rPt.getX() - pRef->getX());
+//
+// rPt.setX(pRef->getX() + fDx * (*pCos) + fDy * (*pSin));
+// rPt.setY(pRef->getY() + fDy * (*pCos) - fDx * (*pSin));
+//}
+
+//void SdrGlueEditView::RotateMarkedGluePoints(const basegfx::B2DPoint& rRef, double fAngle, bool bCopy)
+//{
+// XubString aStr(ImpGetResStr(STR_EditRotate));
+//
+// if(bCopy)
+// {
+// aStr += ImpGetResStr(STR_EditWithCopy);
+// }
+//
+// BegUndo(aStr, getSelectedGluesDescription(), SDRREPFUNC_OBJ_ROTATE);
+//
+// if(bCopy)
+// {
+// ImpCopyMarkedGluePoints();
+// }
+//
+// const double fSin(sin(fAngle));
+// const double fCos(cos(fAngle));
+//
+// ImpTransformMarkedGluePoints(ImpRotate, &rRef, &fAngle, &fSin, &fCos);
+// EndUndo();
+// RecreateAllMarkHandles();
+//}
////////////////////////////////////////////////////////////////////////////////////////////////////
// eof
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv.cxx Fri Oct 4 17:20:25 2013
@@ -1069,25 +1069,36 @@ void SdrMarkView::CreateMarkHandles(SdrH
if(!aMarkedGluePoints.empty())
{
- const SdrGluePointList* pGPL=pObj->GetGluePointList();
+ const sdr::glue::List* pGPL=pObj->GetGluePointList(false);
if(pGPL)
{
- const basegfx::B2DRange aObjSnapRange(sdr::legacy::GetSnapRange(*pObj));
+ // TTTT:GLUE const basegfx::B2DRange aObjSnapRange(sdr::legacy::GetSnapRange(*pObj));
for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
aCurrent != aMarkedGluePoints.end(); aCurrent++)
{
const sal_uInt32 nId(*aCurrent);
- const sal_uInt32 nNumGP(pGPL->FindGluePoint(nId));
-
- if(SDRGLUEPOINT_NOTFOUND != nNumGP)
+ const sdr::glue::Point* pCandidate = pGPL->findByID(nId);
+
+ if(pCandidate)
{
- const SdrGluePoint& rGP=(*pGPL)[nNumGP];
- basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjSnapRange));
+ const basegfx::B2DPoint aPos(pObj->getSdrObjectTransformation() * pCandidate->getUnitPosition());
SdrHdl* pGlueHdl = new SdrHdl(rTarget, pObj, HDL_GLUE, aPos);
+
pGlueHdl->SetObjHdlNum(nId);
}
+
+ // TTTT:GLUE
+ //const sal_uInt32 nNumGP(pGPL->FindGluePoint(nId));
+ //
+ //if(SDRGLUEPOINT_NOTFOUND != nNumGP)
+ //{
+ // const sdr::glue::Point& rGP=(*pGPL)[nNumGP];
+ // basegfx::B2DPoint aPos(rGP.GetAbsolutePos(aObjSnapRange));
+ // SdrHdl* pGlueHdl = new SdrHdl(rTarget, pObj, HDL_GLUE, aPos);
+ // pGlueHdl->SetObjHdlNum(nId);
+ //}
}
}
}
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv1.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv1.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv1.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdmrkv1.cxx Fri Oct 4 17:20:25 2013
@@ -312,290 +312,398 @@ void SdrMarkView::impCreatePointRanges()
bool SdrMarkView::HasMarkableGluePoints() const
{
- bool bRet(false);
-
- if(IsGluePointEditMode() && areSdrObjectsSelected())
+ if(IsGluePointEditMode() && areSdrObjectsSelected())
{
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size() && !bRet; nMarkNum++)
- {
- const SdrObject* pObj = aSelection[nMarkNum];
- const SdrGluePointList* pGPL=pObj->GetGluePointList();
-
- if(pGPL && pGPL->GetCount())
- {
- for(sal_uInt32 a(0); !bRet && a < pGPL->GetCount(); a++)
- {
- if((*pGPL)[a].IsUserDefined())
- {
- bRet = true;
- }
- }
- }
- }
- }
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+
+ for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
+ {
+ const SdrObject* pObj = aSelection[nMarkNum];
+ const sdr::glue::List* pGPL = pObj ? pObj->GetGluePointList(false) : 0;
+
+ if(pGPL)
+ {
+ const sdr::glue::PointVector aCandidates(pGPL->getVector());
+
+ for(sal_uInt32 a(0); a < aCandidates.size(); a++)
+ {
+ const sdr::glue::Point* pCandidate = aCandidates[a];
+
+ if(pCandidate)
+ {
+ if(aCandidates[a]->getUserDefined())
+ {
+ return true;
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "Got a sdr::glue::PointVector with empty spots (!)");
+ }
+ }
+ }
+ }
+ }
- return bRet;
+ return false;
}
sal_uInt32 SdrMarkView::GetMarkableGluePointCount() const
{
- sal_uInt32 nAnz(0);
-
- if(IsGluePointEditMode() && areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
- {
- const SdrObject* pObj = aSelection[nMarkNum];
- const SdrGluePointList* pGPL=pObj->GetGluePointList();
-
- if(pGPL && pGPL->GetCount())
- {
- for(sal_uInt32 a(0); a < pGPL->GetCount(); a++)
- {
- if((*pGPL)[a].IsUserDefined())
- {
- nAnz++;
- }
- }
- }
- }
- }
+ sal_uInt32 nAnz(0);
- return nAnz;
+ if(IsGluePointEditMode() && areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+
+ for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
+ {
+ const SdrObject* pObj = aSelection[nMarkNum];
+ const sdr::glue::List* pGPL = pObj ? pObj->GetGluePointList(false) : 0;
+
+ if(pGPL)
+ {
+ const sdr::glue::PointVector aCandidates(pGPL->getVector());
+
+ for(sal_uInt32 a(0); a < aCandidates.size(); a++)
+ {
+ const sdr::glue::Point* pCandidate = aCandidates[a];
+
+ if(pCandidate)
+ {
+ if(aCandidates[a]->getUserDefined())
+ {
+ nAnz++;
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "Got a sdr::glue::PointVector with empty spots (!)");
+ }
+ }
+
+ // TTTT:GLUE
+ //for(sal_uInt32 a(0); a < pGPL->GetCount(); a++)
+ //{
+ // if((*pGPL)[a].IsUserDefined())
+ // {
+ // nAnz++;
+ // }
+ //}
+ }
+ }
+ }
+
+ return nAnz;
}
sal_uInt32 SdrMarkView::GetMarkedGluePointCount() const
{
- sal_uInt32 nAnz(0);
+ sal_uInt32 nAnz(0);
- if(areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+ if(areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
- for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
+ for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
{
- const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*aSelection[nMarkNum]));
+ const sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*aSelection[nMarkNum]));
- nAnz += aMarkedGluePoints.size();
- }
- }
+ nAnz += aMarkedGluePoints.size();
+ }
+ }
- return nAnz;
+ return nAnz;
}
void SdrMarkView::MarkGluePoints(const basegfx::B2DRange* pRange, bool bUnmark)
{
- if(!IsGluePointEditMode() && !bUnmark)
- {
- return;
- }
-
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
- {
- const SdrObject* pObj = aSelection[nMarkNum];
- const SdrGluePointList* pGPL=pObj->GetGluePointList();
- sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
- bool bGluePointsChanged(false);
-
- if(bUnmark && !pRange)
- {
- // UnmarkAll
- if(aMarkedGluePoints.size())
- {
- aMarkedGluePoints.clear();
- bGluePointsChanged = true;
- }
- }
- else
- {
- if(pGPL && (!aMarkedGluePoints.empty() || !bUnmark))
- {
- const sal_uInt32 nGPAnz(pGPL->GetCount());
- const basegfx::B2DRange aObjSnapRange(nGPAnz ? sdr::legacy::GetSnapRange(*pObj) : basegfx::B2DRange());
-
- for(sal_uInt32 nGPNum(0); nGPNum < nGPAnz; nGPNum++)
- {
- const SdrGluePoint& rGP=(*pGPL)[nGPNum];
-
- if(rGP.IsUserDefined())
- {
- if(!pRange || pRange->isInside(rGP.GetAbsolutePos(aObjSnapRange)))
- {
- sdr::selection::Indices::iterator aFound(aMarkedGluePoints.find(rGP.GetId()));
-
- if(bUnmark)
- {
- if(aFound != aMarkedGluePoints.end())
- {
- aMarkedGluePoints.erase(aFound);
- bGluePointsChanged = true;
- }
- }
- else
- {
- if(aFound == aMarkedGluePoints.end())
- {
- aMarkedGluePoints.insert(rGP.GetId());
- bGluePointsChanged = true;
- }
- }
- }
- }
- }
- }
- }
-
- if(bGluePointsChanged)
- {
- setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
- }
- }
+ if(!IsGluePointEditMode() && !bUnmark)
+ {
+ return;
+ }
+
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+
+ for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
+ {
+ const SdrObject* pObj = aSelection[nMarkNum];
+
+ if(!pObj)
+ {
+ OSL_ENSURE(false, "Got SdrObjectVector from selection with empty entries (!)");
+ }
+ else
+ {
+ sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+ bool bGluePointsChanged(false);
+
+ if(bUnmark && !pRange)
+ {
+ // UnmarkAll
+ if(aMarkedGluePoints.size())
+ {
+ aMarkedGluePoints.clear();
+ bGluePointsChanged = true;
+ }
+ }
+ else
+ {
+ const sdr::glue::List* pGPL = pObj->GetGluePointList(false);
+
+ if(pGPL && (!aMarkedGluePoints.empty() || !bUnmark))
+ {
+ const sdr::glue::PointVector aCandidates(pGPL->getVector());
+
+ for(sal_uInt32 a(0); a < aCandidates.size(); a++)
+ {
+ const sdr::glue::Point* pCandidate = aCandidates[a];
+
+ if(pCandidate)
+ {
+ if(pCandidate->getUserDefined())
+ {
+ if(!pRange || pRange->isInside(pObj->getSdrObjectTransformation() * pCandidate->getUnitPosition()))
+ {
+ sdr::selection::Indices::iterator aFound(aMarkedGluePoints.find(pCandidate->getID()));
+
+ if(bUnmark)
+ {
+ if(aFound != aMarkedGluePoints.end())
+ {
+ aMarkedGluePoints.erase(aFound);
+ bGluePointsChanged = true;
+ }
+ }
+ else
+ {
+ if(aFound == aMarkedGluePoints.end())
+ {
+ aMarkedGluePoints.insert(pCandidate->getID());
+ bGluePointsChanged = true;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "Got a sdr::glue::PointVector with empty spots (!)");
+ }
+ }
+
+ // TTTT:GLUE
+ //const sal_uInt32 nGPAnz(pGPL->GetCount());
+ //const basegfx::B2DRange aObjSnapRange(nGPAnz ? sdr::legacy::GetSnapRange(*pObj) : basegfx::B2DRange());
+ //
+ //for(sal_uInt32 nGPNum(0); nGPNum < nGPAnz; nGPNum++)
+ //{
+ // const sdr::glue::Point& rGP=(*pGPL)[nGPNum];
+ //
+ // if(rGP.IsUserDefined())
+ // {
+ // if(!pRange || pRange->isInside(rGP.GetAbsolutePos(aObjSnapRange)))
+ // {
+ // sdr::selection::Indices::iterator aFound(aMarkedGluePoints.find(rGP.GetId()));
+ //
+ // if(bUnmark)
+ // {
+ // if(aFound != aMarkedGluePoints.end())
+ // {
+ // aMarkedGluePoints.erase(aFound);
+ // bGluePointsChanged = true;
+ // }
+ // }
+ // else
+ // {
+ // if(aFound == aMarkedGluePoints.end())
+ // {
+ // aMarkedGluePoints.insert(rGP.GetId());
+ // bGluePointsChanged = true;
+ // }
+ // }
+ // }
+ // }
+ //}
+ }
+ }
+
+ if(bGluePointsChanged)
+ {
+ setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
+ }
+ }
+ }
}
bool SdrMarkView::PickGluePoint(const basegfx::B2DPoint& rPnt, SdrObject*& rpObj, sal_uInt32& rnId) const
{
- rpObj = 0;
- rnId = 0;
+ rpObj = 0;
+ rnId = 0;
+
+ if(!IsGluePointEditMode())
+ {
+ return false;
+ }
+
+ // SdrObject* pObj0 = rpObj;
+ const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
+ sal_uInt32 nMarkNum(aSelection.size());
+
+ while(nMarkNum > 0)
+ {
+ nMarkNum--;
+ SdrObject* pObj = aSelection[nMarkNum];
+ const sdr::glue::List* pGPL = pObj ? pObj->GetGluePointList(false) : 0;
+
+ if(pGPL)
+ {
+ const sdr::glue::PointVector aCandidates(pGPL->getVector());
+
+ for(sal_uInt32 a(0); a < aCandidates.size(); a++)
+ {
+ const sdr::glue::Point* pCandidate = aCandidates[a];
- if(!IsGluePointEditMode())
- {
- return false;
- }
-
- SdrObject* pObj0=rpObj;
- const SdrObjectVector aSelection(getSelectedSdrObjectVectorFromSdrMarkView());
- sal_uInt32 nMarkNum(aSelection.size());
-
- while(nMarkNum > 0)
- {
- nMarkNum--;
- SdrObject* pObj = aSelection[nMarkNum];
- const SdrGluePointList* pGPL=pObj->GetGluePointList();
-
- if(pGPL)
- {
- const sal_uInt32 nNum(pGPL->GPLHitTest(rPnt, getHitTolLog(), sdr::legacy::GetSnapRange(*pObj), false));
-
- if(SDRGLUEPOINT_NOTFOUND != nNum)
- {
- // #i38892#
- const SdrGluePoint& rCandidate = (*pGPL)[nNum];
-
- if(rCandidate.IsUserDefined())
- {
- rpObj=pObj;
- rnId=(*pGPL)[nNum].GetId();
-
- return true;
- }
- }
- }
- }
+ if(pCandidate)
+ {
+ if(pCandidate->getUserDefined())
+ {
+ const basegfx::B2DPoint aAbsolutePos(pObj->getSdrObjectTransformation() * pCandidate->getUnitPosition());
+ const double fDist(basegfx::B2DVector(aAbsolutePos - rPnt).getLength());
+
+ if(basegfx::fTools::lessOrEqual(fDist, getHitTolLog()))
+ {
+ rpObj = pObj;
+ rnId = pCandidate->getID();
+
+ return true;
+ }
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "Got a sdr::glue::PointVector with empty spots (!)");
+ }
+ }
+ }
+
+ // TTTT:GLUE
+ // const sal_uInt32 nNum(pGPL->GPLHitTest(rPnt, getHitTolLog(), pObj->getSdrObjectTransformation(), false));
+ //
+ // if(SDRGLUEPOINT_NOTFOUND != nNum)
+ // {
+ // // #i38892#
+ // const sdr::glue::Point& rCandidate = (*pGPL)[nNum];
+ //
+ // if(rCandidate.IsUserDefined())
+ // {
+ // rpObj=pObj;
+ // rnId=(*pGPL)[nNum].GetId();
+ //
+ // return true;
+ // }
+ // }
+ //}
+ }
- return false;
+ return false;
}
bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt32 nId, bool bUnmark)
{
- if(!IsGluePointEditMode())
- {
- return false;
- }
-
- bool bChgd(false);
-
- if(pObj)
- {
- if(isSdrObjectSelected(*pObj))
- {
- sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
- sdr::selection::Indices::iterator aFound(aMarkedGluePoints.find(nId));
- bool bGluePointsChanged(false);
-
- if(bUnmark)
- {
- if(aFound != aMarkedGluePoints.end())
- {
- aMarkedGluePoints.erase(aFound);
- bGluePointsChanged = true;
- }
- }
- else
- {
- if(aFound == aMarkedGluePoints.end())
+ if(!IsGluePointEditMode())
+ {
+ return false;
+ }
+
+ bool bChgd(false);
+
+ if(pObj)
+ {
+ if(isSdrObjectSelected(*pObj))
+ {
+ sdr::selection::Indices aMarkedGluePoints(getSelectedGluesForSelectedSdrObject(*pObj));
+ sdr::selection::Indices::iterator aFound(aMarkedGluePoints.find(nId));
+ bool bGluePointsChanged(false);
+
+ if(bUnmark)
+ {
+ if(aFound != aMarkedGluePoints.end())
+ {
+ aMarkedGluePoints.erase(aFound);
+ bGluePointsChanged = true;
+ }
+ }
+ else
+ {
+ if(aFound == aMarkedGluePoints.end())
{
- aMarkedGluePoints.insert(nId);
- bGluePointsChanged = true;
- }
- }
-
- if(bGluePointsChanged)
- {
- bChgd = true;
- setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
- }
- }
- else
- {
- // Objekt implizit markieren ...
- // ... fehlende Implementation
- }
- }
+ aMarkedGluePoints.insert(nId);
+ bGluePointsChanged = true;
+ }
+ }
+
+ if(bGluePointsChanged)
+ {
+ bChgd = true;
+ setSelectedGluesForSelectedSdrObject(*pObj, aMarkedGluePoints);
+ }
+ }
+ else
+ {
+ // Objekt implizit markieren ...
+ // ... fehlende Implementation
+ }
+ }
- return bChgd;
+ return bChgd;
}
bool SdrMarkView::IsGluePointMarked(const SdrObject& rObj, sal_uInt32 nId) const
{
- return (0 != getSelectedGluesForSelectedSdrObject(rObj).count(nId));
+ return (0 != getSelectedGluesForSelectedSdrObject(rObj).count(nId));
}
bool SdrMarkView::UnmarkGluePoint(const SdrHdl& rHdl)
{
- if(&rHdl && HDL_GLUE == rHdl.GetKind() && rHdl.GetObj())
- {
- return MarkGluePoint(rHdl.GetObj(), rHdl.GetObjHdlNum(), true);
- }
- else
- {
- return false;
- }
+ if(&rHdl && HDL_GLUE == rHdl.GetKind() && rHdl.GetObj())
+ {
+ return MarkGluePoint(rHdl.GetObj(), rHdl.GetObjHdlNum(), true);
+ }
+ else
+ {
+ return false;
+ }
}
SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt32 nId) const
{
const SdrHdlList& rHdlList = GetHdlList();
- const sal_uInt32 nHdlAnz(rHdlList.GetHdlCount());
+ const sal_uInt32 nHdlAnz(rHdlList.GetHdlCount());
- for(sal_uInt32 nHdlNum(0); nHdlNum < nHdlAnz; nHdlNum++)
+ for(sal_uInt32 nHdlNum(0); nHdlNum < nHdlAnz; nHdlNum++)
{
- SdrHdl* pHdl = rHdlList.GetHdlByIndex(nHdlNum);
+ SdrHdl* pHdl = rHdlList.GetHdlByIndex(nHdlNum);
- if (pHdl->GetObj()==pObj &&
- HDL_GLUE == pHdl->GetKind() &&
- pHdl->GetObjHdlNum() == nId)
- {
- return pHdl;
- }
+ if (pHdl->GetObj()==pObj &&
+ HDL_GLUE == pHdl->GetKind() &&
+ pHdl->GetObjHdlNum() == nId)
+ {
+ return pHdl;
+ }
}
- return 0;
+ return 0;
}
const basegfx::B2DRange& SdrMarkView::getMarkedGluePointRange() const
{
- if(maMarkedGluePointRange.isEmpty())
- {
- impCreatePointRanges();
+ if(maMarkedGluePointRange.isEmpty())
+ {
+ impCreatePointRanges();
}
- return maMarkedGluePointRange;
+ return maMarkedGluePointRange;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdoashp.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdoashp.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdoashp.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdoashp.cxx Fri Oct 4 17:20:25 2013
@@ -1812,89 +1812,145 @@ void SdrObjCustomShape::setSdrObjectTran
////////////////////////////////////////////////////////////////////////////////////////////////////
-// #i38892#
-void SdrObjCustomShape::ImpCheckCustomGluePointsAreAdded()
-{
- const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
-
- if(pSdrObject)
- {
- const SdrGluePointList* pSource = pSdrObject->GetGluePointList();
+// TTTT:GLUE
+//void SdrObjCustomShape::ImpCheckCustomGluePointsAreAdded()
+//{
+// const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
+//
+// if(pSdrObject)
+// {
+// const sdr::glue::List* pSource = pSdrObject->GetGluePointList(false);
+//
+// if(pSource && pSource->GetCount())
+// {
+// //if(!SdrTextObj::GetGluePointList())
+// //{
+// // SdrTextObj::ForceGluePointList();
+// //}
+//
+// const sdr::glue::List* pList = SdrTextObj::GetGluePointList(true);
+//
+// if(pList)
+// {
+// sdr::glue::List aNewList;
+// sal_uInt16 a;
+//
+// // build transform matrix from helper object to local
+// basegfx::B2DHomMatrix aTransFromHelperToLocal(pSdrObject->getSdrObjectTransformation());
+// aTransFromHelperToLocal.invert();
+// aTransFromHelperToLocal = getSdrObjectTransformation() * aTransFromHelperToLocal;
+//
+// for(a = 0; a < pSource->GetCount(); a++)
+// {
+// sdr::glue::Point aCopy((*pSource)[a]);
+// aCopy.SetUserDefined(false);
+//
+// basegfx::B2DPoint aGluePos(aCopy.GetPos());
+// aGluePos *= aTransFromHelperToLocal;
+// aCopy.SetPos(aGluePos);
+//
+// aNewList.Insert(aCopy);
+// }
+//
+// for(a = 0; a < pList->GetCount(); a++)
+// {
+// const sdr::glue::Point& rCandidate = (*pList)[a];
+//
+// if(rCandidate.IsUserDefined())
+// {
+// aNewList.Insert(rCandidate);
+// }
+// }
+//
+// // copy new list to local. This is NOT very convenient behaviour, the local
+// // GluePointList should not be set, but be delivered by using GetGluePointList(),
+// // maybe on demand. Since the local object is changed here, this is assumed to
+// // be a result of GetGluePointList and thus the list is copied
+// if(mpPlusData)
+// {
+// *mpPlusData->mpGluePoints = aNewList;
+// }
+// }
+// }
+// }
+//}
- if(pSource && pSource->GetCount())
- {
- if(!SdrTextObj::GetGluePointList())
- {
- SdrTextObj::ForceGluePointList();
- }
+sdr::glue::List* SdrObjCustomShape::GetGluePointList(bool bForce) const
+{
+ sdr::glue::List* pOld = GetGluePointList(false);
+ sdr::glue::List* pNew = GetGluePointList(bForce);
- const SdrGluePointList* pList = SdrTextObj::GetGluePointList();
+ if(bForce && !pOld && pNew)
+ {
+ // new list was created, add GluePoints from created visualization as non-user-defined GluePoints
+ const SdrObject* pSdrObject = GetSdrObjectFromCustomShape();
- if(pList)
- {
- SdrGluePointList aNewList;
- sal_uInt16 a;
+ if(pSdrObject)
+ {
+ const sdr::glue::List* pSource = pSdrObject->GetGluePointList(false);
- // build transform matrix from helper object to local
- basegfx::B2DHomMatrix aTransFromHelperToLocal(pSdrObject->getSdrObjectTransformation());
- aTransFromHelperToLocal.invert();
- aTransFromHelperToLocal = getSdrObjectTransformation() * aTransFromHelperToLocal;
+ if(pSource)
+ {
+ // build transform from helper object unit coordinates to target object unit coordinates;
+ // we need the inverse of the target object transform. temporarily correct zero sizes for invert
+ basegfx::B2DHomMatrix aInvLocal(basegfx::tools::guaranteeMinimalScaling(getSdrObjectTransformation()));
+ aInvLocal.invert();
- for(a = 0; a < pSource->GetCount(); a++)
- {
- SdrGluePoint aCopy((*pSource)[a]);
- aCopy.SetUserDefined(false);
+ // build full transform
+ basegfx::B2DHomMatrix aFullHelperUnitToTargetUnit(aInvLocal * pSdrObject->getSdrObjectTransformation());
- basegfx::B2DPoint aGluePos(aCopy.GetPos());
- aGluePos *= aTransFromHelperToLocal;
- aCopy.SetPos(aGluePos);
+ // get vector, change and copy points
+ const sdr::glue::PointVector aCandidates(pSource->getVector());
- aNewList.Insert(aCopy);
- }
+ for(sal_uInt32 a(0); a < aCandidates.size(); a++)
+ {
+ const sdr::glue::Point* pCandidate(aCandidates[a]);
- for(a = 0; a < pList->GetCount(); a++)
- {
- const SdrGluePoint& rCandidate = (*pList)[a];
+ if(pCandidate)
+ {
+ const basegfx::B2DPoint aNewPos(aFullHelperUnitToTargetUnit * pCandidate->getUnitPosition());
+ const sdr::glue::Point aNewPoint(
+ aNewPos,
+ pCandidate->getEscapeDirections(),
+ pCandidate->getHorizontalAlignment(),
+ pCandidate->getVerticalAlignment(),
+ pCandidate->getRelative(),
+ false);
+
+ pNew->add(aNewPoint);
+ }
+ else
+ {
+ OSL_ENSURE(false, "Got empty slot in sdr::glue::PointVector (!)");
+ }
+ }
+ }
+ }
- if(rCandidate.IsUserDefined())
- {
- aNewList.Insert(rCandidate);
- }
- }
+ // TTTT:GLUE check here (!)
+ // Add custom glues here (!)
+ // ((SdrObjCustomShape*)this)->ImpCheckCustomGluePointsAreAdded();
+ }
- // copy new list to local. This is NOT very convenient behaviour, the local
- // GluePointList should not be set, but be delivered by using GetGluePointList(),
- // maybe on demand. Since the local object is changed here, this is assumed to
- // be a result of GetGluePointList and thus the list is copied
- if(mpPlusData)
- {
- *mpPlusData->mpGluePoints = aNewList;
- }
- }
- }
- }
-}
+ return mpPlusData ? mpPlusData->mpGluePoints : 0;
-// #i38892#
-const SdrGluePointList* SdrObjCustomShape::GetGluePointList() const
-{
- ((SdrObjCustomShape*)this)->ImpCheckCustomGluePointsAreAdded();
- return SdrTextObj::GetGluePointList();
+ //((SdrObjCustomShape*)this)->ImpCheckCustomGluePointsAreAdded();
+ //return SdrTextObj::GetGluePointList();
}
-// #i38892#
-SdrGluePointList* SdrObjCustomShape::ForceGluePointList()
-{
- if(SdrTextObj::ForceGluePointList())
- {
- ImpCheckCustomGluePointsAreAdded();
- return SdrTextObj::ForceGluePointList();
- }
- else
- {
- return 0L;
- }
-}
+//// #i38892# TTTT:GLUE
+//sdr::glue::List* SdrObjCustomShape::ForceGluePointList()
+//{
+// if(SdrTextObj::ForceGluePointList())
+// {
+// ImpCheckCustomGluePointsAreAdded();
+// return SdrTextObj::ForceGluePointList();
+// }
+// else
+// {
+// return 0L;
+// }
+//}
////////////////////////////////////////////////////////////////////////////////////////////////////
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdobj.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdobj.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdobj.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdobj.cxx Fri Oct 4 17:20:25 2013
@@ -397,7 +397,7 @@ SdrObjPlusData* SdrObjPlusData::Clone(Sd
// copy GluePoints
if(mpGluePoints)
{
- pNeuPlusData->mpGluePoints = new SdrGluePointList(*mpGluePoints);
+ pNeuPlusData->mpGluePoints = new sdr::glue::List(*mpGluePoints);
}
// copy object name, title and description
@@ -1585,7 +1585,7 @@ void SdrObject::SaveGeoData(SdrObjGeoDat
}
else
{
- rGeo.mpGPL = new SdrGluePointList(*mpPlusData->mpGluePoints);
+ rGeo.mpGPL = new sdr::glue::List(*mpPlusData->mpGluePoints);
}
}
else
@@ -1631,7 +1631,7 @@ void SdrObject::RestGeoData(const SdrObj
}
else
{
- mpPlusData->mpGluePoints = new SdrGluePointList(*rGeo.mpGPL);
+ mpPlusData->mpGluePoints = new sdr::glue::List(*rGeo.mpGPL);
}
}
else
@@ -2063,61 +2063,78 @@ void SdrObject::SetStyleSheet(SfxStyleSh
}
}
-SdrGluePoint SdrObject::GetVertexGluePoint(sal_uInt32 nPosNum) const
+sdr::glue::Point SdrObject::GetVertexGluePoint(sal_uInt32 nPosNum) const
{
- basegfx::B2DPoint aGluePoint(0.5, 0.5);
+ basegfx::B2DPoint aGluePosition(0.5, 0.5);
- switch(nPosNum)
- {
- default: //case 0: TopCenter
- {
- aGluePoint.setY(0.0);
- break;
- }
- case 1: // RightCenter
- {
- aGluePoint.setX(1.0);
- break;
- }
- case 2: // BottomCenter
- {
- aGluePoint.setY(1.0);
- break;
- }
- case 3: // LeftCenter
- {
- aGluePoint.setX(0.0);
- break;
- }
- }
-
- aGluePoint = getSdrObjectTransformation() * aGluePoint;
- SdrGluePoint aGP(aGluePoint - sdr::legacy::GetSnapRange(*this).getCenter());
- aGP.SetPercent(false);
-
- return aGP;
-}
-
-const SdrGluePointList* SdrObject::GetGluePointList() const
-{
- if(mpPlusData)
+ switch(nPosNum)
{
- return mpPlusData->mpGluePoints;
+ default: //case 0: TopCenter
+ {
+ aGluePosition.setY(0.0);
+ break;
+ }
+ case 1: // RightCenter
+ {
+ aGluePosition.setX(1.0);
+ break;
+ }
+ case 2: // BottomCenter
+ {
+ aGluePosition.setY(1.0);
+ break;
+ }
+ case 3: // LeftCenter
+ {
+ aGluePosition.setX(0.0);
+ break;
+ }
}
- return 0;
+ // create GluePoint, need to set UserDefined to false for these default GluePoints
+ return sdr::glue::Point(
+ aGluePosition,
+ sdr::glue::Point::ESCAPE_DIRECTION_SMART,
+ sdr::glue::Point::Alignment_Center,
+ sdr::glue::Point::Alignment_Center,
+ true, // mbRelative
+ false); // mbUserDefined
+
+ // TTTT:GLUE
+ //aGluePosition = getSdrObjectTransformation() * aGluePosition;
+ //sdr::glue::Point aGP(aGluePosition - sdr::legacy::GetSnapRange(*this).getCenter());
+ //aGP.SetPercent(false);
+ //
+ //return aGP;
}
-SdrGluePointList* SdrObject::ForceGluePointList()
+// TTTT:GLUE
+//const sdr::glue::List* SdrObject::GetGluePointList() const
+//{
+// if(mpPlusData)
+// {
+// return mpPlusData->mpGluePoints;
+// }
+//
+// return 0;
+//}
+
+sdr::glue::List* SdrObject::GetGluePointList(bool bForce) const
{
- ImpForcePlusData();
-
- if(!mpPlusData->mpGluePoints)
+ if(bForce)
{
- mpPlusData->mpGluePoints = new SdrGluePointList;
- }
+ if(!mpPlusData)
+ {
+ const_cast< SdrObject* >(this)->ImpForcePlusData();
+ }
- return mpPlusData->mpGluePoints;
+ if(!mpPlusData->mpGluePoints)
+ {
+ const_cast< SdrObject* >(this)->mpPlusData->mpGluePoints = new sdr::glue::List;
+ }
+ }
+
+ return mpPlusData ? mpPlusData->mpGluePoints : 0;
}
void extractLineContourFromPrimitive2DSequence(
@@ -2602,7 +2619,7 @@ void SdrObject::setSdrObjectTransformati
//SetGlueReallyAbsolute(false);
//if (GetGluePointList()!=NULL) {
- // SdrGluePointList* pGPL=ForceGluePointList();
+ // sdr::glue::List* pGPL=GetGluePointList(true);
// pGPL->SetReallyAbsolute(true,*this);
// NbcShearGluePoints(rRef,nWink,tn,bVShear);
// pGPL->SetReallyAbsolute(false,*this);
@@ -2610,14 +2627,31 @@ void SdrObject::setSdrObjectTransformati
if(rTransformation != getSdrObjectTransformation())
{
- if(GetGluePointList())
+ basegfx::B2DVector aOldAbsoluteScale;
+ sdr::glue::List* pGPL = GetGluePointList(false);
+
+ if(pGPL)
{
- ForceGluePointList()->TransformGluePoints(rTransformation, sdr::legacy::GetSnapRange(*this));
+ // remember old absolute size
+ aOldAbsoluteScale = basegfx::absolute(getSdrObjectScale());
}
const SdrObjectChangeBroadcaster aSdrObjectChangeBroadcaster(*this);
+
maSdrObjectTransformation.setB2DHomMatrix(rTransformation);
SetChanged();
+
+ if(pGPL)
+ {
+ // get new absolute size
+ const basegfx::B2DVector aNewAbsoluteScale(basegfx::absolute(getSdrObjectScale()));
+
+ if(!aOldAbsoluteScale.equal(aNewAbsoluteScale))
+ {
+ // adapt the non-relative gluepoints according to their alignments
+ pGPL->adaptToChangedScale(aOldAbsoluteScale, aNewAbsoluteScale);
+ }
+ }
}
}