Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 394 insertions, 0 deletions

diff --git a/svx/source/svdraw/svdglue.cxx b/svx/source/svdraw/svdglue.cxx
new file mode 100644
index 000000000..9808372f8
--- /dev/null
+++ b/svx/source/svdraw/svdglue.cxx
@@ -0,0 +1,394 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/debug.hxx>
+#include <vcl/window.hxx>
+
+#include <svx/svdglue.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdtrans.hxx>
+#include <comphelper/lok.hxx>
+
+const Size aGlueHalfSize(4,4);
+
+void SdrGluePoint::SetReallyAbsolute(bool bOn, const SdrObject& rObj)
+{
+   if ( bReallyAbsolute == bOn )
+       return;
+
+   if ( bOn )
+   {
+       aPos=GetAbsolutePos(rObj);
+       bReallyAbsolute=bOn;
+   }
+   else
+   {
+       bReallyAbsolute=bOn;
+       Point aPt(aPos);
+       SetAbsolutePos(aPt,rObj);
+   }
+}
+
+Point SdrGluePoint::GetAbsolutePos(const SdrObject& rObj) const
+{
+    if (bReallyAbsolute) return aPos;
+    tools::Rectangle aSnap(rObj.GetSnapRect());
+    tools::Rectangle aBound(rObj.GetSnapRect());
+    Point aPt(aPos);
+
+    Point aOfs(aSnap.Center());
+    switch (GetHorzAlign()) {
+        case SdrAlign::HORZ_LEFT  : aOfs.setX(aSnap.Left() ); break;
+        case SdrAlign::HORZ_RIGHT : aOfs.setX(aSnap.Right() ); break;
+        default: break;
+    }
+    switch (GetVertAlign()) {
+        case SdrAlign::VERT_TOP   : aOfs.setY(aSnap.Top() ); break;
+        case SdrAlign::VERT_BOTTOM: aOfs.setY(aSnap.Bottom() ); break;
+        default: break;
+    }
+    if (!bNoPercent) {
+        tools::Long nXMul=aSnap.Right()-aSnap.Left();
+        tools::Long nYMul=aSnap.Bottom()-aSnap.Top();
+        tools::Long nXDiv=10000;
+        tools::Long nYDiv=10000;
+        if (nXMul!=nXDiv) {
+            aPt.setX( aPt.X() * nXMul );
+            aPt.setX( aPt.X() / nXDiv );
+        }
+        if (nYMul!=nYDiv) {
+            aPt.setY( aPt.Y() * nYMul );
+            aPt.setY( aPt.Y() / nYDiv );
+        }
+    }
+    aPt+=aOfs;
+    // Now limit to the BoundRect of the object
+    if (aPt.X()<aBound.Left  ()) aPt.setX(aBound.Left  () );
+    if (aPt.X()>aBound.Right ()) aPt.setX(aBound.Right () );
+    if (aPt.Y()<aBound.Top   ()) aPt.setY(aBound.Top   () );
+    if (aPt.Y()>aBound.Bottom()) aPt.setY(aBound.Bottom() );
+    return aPt;
+}
+
+void SdrGluePoint::SetAbsolutePos(const Point& rNewPos, const SdrObject& rObj)
+{
+    if (bReallyAbsolute) {
+        aPos=rNewPos;
+        return;
+    }
+    tools::Rectangle aSnap(rObj.GetSnapRect());
+    Point aPt(rNewPos);
+
+    Point aOfs(aSnap.Center());
+    switch (GetHorzAlign()) {
+        case SdrAlign::HORZ_LEFT  : aOfs.setX(aSnap.Left() ); break;
+        case SdrAlign::HORZ_RIGHT : aOfs.setX(aSnap.Right() ); break;
+        default: break;
+    }
+    switch (GetVertAlign()) {
+        case SdrAlign::VERT_TOP   : aOfs.setY(aSnap.Top() ); break;
+        case SdrAlign::VERT_BOTTOM: aOfs.setY(aSnap.Bottom() ); break;
+        default: break;
+    }
+    aPt-=aOfs;
+    if (!bNoPercent) {
+        tools::Long nXMul=aSnap.Right()-aSnap.Left();
+        tools::Long nYMul=aSnap.Bottom()-aSnap.Top();
+        if (nXMul==0) nXMul=1;
+        if (nYMul==0) nYMul=1;
+        tools::Long nXDiv=10000;
+        tools::Long nYDiv=10000;
+        if (nXMul!=nXDiv) {
+            aPt.setX( aPt.X() * nXDiv );
+            aPt.setX( aPt.X() / nXMul );
+        }
+        if (nYMul!=nYDiv) {
+            aPt.setY( aPt.Y() * nYDiv );
+            aPt.setY( aPt.Y() / nYMul );
+        }
+    }
+    aPos=aPt;
+}
+
+Degree100 SdrGluePoint::GetAlignAngle() const
+{
+    if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
+        return 0_deg100; // Invalid!
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER))
+        return 0_deg100;
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP))
+        return 4500_deg100;
+    else if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP))
+        return 9000_deg100;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_TOP))
+        return 13500_deg100;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_CENTER))
+        return 18000_deg100;
+    else if (nAlign == (SdrAlign::HORZ_LEFT  |SdrAlign::VERT_BOTTOM))
+        return 22500_deg100;
+    else if (nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM))
+        return 27000_deg100;
+    else if (nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM))
+        return 31500_deg100;
+    return 0_deg100;
+}
+
+void SdrGluePoint::SetAlignAngle(Degree100 nAngle)
+{
+    nAngle=NormAngle36000(nAngle);
+    if (nAngle>=33750_deg100 || nAngle<2250_deg100) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER;
+    else if (nAngle< 6750_deg100) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP   ;
+    else if (nAngle<11250_deg100) nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP   ;
+    else if (nAngle<15750_deg100) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_TOP   ;
+    else if (nAngle<20250_deg100) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_CENTER;
+    else if (nAngle<24750_deg100) nAlign=SdrAlign::HORZ_LEFT  |SdrAlign::VERT_BOTTOM;
+    else if (nAngle<29250_deg100) nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM;
+    else if (nAngle<33750_deg100) nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM;
+}
+
+Degree100 SdrGluePoint::EscDirToAngle(SdrEscapeDirection nEsc)
+{
+    switch (nEsc) {
+        case SdrEscapeDirection::RIGHT : return 0_deg100;
+        case SdrEscapeDirection::TOP   : return 9000_deg100;
+        case SdrEscapeDirection::LEFT  : return 18000_deg100;
+        case SdrEscapeDirection::BOTTOM: return 27000_deg100;
+        default: break;
+    } // switch
+    return 0_deg100;
+}
+
+SdrEscapeDirection SdrGluePoint::EscAngleToDir(Degree100 nAngle)
+{
+    nAngle=NormAngle36000(nAngle);
+    if (nAngle>=31500_deg100 || nAngle<4500_deg100)
+        return SdrEscapeDirection::RIGHT;
+    if (nAngle<13500_deg100)
+        return SdrEscapeDirection::TOP;
+    if (nAngle<22500_deg100)
+        return SdrEscapeDirection::LEFT;
+    /* (nAngle<31500)*/
+    return SdrEscapeDirection::BOTTOM;
+}
+
+void SdrGluePoint::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs, const SdrObject* pObj)
+{
+    Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos());
+    RotatePoint(aPt,rRef,sn,cs);
+    // rotate reference edge
+    if(nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
+    {
+        SetAlignAngle(GetAlignAngle()+nAngle);
+    }
+    // rotate exit directions
+    SdrEscapeDirection nEscDir0=nEscDir;
+    SdrEscapeDirection nEscDir1=SdrEscapeDirection::SMART;
+    if (nEscDir0&SdrEscapeDirection::LEFT  ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::LEFT  )+nAngle);
+    if (nEscDir0&SdrEscapeDirection::TOP   ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::TOP   )+nAngle);
+    if (nEscDir0&SdrEscapeDirection::RIGHT ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::RIGHT )+nAngle);
+    if (nEscDir0&SdrEscapeDirection::BOTTOM) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::BOTTOM)+nAngle);
+    nEscDir=nEscDir1;
+    if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt);
+}
+
+void SdrGluePoint::Mirror(const Point& rRef1, const Point& rRef2, Degree100 nAngle, const SdrObject* pObj)
+{
+    Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos());
+    MirrorPoint(aPt,rRef1,rRef2);
+    // mirror reference edge
+    if(nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
+    {
+        Degree100 nAW=GetAlignAngle();
+        nAW+=2_deg100*(nAngle-nAW);
+        SetAlignAngle(nAW);
+    }
+    // mirror exit directions
+    SdrEscapeDirection nEscDir0=nEscDir;
+    SdrEscapeDirection nEscDir1=SdrEscapeDirection::SMART;
+    if (nEscDir0&SdrEscapeDirection::LEFT) {
+        Degree100 nEW=EscDirToAngle(SdrEscapeDirection::LEFT);
+        nEW+=2_deg100*(nAngle-nEW);
+        nEscDir1|=EscAngleToDir(nEW);
+    }
+    if (nEscDir0&SdrEscapeDirection::TOP) {
+        Degree100 nEW=EscDirToAngle(SdrEscapeDirection::TOP);
+        nEW+=2_deg100*(nAngle-nEW);
+        nEscDir1|=EscAngleToDir(nEW);
+    }
+    if (nEscDir0&SdrEscapeDirection::RIGHT) {
+        Degree100 nEW=EscDirToAngle(SdrEscapeDirection::RIGHT);
+        nEW+=2_deg100*(nAngle-nEW);
+        nEscDir1|=EscAngleToDir(nEW);
+    }
+    if (nEscDir0&SdrEscapeDirection::BOTTOM) {
+        Degree100 nEW=EscDirToAngle(SdrEscapeDirection::BOTTOM);
+        nEW+=2_deg100*(nAngle-nEW);
+        nEscDir1|=EscAngleToDir(nEW);
+    }
+    nEscDir=nEscDir1;
+    if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt);
+}
+
+void SdrGluePoint::Shear(const Point& rRef, double tn, bool bVShear, const SdrObject* pObj)
+{
+    Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos());
+    ShearPoint(aPt,rRef,tn,bVShear);
+    if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt);
+}
+
+void SdrGluePoint::Invalidate(vcl::Window& rWin, const SdrObject* pObj) const
+{
+    if (comphelper::LibreOfficeKit::isActive())
+        return;
+    bool bMapMode=rWin.IsMapModeEnabled();
+    Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos());
+    aPt=rWin.LogicToPixel(aPt);
+    rWin.EnableMapMode(false);
+
+    Size aSiz( aGlueHalfSize );
+    tools::Rectangle aRect(aPt.X()-aSiz.Width(),aPt.Y()-aSiz.Height(),
+                    aPt.X()+aSiz.Width(),aPt.Y()+aSiz.Height());
+
+    // do not erase background, that causes flicker (!)
+    rWin.Invalidate(aRect, InvalidateFlags::NoErase);
+
+    rWin.EnableMapMode(bMapMode);
+}
+
+bool SdrGluePoint::IsHit(const Point& rPnt, const OutputDevice& rOut, const SdrObject* pObj) const
+{
+    Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos());
+    Size aSiz=rOut.PixelToLogic(aGlueHalfSize);
+    tools::Rectangle aRect(aPt.X()-aSiz.Width(),aPt.Y()-aSiz.Height(),aPt.X()+aSiz.Width(),aPt.Y()+aSiz.Height());
+    return aRect.Contains(rPnt);
+}
+
+
+SdrGluePointList& SdrGluePointList::operator=(const SdrGluePointList& rSrcList)
+{
+    if (GetCount()!=0) aList.clear();
+    sal_uInt16 nCount=rSrcList.GetCount();
+    for (sal_uInt16 i=0; i<nCount; i++) {
+        Insert(rSrcList[i]);
+    }
+    return *this;
+}
+
+// The ID's of the gluepoints always increase monotonously!
+// If an ID is taken already, the new gluepoint gets a new ID. ID 0 is reserved.
+sal_uInt16 SdrGluePointList::Insert(const SdrGluePoint& rGP)
+{
+    SdrGluePoint aGP(rGP);
+    sal_uInt16 nId=aGP.GetId();
+    sal_uInt16 nCount=GetCount();
+    sal_uInt16 nInsPos=nCount;
+    sal_uInt16 nLastId=nCount!=0 ? aList[nCount-1].GetId() : 0;
+    DBG_ASSERT(nLastId>=nCount,"SdrGluePointList::Insert(): nLastId<nCount");
+    bool bHole = nLastId>nCount;
+    if (nId<=nLastId) {
+        if (!bHole || nId==0) {
+            nId=nLastId+1;
+        } else {
+            bool bBrk = false;
+            for (sal_uInt16 nNum=0; nNum<nCount && !bBrk; nNum++) {
+                const auto& pGP2=aList[nNum];
+                sal_uInt16 nTmpId=pGP2.GetId();
+                if (nTmpId==nId) {
+                    nId=nLastId+1; // already in use
+                    bBrk = true;
+                }
+                if (nTmpId>nId) {
+                    nInsPos=nNum; // insert here (sort)
+                    bBrk = true;
+                }
+            }
+        }
+        aGP.SetId(nId);
+    }
+    aList.emplace(aList.begin()+nInsPos, aGP);
+    return nInsPos;
+}
+
+void SdrGluePointList::Invalidate(vcl::Window& rWin, const SdrObject* pObj) const
+{
+    if (comphelper::LibreOfficeKit::isActive())
+        return;
+    for (auto& xGP : aList)
+        xGP.Invalidate(rWin,pObj);
+}
+
+sal_uInt16 SdrGluePointList::FindGluePoint(sal_uInt16 nId) const
+{
+    // TODO: Implement a better search algorithm
+    // List should be sorted at all times!
+    sal_uInt16 nCount=GetCount();
+    sal_uInt16 nRet=SDRGLUEPOINT_NOTFOUND;
+    for (sal_uInt16 nNum=0; nNum<nCount && nRet==SDRGLUEPOINT_NOTFOUND; nNum++) {
+        const auto& pGP=aList[nNum];
+        if (pGP.GetId()==nId) nRet=nNum;
+    }
+    return nRet;
+}
+
+sal_uInt16 SdrGluePointList::HitTest(const Point& rPnt, const OutputDevice& rOut, const SdrObject* pObj) const
+{
+    sal_uInt16 nCount = GetCount();
+    sal_uInt16 nRet = SDRGLUEPOINT_NOTFOUND;
+    sal_uInt16 nNum = nCount;
+    while ((nNum>0) && nRet==SDRGLUEPOINT_NOTFOUND) {
+        nNum--;
+        const auto& pGP = aList[nNum];
+        if (pGP.IsHit(rPnt,rOut,pObj))
+            nRet = nNum;
+    }
+    return nRet;
+}
+
+void SdrGluePointList::SetReallyAbsolute(bool bOn, const SdrObject& rObj)
+{
+    for (auto& xGP : aList)
+        xGP.SetReallyAbsolute(bOn,rObj);
+}
+
+void SdrGluePointList::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs, const SdrObject* pObj)
+{
+    for (auto& xGP : aList)
+        xGP.Rotate(rRef,nAngle,sn,cs,pObj);
+}
+
+void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, const SdrObject* pObj)
+{
+    Point aPt(rRef2); aPt-=rRef1;
+    Degree100 nAngle=GetAngle(aPt);
+    Mirror(rRef1,rRef2,nAngle,pObj);
+}
+
+void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, Degree100 nAngle, const SdrObject* pObj)
+{
+    for (auto& xGP : aList)
+        xGP.Mirror(rRef1,rRef2,nAngle,pObj);
+}
+
+void SdrGluePointList::Shear(const Point& rRef, double tn, bool bVShear, const SdrObject* pObj)
+{
+    for (auto& xGP : aList)
+        xGP.Shear(rRef,tn,bVShear,pObj);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */