Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <svx/svdglev.hxx>
      22             : #include <math.h>
      23             : 
      24             : #include <svx/svdundo.hxx>
      25             : #include "svx/svdstr.hrc"
      26             : #include "svdglob.hxx"
      27             : #include <svx/svdpagv.hxx>
      28             : #include <svx/svdglue.hxx>
      29             : #include <svx/svdtrans.hxx>
      30             : #include <svx/svdobj.hxx>
      31             : 
      32             : 
      33             : 
      34        9504 : SdrGlueEditView::SdrGlueEditView(SdrModel* pModel1, OutputDevice* pOut):
      35        9504 :     SdrPolyEditView(pModel1,pOut)
      36             : {
      37        9504 : }
      38             : 
      39        9438 : SdrGlueEditView::~SdrGlueEditView()
      40             : {
      41        9438 : }
      42             : 
      43             : 
      44             : 
      45         855 : void SdrGlueEditView::ImpDoMarkedGluePoints(PGlueDoFunc pDoFunc, bool bConst, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5)
      46             : {
      47         855 :     const size_t nMarkCount=GetMarkedObjectCount();
      48         855 :     for (size_t nm=0; nm<nMarkCount; ++nm) {
      49           0 :         SdrMark* pM=GetSdrMarkByIndex(nm);
      50           0 :         SdrObject* pObj=pM->GetMarkedSdrObj();
      51           0 :         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
      52           0 :         sal_uIntPtr nPointCount=pPts==NULL ? 0 : pPts->size();
      53           0 :         if (nPointCount!=0) {
      54           0 :             SdrGluePointList* pGPL=NULL;
      55           0 :             if (bConst) {
      56           0 :                 const SdrGluePointList* pConstGPL=pObj->GetGluePointList();
      57           0 :                 pGPL=const_cast<SdrGluePointList*>(pConstGPL);
      58             :             } else {
      59           0 :                 pGPL=pObj->ForceGluePointList();
      60             :             }
      61           0 :             if (pGPL!=NULL)
      62             :             {
      63           0 :                 if(!bConst && IsUndoEnabled() )
      64           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
      65             : 
      66           0 :                 for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); ++it)
      67             :                 {
      68           0 :                     sal_uInt16 nPtId=*it;
      69           0 :                     sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId);
      70           0 :                     if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND)
      71             :                     {
      72           0 :                         SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
      73           0 :                         (*pDoFunc)(rGP,pObj,p1,p2,p3,p4,p5);
      74             :                     }
      75             :                 }
      76           0 :                 if (!bConst)
      77             :                 {
      78           0 :                     pObj->SetChanged();
      79           0 :                     pObj->BroadcastObjectChange();
      80             :                 }
      81             :             }
      82             :         }
      83             :     }
      84         855 :     if (!bConst && nMarkCount!=0) pMod->SetChanged();
      85         855 : }
      86             : 
      87             : 
      88             : 
      89           0 : static void ImpGetEscDir(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnThisEsc, const void* pnRet, const void*, const void*)
      90             : {
      91           0 :     sal_uInt16& nRet=*const_cast<sal_uInt16 *>(static_cast<sal_uInt16 const *>(pnRet));
      92           0 :     if (nRet!=FUZZY) {
      93           0 :         SdrEscapeDirection nEsc = rGP.GetEscDir();
      94           0 :         bool bOn = bool(nEsc & *static_cast<SdrEscapeDirection const *>(pnThisEsc));
      95           0 :         bool& bFirst=*const_cast<bool *>(static_cast<bool const *>(pbFirst));
      96           0 :         if (bFirst) {
      97           0 :             nRet = bOn ? 1 : 0;
      98           0 :             bFirst = false;
      99             :         }
     100           0 :         else if (nRet != (bOn ? 1 : 0)) nRet=FUZZY;
     101             :     }
     102           0 : }
     103             : 
     104         684 : SDR_TRISTATE SdrGlueEditView::IsMarkedGluePointsEscDir(SdrEscapeDirection nThisEsc) const
     105             : {
     106         684 :     ForceUndirtyMrkPnt();
     107         684 :     bool bFirst=true;
     108         684 :     sal_uInt16 nRet=0;
     109         684 :     const_cast<SdrGlueEditView*>(this)->ImpDoMarkedGluePoints(ImpGetEscDir,true,&bFirst,&nThisEsc,&nRet);
     110         684 :     return (SDR_TRISTATE)nRet;
     111             : }
     112             : 
     113           0 : static void ImpSetEscDir(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pnThisEsc, const void* pbOn, const void*, const void*, const void*)
     114             : {
     115           0 :     SdrEscapeDirection nEsc=rGP.GetEscDir();
     116           0 :     if (*static_cast<bool const *>(pbOn))
     117           0 :         nEsc |= *static_cast<SdrEscapeDirection const *>(pnThisEsc);
     118             :     else
     119           0 :         nEsc &= ~*static_cast<SdrEscapeDirection const *>(pnThisEsc);
     120           0 :     rGP.SetEscDir(nEsc);
     121           0 : }
     122             : 
     123           0 : void SdrGlueEditView::SetMarkedGluePointsEscDir(SdrEscapeDirection nThisEsc, bool bOn)
     124             : {
     125           0 :     ForceUndirtyMrkPnt();
     126           0 :     BegUndo(ImpGetResStr(STR_EditSetGlueEscDir),GetDescriptionOfMarkedGluePoints());
     127           0 :     ImpDoMarkedGluePoints(ImpSetEscDir,false,&nThisEsc,&bOn);
     128           0 :     EndUndo();
     129           0 : }
     130             : 
     131             : 
     132             : 
     133           0 : static void ImpGetPercent(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnRet, const void*, const void*, const void*)
     134             : {
     135           0 :     sal_uInt16& nRet=*const_cast<sal_uInt16 *>(static_cast<sal_uInt16 const *>(pnRet));
     136           0 :     if (nRet!=FUZZY) {
     137           0 :         bool bOn=rGP.IsPercent();
     138           0 :         bool& bFirst=*const_cast<bool *>(static_cast<bool const *>(pbFirst));
     139           0 :         if (bFirst) { nRet=sal_uInt16(bOn); bFirst=false; }
     140           0 :         else if ((nRet!=0)!=bOn) nRet=FUZZY;
     141             :     }
     142           0 : }
     143             : 
     144         171 : SDR_TRISTATE SdrGlueEditView::IsMarkedGluePointsPercent() const
     145             : {
     146         171 :     ForceUndirtyMrkPnt();
     147         171 :     bool bFirst=true;
     148         171 :     sal_uInt16 nRet=sal_uInt16(true);
     149         171 :     const_cast<SdrGlueEditView*>(this)->ImpDoMarkedGluePoints(ImpGetPercent,true,&bFirst,&nRet);
     150         171 :     return (SDR_TRISTATE)nRet;
     151             : }
     152             : 
     153           0 : static void ImpSetPercent(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbOn, const void*, const void*, const void*, const void*)
     154             : {
     155           0 :     Point aPos(rGP.GetAbsolutePos(*pObj));
     156           0 :     rGP.SetPercent(*static_cast<bool const *>(pbOn));
     157           0 :     rGP.SetAbsolutePos(aPos,*pObj);
     158           0 : }
     159             : 
     160           0 : void SdrGlueEditView::SetMarkedGluePointsPercent(bool bOn)
     161             : {
     162           0 :     ForceUndirtyMrkPnt();
     163           0 :     BegUndo(ImpGetResStr(STR_EditSetGluePercent),GetDescriptionOfMarkedGluePoints());
     164           0 :     ImpDoMarkedGluePoints(ImpSetPercent,false,&bOn);
     165           0 :     EndUndo();
     166           0 : }
     167             : 
     168             : 
     169             : 
     170           0 : static void ImpGetAlign(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pbDontCare, const void* pbVert, const void* pnRet, const void*)
     171             : {
     172           0 :     SdrAlign& nRet=*const_cast<SdrAlign *>(static_cast<SdrAlign const *>(pnRet));
     173           0 :     bool& bDontCare=*const_cast<bool *>(static_cast<bool const *>(pbDontCare));
     174           0 :     bool bVert=*static_cast<bool const *>(pbVert);
     175           0 :     if (!bDontCare) {
     176           0 :         SdrAlign nAlg=SdrAlign::NONE;
     177           0 :         if (bVert) {
     178           0 :             nAlg=rGP.GetVertAlign();
     179             :         } else {
     180           0 :             nAlg=rGP.GetHorzAlign();
     181             :         }
     182           0 :         bool& bFirst=*const_cast<bool *>(static_cast<bool const *>(pbFirst));
     183           0 :         if (bFirst) { nRet=nAlg; bFirst=false; }
     184           0 :         else if (nRet!=nAlg) {
     185           0 :             if (bVert) {
     186           0 :                 nRet=SdrAlign::VERT_DONTCARE;
     187             :             } else {
     188           0 :                 nRet=SdrAlign::HORZ_DONTCARE;
     189             :             }
     190           0 :             bDontCare=true;
     191             :         }
     192             :     }
     193           0 : }
     194             : 
     195           0 : SdrAlign SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const
     196             : {
     197           0 :     ForceUndirtyMrkPnt();
     198           0 :     bool bFirst=true;
     199           0 :     bool bDontCare=false;
     200           0 :     SdrAlign nRet=SdrAlign::NONE;
     201           0 :     const_cast<SdrGlueEditView*>(this)->ImpDoMarkedGluePoints(ImpGetAlign,true,&bFirst,&bDontCare,&bVert,&nRet);
     202           0 :     return nRet;
     203             : }
     204             : 
     205           0 : static void ImpSetAlign(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbVert, const void* pnAlign, const void*, const void*, const void*)
     206             : {
     207           0 :     Point aPos(rGP.GetAbsolutePos(*pObj));
     208           0 :     if (*static_cast<bool const *>(pbVert)) { // bVert?
     209           0 :         rGP.SetVertAlign(*static_cast<SdrAlign const *>(pnAlign));
     210             :     } else {
     211           0 :         rGP.SetHorzAlign(*static_cast<SdrAlign const *>(pnAlign));
     212             :     }
     213           0 :     rGP.SetAbsolutePos(aPos,*pObj);
     214           0 : }
     215             : 
     216           0 : void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, SdrAlign nAlign)
     217             : {
     218           0 :     ForceUndirtyMrkPnt();
     219           0 :     BegUndo(ImpGetResStr(STR_EditSetGlueAlign),GetDescriptionOfMarkedGluePoints());
     220           0 :     ImpDoMarkedGluePoints(ImpSetAlign,false,&bVert,&nAlign);
     221           0 :     EndUndo();
     222           0 : }
     223             : 
     224           0 : void SdrGlueEditView::DeleteMarkedGluePoints()
     225             : {
     226           0 :     BrkAction();
     227           0 :     ForceUndirtyMrkPnt();
     228           0 :     const bool bUndo = IsUndoEnabled();
     229           0 :     if( bUndo )
     230           0 :         BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedGluePoints(),SDRREPFUNC_OBJ_DELETE);
     231             : 
     232           0 :     const size_t nMarkCount=GetMarkedObjectCount();
     233           0 :     for (size_t nm=0; nm<nMarkCount; ++nm)
     234             :     {
     235           0 :         SdrMark* pM=GetSdrMarkByIndex(nm);
     236           0 :         SdrObject* pObj=pM->GetMarkedSdrObj();
     237           0 :         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     238           0 :         sal_uIntPtr nPointCount=pPts==NULL ? 0 : pPts->size();
     239           0 :         if (nPointCount!=0)
     240             :         {
     241           0 :             SdrGluePointList* pGPL=pObj->ForceGluePointList();
     242           0 :             if (pGPL!=NULL)
     243             :             {
     244           0 :                 if( bUndo )
     245           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
     246             : 
     247           0 :                 for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); ++it)
     248             :                 {
     249           0 :                     sal_uInt16 nPtId=*it;
     250           0 :                     sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId);
     251           0 :                     if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND)
     252             :                     {
     253           0 :                         pGPL->Delete(nGlueIdx);
     254             :                     }
     255             :                 }
     256           0 :                 pObj->SetChanged();
     257           0 :                 pObj->BroadcastObjectChange();
     258             :             }
     259             :         }
     260             :     }
     261           0 :     if( bUndo )
     262           0 :         EndUndo();
     263           0 :     UnmarkAllGluePoints();
     264           0 :     if (nMarkCount!=0)
     265           0 :         pMod->SetChanged();
     266           0 : }
     267             : 
     268             : 
     269             : 
     270           0 : void SdrGlueEditView::ImpCopyMarkedGluePoints()
     271             : {
     272           0 :     const bool bUndo = IsUndoEnabled();
     273             : 
     274           0 :     if( bUndo )
     275           0 :         BegUndo();
     276             : 
     277           0 :     const size_t nMarkCount=GetMarkedObjectCount();
     278           0 :     for (size_t nm=0; nm<nMarkCount; ++nm)
     279             :     {
     280           0 :         SdrMark* pM=GetSdrMarkByIndex(nm);
     281           0 :         SdrObject* pObj=pM->GetMarkedSdrObj();
     282           0 :         SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     283           0 :         SdrGluePointList* pGPL=pObj->ForceGluePointList();
     284           0 :         sal_uIntPtr nPointCount=pPts==NULL ? 0 : pPts->size();
     285           0 :         if (nPointCount!=0 && pGPL!=NULL)
     286             :         {
     287           0 :             if( bUndo )
     288           0 :                 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
     289             : 
     290           0 :             SdrUShortCont aIdsToErase;
     291           0 :             SdrUShortCont aIdsToInsert;
     292           0 :             for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); ++it)
     293             :             {
     294           0 :                 sal_uInt16 nPtId=*it;
     295           0 :                 sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId);
     296           0 :                 if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND)
     297             :                 {
     298           0 :                     SdrGluePoint aNewGP((*pGPL)[nGlueIdx]);  // clone GluePoint
     299           0 :                     sal_uInt16 nNewIdx=pGPL->Insert(aNewGP);     // and insert it
     300           0 :                     sal_uInt16 nNewId=(*pGPL)[nNewIdx].GetId();  // retrieve ID of new GluePoints
     301           0 :                     aIdsToErase.insert(nPtId);               // select it (instead of the old one)
     302           0 :                     aIdsToInsert.insert(nNewId);
     303             :                 }
     304             :             }
     305           0 :             for(SdrUShortCont::const_iterator it = aIdsToErase.begin(); it != aIdsToErase.end(); ++it)
     306           0 :                 pPts->erase(*it);
     307           0 :             pPts->insert(aIdsToInsert.begin(), aIdsToInsert.end());
     308             : 
     309             :         }
     310             :     }
     311           0 :     if( bUndo )
     312           0 :         EndUndo();
     313             : 
     314           0 :     if (nMarkCount!=0)
     315           0 :         pMod->SetChanged();
     316           0 : }
     317             : 
     318             : 
     319             : 
     320           0 : void SdrGlueEditView::ImpTransformMarkedGluePoints(PGlueTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5)
     321             : {
     322           0 :     const size_t nMarkCount=GetMarkedObjectCount();
     323           0 :     for (size_t nm=0; nm<nMarkCount; ++nm) {
     324           0 :         SdrMark* pM=GetSdrMarkByIndex(nm);
     325           0 :         SdrObject* pObj=pM->GetMarkedSdrObj();
     326           0 :         const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
     327           0 :         sal_uIntPtr nPointCount=pPts==NULL ? 0 : pPts->size();
     328           0 :         if (nPointCount!=0) {
     329           0 :             SdrGluePointList* pGPL=pObj->ForceGluePointList();
     330           0 :             if (pGPL!=NULL)
     331             :             {
     332           0 :                 if( IsUndoEnabled() )
     333           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
     334             : 
     335           0 :                 for(SdrUShortCont::const_iterator it = pPts->begin(); it != pPts->end(); ++it)
     336             :                 {
     337           0 :                     sal_uInt16 nPtId=*it;
     338           0 :                     sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId);
     339           0 :                     if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND) {
     340           0 :                         SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
     341           0 :                         Point aPos(rGP.GetAbsolutePos(*pObj));
     342           0 :                         (*pTrFunc)(aPos,p1,p2,p3,p4,p5);
     343           0 :                         rGP.SetAbsolutePos(aPos,*pObj);
     344             :                     }
     345             :                 }
     346           0 :                 pObj->SetChanged();
     347           0 :                 pObj->BroadcastObjectChange();
     348             :             }
     349             :         }
     350             :     }
     351           0 :     if (nMarkCount!=0) pMod->SetChanged();
     352           0 : }
     353             : 
     354             : 
     355             : 
     356           0 : static void ImpMove(Point& rPt, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/)
     357             : {
     358           0 :     rPt.X()+=static_cast<const Size*>(p1)->Width();
     359           0 :     rPt.Y()+=static_cast<const Size*>(p1)->Height();
     360           0 : }
     361             : 
     362           0 : void SdrGlueEditView::MoveMarkedGluePoints(const Size& rSiz, bool bCopy)
     363             : {
     364           0 :     ForceUndirtyMrkPnt();
     365           0 :     OUString aStr(ImpGetResStr(STR_EditMove));
     366           0 :     if (bCopy) aStr += ImpGetResStr(STR_EditWithCopy);
     367           0 :     BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SDRREPFUNC_OBJ_MOVE);
     368           0 :     if (bCopy) ImpCopyMarkedGluePoints();
     369           0 :     ImpTransformMarkedGluePoints(ImpMove,&rSiz);
     370           0 :     EndUndo();
     371           0 :     AdjustMarkHdl();
     372           0 : }
     373             : 
     374             : 
     375             : 
     376           0 : static void ImpResize(Point& rPt, const void* p1, const void* p2, const void* p3, const void* /*p4*/, const void* /*p5*/)
     377             : {
     378           0 :     ResizePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
     379           0 : }
     380             : 
     381           0 : void SdrGlueEditView::ResizeMarkedGluePoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy)
     382             : {
     383           0 :     ForceUndirtyMrkPnt();
     384           0 :     OUString aStr(ImpGetResStr(STR_EditResize));
     385           0 :     if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
     386           0 :     BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SDRREPFUNC_OBJ_RESIZE);
     387           0 :     if (bCopy) ImpCopyMarkedGluePoints();
     388           0 :     ImpTransformMarkedGluePoints(ImpResize,&rRef,&xFact,&yFact);
     389           0 :     EndUndo();
     390           0 :     AdjustMarkHdl();
     391           0 : }
     392             : 
     393             : 
     394             : 
     395           0 : static void ImpRotate(Point& rPt, const void* p1, const void* /*p2*/, const void* p3, const void* p4, const void* /*p5*/)
     396             : {
     397           0 :     RotatePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
     398           0 : }
     399             : 
     400           0 : void SdrGlueEditView::RotateMarkedGluePoints(const Point& rRef, long nAngle, bool bCopy)
     401             : {
     402           0 :     ForceUndirtyMrkPnt();
     403           0 :     OUString aStr(ImpGetResStr(STR_EditRotate));
     404           0 :     if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy);
     405           0 :     BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SDRREPFUNC_OBJ_ROTATE);
     406           0 :     if (bCopy) ImpCopyMarkedGluePoints();
     407           0 :     double nSin=sin(nAngle*nPi180);
     408           0 :     double nCos=cos(nAngle*nPi180);
     409           0 :     ImpTransformMarkedGluePoints(ImpRotate,&rRef,&nAngle,&nSin,&nCos);
     410           0 :     EndUndo();
     411           0 :     AdjustMarkHdl();
     412         435 : }
     413             : 
     414             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */