diff options
Diffstat (limited to 'svx/source/svdraw/svdmrkv.cxx')
| -rw-r--r-- | svx/source/svdraw/svdmrkv.cxx | 2735 |
1 files changed, 2735 insertions, 0 deletions
diff --git a/svx/source/svdraw/svdmrkv.cxx b/svx/source/svdraw/svdmrkv.cxx new file mode 100644 index 0000000000..b0784449f1 --- /dev/null +++ b/svx/source/svdraw/svdmrkv.cxx @@ -0,0 +1,2735 @@ +/* -*- 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 <svx/svdmrkv.hxx> +#include <svx/svdview.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdotable.hxx> +#include <svx/svdomedia.hxx> + +#include <osl/diagnose.h> +#include <osl/thread.h> +#include <rtl/strbuf.hxx> +#include <svx/svdoole2.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflgrit.hxx> +#include "gradtrns.hxx" +#include <svx/xflftrit.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/svdundo.hxx> +#include <svx/svdopath.hxx> +#include <svx/scene3d.hxx> +#include <svx/svdovirt.hxx> +#include <sdr/overlay/overlayrollingrectangle.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <svx/sdr/overlay/overlayselection.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/sdrhittesthelper.hxx> +#include <vcl/uitest/logger.hxx> +#include <vcl/uitest/eventdescription.hxx> +#include <vcl/window.hxx> +#include <o3tl/string_view.hxx> + +#include <LibreOfficeKit/LibreOfficeKitEnums.h> +#include <comphelper/lok.hxx> +#include <sfx2/lokhelper.hxx> +#include <sfx2/lokcomponenthelpers.hxx> +#include <sfx2/viewsh.hxx> +#include <svtools/optionsdrawinglayer.hxx> + +#include <array> + +#include <com/sun/star/frame/XController.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> + +#include <boost/property_tree/json_parser.hpp> + +using namespace com::sun::star; + +// Migrate Marking of Objects, Points and GluePoints + +class ImplMarkingOverlay +{ + // The OverlayObjects + sdr::overlay::OverlayObjectList maObjects; + + // The remembered second position in logical coordinates + basegfx::B2DPoint maSecondPosition; + + // A flag to remember if the action is for unmarking. + bool mbUnmarking : 1; + +public: + ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, bool bUnmarking); + + // The OverlayObjects are cleared using the destructor of OverlayObjectList. + // That destructor calls clear() at the list which removes all objects from the + // OverlayManager and deletes them. + + void SetSecondPosition(const basegfx::B2DPoint& rNewPosition); + bool IsUnmarking() const { return mbUnmarking; } +}; + +ImplMarkingOverlay::ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, bool bUnmarking) +: maSecondPosition(rStartPos), + mbUnmarking(bUnmarking) +{ + if (comphelper::LibreOfficeKit::isActive()) + return; // We do client-side object manipulation with the Kit API + + for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++) + { + SdrPaintWindow* pCandidate = rView.GetPaintWindow(a); + const rtl::Reference< sdr::overlay::OverlayManager >& xTargetOverlay = pCandidate->GetOverlayManager(); + + if (xTargetOverlay.is()) + { + std::unique_ptr<sdr::overlay::OverlayRollingRectangleStriped> pNew(new sdr::overlay::OverlayRollingRectangleStriped( + rStartPos, rStartPos, false)); + xTargetOverlay->add(*pNew); + maObjects.append(std::move(pNew)); + } + } +} + +void ImplMarkingOverlay::SetSecondPosition(const basegfx::B2DPoint& rNewPosition) +{ + if(rNewPosition != maSecondPosition) + { + // apply to OverlayObjects + for(sal_uInt32 a(0); a < maObjects.count(); a++) + { + sdr::overlay::OverlayRollingRectangleStriped& rCandidate = static_cast< sdr::overlay::OverlayRollingRectangleStriped&>(maObjects.getOverlayObject(a)); + rCandidate.setSecondPosition(rNewPosition); + } + + // remember new position + maSecondPosition = rNewPosition; + } +} + +class MarkingSubSelectionOverlay +{ + sdr::overlay::OverlayObjectList maObjects; + +public: + MarkingSubSelectionOverlay(const SdrPaintView& rView, std::vector<basegfx::B2DRectangle> const & rSelections) + { + if (comphelper::LibreOfficeKit::isActive()) + return; // We do client-side object manipulation with the Kit API + + for (sal_uInt32 a(0); a < rView.PaintWindowCount(); a++) + { + SdrPaintWindow* pCandidate = rView.GetPaintWindow(a); + const rtl::Reference<sdr::overlay::OverlayManager>& xTargetOverlay = pCandidate->GetOverlayManager(); + + if (xTargetOverlay.is()) + { + const Color aHighlightColor = SvtOptionsDrawinglayer::getHilightColor(); + + std::unique_ptr<sdr::overlay::OverlaySelection> pNew = + std::make_unique<sdr::overlay::OverlaySelection>( + sdr::overlay::OverlayType::Transparent, + aHighlightColor, std::vector(rSelections), false); + + xTargetOverlay->add(*pNew); + maObjects.append(std::move(pNew)); + } + } + } +}; + +SdrMarkView::SdrMarkView(SdrModel& rSdrModel, OutputDevice* pOut) + : SdrSnapView(rSdrModel, pOut) + , mpMarkedObj(nullptr) + , mpMarkedPV(nullptr) + , maHdlList(this) + , meDragMode(SdrDragMode::Move) + , meEditMode(SdrViewEditMode::Edit) + , meEditMode0(SdrViewEditMode::Edit) + , mbDesignMode(false) + , mbForceFrameHandles(false) + , mbPlusHdlAlways(false) + , mbInsPolyPoint(false) + , mbMarkedObjRectDirty(false) + , mbMrkPntDirty(false) + , mbMarkedPointsRectsDirty(false) + , mbMarkHandlesHidden(false) + , mbNegativeX(false) +{ + + BrkMarkObj(); + BrkMarkPoints(); + BrkMarkGluePoints(); + + StartListening(rSdrModel); +} + +SdrMarkView::~SdrMarkView() +{ + // Migrate selections + BrkMarkObj(); + BrkMarkPoints(); + BrkMarkGluePoints(); +} + +void SdrMarkView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint); + SdrHintKind eKind=pSdrHint->GetKind(); + if (eKind==SdrHintKind::ObjectChange || eKind==SdrHintKind::ObjectInserted || eKind==SdrHintKind::ObjectRemoved) + { + mbMarkedObjRectDirty=true; + mbMarkedPointsRectsDirty=true; + } + } + SdrSnapView::Notify(rBC,rHint); +} + +void SdrMarkView::ModelHasChanged() +{ + SdrPaintView::ModelHasChanged(); + GetMarkedObjectListWriteAccess().SetNameDirty(); + mbMarkedObjRectDirty=true; + mbMarkedPointsRectsDirty=true; + // Example: Obj is selected and maMarkedObjectList is sorted. + // In another View 2, the ObjOrder is changed (e. g. MovToTop()) + // Then we need to re-sort MarkList. + GetMarkedObjectListWriteAccess().SetUnsorted(); + SortMarkedObjects(); + mbMrkPntDirty=true; + UndirtyMrkPnt(); + SdrView* pV=static_cast<SdrView*>(this); + if (pV!=nullptr && !pV->IsDragObj() && !pV->IsInsObjPoint()) { + AdjustMarkHdl(); + } + + if (comphelper::LibreOfficeKit::isActive()) + modelHasChangedLOKit(); +} + +void SdrMarkView::modelHasChangedLOKit() +{ + if (GetMarkedObjectCount() <= 0) + return; + + //TODO: Is MarkedObjRect valid at this point? + tools::Rectangle aSelection(GetMarkedObjRect()); + tools::Rectangle* pResultSelection; + if (aSelection.IsEmpty()) + pResultSelection = nullptr; + else + { + sal_uInt32 nTotalPaintWindows = this->PaintWindowCount(); + if (nTotalPaintWindows == 1) + { + const OutputDevice* pOut = this->GetFirstOutputDevice(); + const vcl::Window* pWin = pOut ? pOut->GetOwnerWindow() : nullptr; + if (pWin && pWin->IsChart()) + { + const vcl::Window* pViewShellWindow = GetSfxViewShell()->GetEditWindowForActiveOLEObj(); + if (pViewShellWindow && pViewShellWindow->IsAncestorOf(*pWin)) + { + Point aOffsetPx = pWin->GetOffsetPixelFrom(*pViewShellWindow); + Point aLogicOffset = pWin->PixelToLogic(aOffsetPx); + aSelection.Move(aLogicOffset.getX(), aLogicOffset.getY()); + } + } + } + + // In case the map mode is in 100th MM, then need to convert the coordinates over to twips for LOK. + if (mpMarkedPV) + { + if (OutputDevice* pOutputDevice = mpMarkedPV->GetView().GetFirstOutputDevice()) + { + if (pOutputDevice->GetMapMode().GetMapUnit() == MapUnit::Map100thMM) + aSelection = o3tl::convert(aSelection, o3tl::Length::mm100, o3tl::Length::twip); + } + } + + pResultSelection = &aSelection; + + if (mbNegativeX) + { + // Convert to positive X doc-coordinates + tools::Long nTmp = aSelection.Left(); + aSelection.SetLeft(-aSelection.Right()); + aSelection.SetRight(-nTmp); + } + } + + if (SfxViewShell* pViewShell = GetSfxViewShell()) + SfxLokHelper::notifyInvalidation(pViewShell, pResultSelection); +} + +bool SdrMarkView::IsAction() const +{ + return SdrSnapView::IsAction() || IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); +} + +void SdrMarkView::MovAction(const Point& rPnt) +{ + SdrSnapView::MovAction(rPnt); + + if(IsMarkObj()) + { + MovMarkObj(rPnt); + } + else if(IsMarkPoints()) + { + MovMarkPoints(rPnt); + } + else if(IsMarkGluePoints()) + { + MovMarkGluePoints(rPnt); + } +} + +void SdrMarkView::EndAction() +{ + if(IsMarkObj()) + { + EndMarkObj(); + } + else if(IsMarkPoints()) + { + EndMarkPoints(); + } + else if(IsMarkGluePoints()) + { + EndMarkGluePoints(); + } + + SdrSnapView::EndAction(); +} + +void SdrMarkView::BckAction() +{ + SdrSnapView::BckAction(); + BrkMarkObj(); + BrkMarkPoints(); + BrkMarkGluePoints(); +} + +void SdrMarkView::BrkAction() +{ + SdrSnapView::BrkAction(); + BrkMarkObj(); + BrkMarkPoints(); + BrkMarkGluePoints(); +} + +void SdrMarkView::TakeActionRect(tools::Rectangle& rRect) const +{ + if(IsMarkObj() || IsMarkPoints() || IsMarkGluePoints()) + { + rRect = tools::Rectangle(maDragStat.GetStart(), maDragStat.GetNow()); + } + else + { + SdrSnapView::TakeActionRect(rRect); + } +} + + +void SdrMarkView::ClearPageView() +{ + UnmarkAllObj(); + SdrSnapView::ClearPageView(); +} + +void SdrMarkView::HideSdrPage() +{ + bool bMrkChg(false); + + SdrPageView* pPageView = GetSdrPageView(); + if (pPageView) + { + // break all creation actions when hiding page (#75081#) + BrkAction(); + + // Discard all selections on this page + bMrkChg = GetMarkedObjectListWriteAccess().DeletePageView(*pPageView); + } + + SdrSnapView::HideSdrPage(); + + if(bMrkChg) + { + MarkListHasChanged(); + AdjustMarkHdl(); + } +} + + +void SdrMarkView::BegMarkObj(const Point& rPnt, bool bUnmark) +{ + BrkAction(); + + DBG_ASSERT(!mpMarkObjOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkObjOverlay (!)"); + + basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); + mpMarkObjOverlay.reset(new ImplMarkingOverlay(*this, aStartPos, bUnmark)); + + maDragStat.Reset(rPnt); + maDragStat.NextPoint(); + maDragStat.SetMinMove(mnMinMovLog); +} + +void SdrMarkView::MovMarkObj(const Point& rPnt) +{ + if(IsMarkObj() && maDragStat.CheckMinMoved(rPnt)) + { + maDragStat.NextMove(rPnt); + DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); + mpMarkObjOverlay->SetSecondPosition(aNewPos); + } +} + +bool SdrMarkView::EndMarkObj() +{ + bool bRetval(false); + + if(IsMarkObj()) + { + if(maDragStat.IsMinMoved()) + { + tools::Rectangle aRect(maDragStat.GetStart(), maDragStat.GetNow()); + aRect.Normalize(); + MarkObj(aRect, mpMarkObjOverlay->IsUnmarking()); + bRetval = true; + } + + // cleanup + BrkMarkObj(); + } + + return bRetval; +} + +void SdrMarkView::BrkMarkObj() +{ + if(IsMarkObj()) + { + DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + mpMarkObjOverlay.reset(); + } +} + + +bool SdrMarkView::BegMarkPoints(const Point& rPnt, bool bUnmark) +{ + if(HasMarkablePoints()) + { + BrkAction(); + + DBG_ASSERT(!mpMarkPointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkPointsOverlay (!)"); + basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); + mpMarkPointsOverlay.reset(new ImplMarkingOverlay(*this, aStartPos, bUnmark)); + + maDragStat.Reset(rPnt); + maDragStat.NextPoint(); + maDragStat.SetMinMove(mnMinMovLog); + + return true; + } + + return false; +} + +void SdrMarkView::MovMarkPoints(const Point& rPnt) +{ + if(IsMarkPoints() && maDragStat.CheckMinMoved(rPnt)) + { + maDragStat.NextMove(rPnt); + + DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); + mpMarkPointsOverlay->SetSecondPosition(aNewPos); + } +} + +bool SdrMarkView::EndMarkPoints() +{ + bool bRetval(false); + + if(IsMarkPoints()) + { + if(maDragStat.IsMinMoved()) + { + tools::Rectangle aRect(maDragStat.GetStart(), maDragStat.GetNow()); + aRect.Normalize(); + MarkPoints(&aRect, mpMarkPointsOverlay->IsUnmarking()); + + bRetval = true; + } + + // cleanup + BrkMarkPoints(); + } + + return bRetval; +} + +void SdrMarkView::BrkMarkPoints() +{ + if(IsMarkPoints()) + { + DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + mpMarkPointsOverlay.reset(); + } +} + + +bool SdrMarkView::BegMarkGluePoints(const Point& rPnt, bool bUnmark) +{ + if(HasMarkableGluePoints()) + { + BrkAction(); + + DBG_ASSERT(!mpMarkGluePointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkGluePointsOverlay (!)"); + + basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); + mpMarkGluePointsOverlay.reset(new ImplMarkingOverlay(*this, aStartPos, bUnmark)); + maDragStat.Reset(rPnt); + maDragStat.NextPoint(); + maDragStat.SetMinMove(mnMinMovLog); + + return true; + } + + return false; +} + +void SdrMarkView::MovMarkGluePoints(const Point& rPnt) +{ + if(IsMarkGluePoints() && maDragStat.CheckMinMoved(rPnt)) + { + maDragStat.NextMove(rPnt); + + DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y()); + mpMarkGluePointsOverlay->SetSecondPosition(aNewPos); + } +} + +void SdrMarkView::EndMarkGluePoints() +{ + if(IsMarkGluePoints()) + { + if(maDragStat.IsMinMoved()) + { + tools::Rectangle aRect(maDragStat.GetStart(),maDragStat.GetNow()); + aRect.Normalize(); + MarkGluePoints(&aRect, mpMarkGluePointsOverlay->IsUnmarking()); + } + + // cleanup + BrkMarkGluePoints(); + } +} + +void SdrMarkView::BrkMarkGluePoints() +{ + if(IsMarkGluePoints()) + { + DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + mpMarkGluePointsOverlay.reset(); + } +} + +bool SdrMarkView::MarkableObjectsExceed( int n ) const +{ + SdrPageView* pPV = GetSdrPageView(); + if (!pPV) + return false; + + SdrObjList* pOL=pPV->GetObjList(); + for (const rtl::Reference<SdrObject>& pObj : *pOL) + if (IsObjMarkable(pObj.get(),pPV) && --n<0) + return true; + + return false; +} + +void SdrMarkView::hideMarkHandles() +{ + if(!mbMarkHandlesHidden) + { + mbMarkHandlesHidden = true; + AdjustMarkHdl(); + } +} + +void SdrMarkView::showMarkHandles() +{ + if(mbMarkHandlesHidden) + { + mbMarkHandlesHidden = false; + AdjustMarkHdl(); + } +} + +bool SdrMarkView::ImpIsFrameHandles() const +{ + const size_t nMarkCount=GetMarkedObjectCount(); + bool bFrmHdl=nMarkCount>static_cast<size_t>(mnFrameHandlesLimit) || mbForceFrameHandles; + bool bStdDrag=meDragMode==SdrDragMode::Move; + if (nMarkCount==1 && bStdDrag && bFrmHdl) + { + const SdrObject* pObj=GetMarkedObjectByIndex(0); + if (pObj && pObj->GetObjInventor()==SdrInventor::Default) + { + SdrObjKind nIdent=pObj->GetObjIdentifier(); + if (nIdent==SdrObjKind::Line || nIdent==SdrObjKind::Edge || nIdent==SdrObjKind::Caption || nIdent==SdrObjKind::Measure || nIdent==SdrObjKind::CustomShape || nIdent==SdrObjKind::Table ) + { + bFrmHdl=false; + } + } + } + if (!bStdDrag && !bFrmHdl) { + // all other drag modes only with FrameHandles + bFrmHdl=true; + if (meDragMode==SdrDragMode::Rotate) { + // when rotating, use ObjOwn drag, if there's at least 1 PolyObj + for (size_t nMarkNum=0; nMarkNum<nMarkCount && bFrmHdl; ++nMarkNum) { + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + const SdrObject* pObj=pM->GetMarkedSdrObj(); + bFrmHdl=!pObj->IsPolyObj(); + } + } + } + if (!bFrmHdl) { + // FrameHandles, if at least 1 Obj can't do SpecialDrag + for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bFrmHdl; ++nMarkNum) { + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + const SdrObject* pObj=pM->GetMarkedSdrObj(); + bFrmHdl=!pObj->hasSpecialDrag(); + } + } + + // no FrameHdl for crop + if(bFrmHdl && SdrDragMode::Crop == meDragMode) + { + bFrmHdl = false; + } + + return bFrmHdl; +} + +namespace +{ +std::u16string_view lcl_getDragMethodServiceName( std::u16string_view rCID ) +{ + std::u16string_view aRet; + + size_t nIndexStart = rCID.find( u"DragMethod=" ); + if( nIndexStart != std::u16string_view::npos ) + { + nIndexStart = rCID.find( '=', nIndexStart ); + if( nIndexStart != std::u16string_view::npos ) + { + nIndexStart++; + size_t nNextSlash = rCID.find( '/', nIndexStart ); + if( nNextSlash != std::u16string_view::npos ) + { + sal_Int32 nIndexEnd = nNextSlash; + size_t nNextColon = rCID.find( ':', nIndexStart ); + if( nNextColon == std::u16string_view::npos || nNextColon < nNextSlash ) + nIndexEnd = nNextColon; + aRet = rCID.substr(nIndexStart,nIndexEnd-nIndexStart); + } + } + } + return aRet; +} + +std::u16string_view lcl_getDragParameterString( std::u16string_view rCID ) +{ + std::u16string_view aRet; + + size_t nIndexStart = rCID.find( u"DragParameter=" ); + if( nIndexStart != std::u16string_view::npos ) + { + nIndexStart = rCID.find( '=', nIndexStart ); + if( nIndexStart != std::u16string_view::npos ) + { + nIndexStart++; + size_t nNextSlash = rCID.find( '/', nIndexStart ); + if( nNextSlash != std::u16string_view::npos ) + { + sal_Int32 nIndexEnd = nNextSlash; + size_t nNextColon = rCID.find( ':', nIndexStart ); + if( nNextColon == std::u16string_view::npos || nNextColon < nNextSlash ) + nIndexEnd = nNextColon; + aRet = rCID.substr(nIndexStart,nIndexEnd-nIndexStart); + } + } + } + return aRet; +} +} // anonymous namespace + +bool SdrMarkView::dumpGluePointsToJSON(boost::property_tree::ptree& rTree) +{ + bool result = false; + tools::Long nSignX = mbNegativeX ? -1 : 1; + if (OutputDevice* pOutDev = mpMarkedPV ? mpMarkedPV->GetView().GetFirstOutputDevice() : nullptr) + { + bool bConvertUnit = false; + if (pOutDev->GetMapMode().GetMapUnit() == MapUnit::Map100thMM) + bConvertUnit = true; + const SdrObjList* pOL = mpMarkedPV->GetObjList(); + if (!pOL) + return false; + boost::property_tree::ptree elements; + for (const rtl::Reference<SdrObject>& pObj : *pOL) + { + if (!pObj) + continue; + if (pObj == GetMarkedObjectByIndex(0)) + continue; + const SdrGluePointList* pGPL = pObj->GetGluePointList(); + bool VertexObject = !(pGPL && pGPL->GetCount()); + const size_t count = !VertexObject ? pGPL->GetCount() : 4; + boost::property_tree::ptree object; + boost::property_tree::ptree points; + for (size_t i = 0; i < count; ++i) + { + boost::property_tree::ptree node; + boost::property_tree::ptree point; + const SdrGluePoint& rGP = !VertexObject ? (*pGPL)[i] : pObj->GetVertexGluePoint(i); + Point rPoint = rGP.GetAbsolutePos(*pObj); + if (bConvertUnit) + { + rPoint = o3tl::convert(rPoint, o3tl::Length::mm100, o3tl::Length::twip); + } + point.put("x", nSignX * rPoint.getX()); + point.put("y", rPoint.getY()); + node.add_child("point", point); + points.push_back(std::make_pair("", node)); + } + basegfx::B2DVector aGridOffset(0.0, 0.0); + Point objLogicRectTopLeft = pObj->GetLogicRect().TopLeft(); + if(getPossibleGridOffsetForPosition(aGridOffset, basegfx::B2DPoint(objLogicRectTopLeft.X(), objLogicRectTopLeft.Y()), GetSdrPageView())) + { + Point p(aGridOffset.getX(), aGridOffset.getY()); + if (bConvertUnit) + { + p = o3tl::convert(p, o3tl::Length::mm100, o3tl::Length::twip); + } + boost::property_tree::ptree gridOffset; + gridOffset.put("x", nSignX * p.getX()); + gridOffset.put("y", p.getY()); + object.add_child("gridoffset", gridOffset); + } + object.put("ordnum", pObj->GetOrdNum()); + object.add_child("gluepoints", points); + elements.push_back(std::make_pair("", object)); + result = true; + } + rTree.add_child("shapes", elements); + } + return result; +} + +void SdrMarkView::SetMarkHandlesForLOKit(tools::Rectangle const & rRect, const SfxViewShell* pOtherShell) +{ + SfxViewShell* pViewShell = GetSfxViewShell(); + + tools::Rectangle aSelection(rRect); + tools::Long nSignX = mbNegativeX ? -1 : 1; + bool bIsChart = false; + Point addLogicOffset(0, 0); + bool convertMapMode = false; + if (!rRect.IsEmpty()) + { + sal_uInt32 nTotalPaintWindows = this->PaintWindowCount(); + if (nTotalPaintWindows == 1) + { + const OutputDevice* pOut = this->GetFirstOutputDevice(); + const vcl::Window* pWin = pOut ? pOut->GetOwnerWindow() : nullptr; + if (pWin && pWin->IsChart()) + { + bIsChart = true; + const vcl::Window* pViewShellWindow = GetSfxViewShell()->GetEditWindowForActiveOLEObj(); + if (pViewShellWindow && pViewShellWindow->IsAncestorOf(*pWin)) + { + Point aOffsetPx = pWin->GetOffsetPixelFrom(*pViewShellWindow); + if (mbNegativeX && AllSettings::GetLayoutRTL()) + { + // mbNegativeX is set only for Calc in RTL mode. + // If global RTL flag is set, vcl-window X offset of chart window is + // mirrored w.r.t parent window rectangle. This needs to be reverted. + aOffsetPx.setX(pViewShellWindow->GetOutOffXPixel() + pViewShellWindow->GetSizePixel().Width() + - pWin->GetOutOffXPixel() - pWin->GetSizePixel().Width()); + } + Point aLogicOffset = pWin->PixelToLogic(aOffsetPx); + addLogicOffset = aLogicOffset; + aSelection.Move(aLogicOffset.getX(), aLogicOffset.getY()); + } + } + } + } + + if (!aSelection.IsEmpty()) + { + // In case the map mode is in 100th MM, then need to convert the coordinates over to twips for LOK. + if (mpMarkedPV) + { + if (OutputDevice* pOutputDevice = mpMarkedPV->GetView().GetFirstOutputDevice()) + { + if (pOutputDevice->GetMapMode().GetMapUnit() == MapUnit::Map100thMM) + { + aSelection = o3tl::convert(aSelection, o3tl::Length::mm100, o3tl::Length::twip); + convertMapMode = true; + } + } + } + + // hide the text selection too + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TEXT_SELECTION, ""_ostr); + } + + { + OStringBuffer aExtraInfo; + OString sSelectionText; + OString sSelectionTextView; + boost::property_tree::ptree aTableJsonTree; + boost::property_tree::ptree aGluePointsTree; + const bool bMediaObj = (mpMarkedObj && mpMarkedObj->GetObjIdentifier() == SdrObjKind::Media); + bool bTableSelection = false; + bool bConnectorSelection = false; + + if (mpMarkedObj && mpMarkedObj->GetObjIdentifier() == SdrObjKind::Table) + { + auto& rTableObject = dynamic_cast<sdr::table::SdrTableObj&>(*mpMarkedObj); + bTableSelection = rTableObject.createTableEdgesJson(aTableJsonTree); + } + if (mpMarkedObj && mpMarkedObj->GetObjIdentifier() == SdrObjKind::Edge) + { + bConnectorSelection = dumpGluePointsToJSON(aGluePointsTree); + } + + if (GetMarkedObjectCount()) + { + SdrMark* pM = GetSdrMarkByIndex(0); + SdrObject* pO = pM->GetMarkedSdrObj(); + Degree100 nRotAngle = pO->GetRotateAngle(); + // true if we are dealing with a RotGrfFlyFrame + // (SwVirtFlyDrawObj with a SwGrfNode) + bool bWriterGraphic = pO->HasLimitedRotation(); + + OString handleArrayStr; + + aExtraInfo.append("{\"id\":\"" + + OString::number(reinterpret_cast<sal_IntPtr>(pO)) + + "\",\"type\":" + + OString::number(static_cast<sal_Int32>(pO->GetObjIdentifier()))); + + // In core, the gridOffset is calculated based on the LogicRect's TopLeft coordinate + // In online, we have the SnapRect and we calculate it based on its TopLeft coordinate + // SnapRect's TopLeft and LogicRect's TopLeft match unless there is rotation + // but the rotation is not applied to the LogicRect. Therefore, + // what we calculate in online does not match with the core in case of the rotation. + // Here we can send the correct gridOffset in the selection callback, this way + // whether the shape is rotated or not, we will always have the correct gridOffset + // Note that the gridOffset is calculated from the first selected obj + basegfx::B2DVector aGridOffset(0.0, 0.0); + if(getPossibleGridOffsetForSdrObject(aGridOffset, GetMarkedObjectByIndex(0), GetSdrPageView())) + { + Point p(aGridOffset.getX(), aGridOffset.getY()); + if (convertMapMode) + p = o3tl::convert(p, o3tl::Length::mm100, o3tl::Length::twip); + aExtraInfo.append(",\"gridOffsetX\":" + + OString::number(nSignX * p.getX()) + + ",\"gridOffsetY\":" + + OString::number(p.getY())); + } + + if (bWriterGraphic) + { + aExtraInfo.append(", \"isWriterGraphic\": true"); + } + else if (bIsChart) + { + LokChartHelper aChartHelper(pViewShell); + css::uno::Reference<css::frame::XController>& xChartController = aChartHelper.GetXController(); + css::uno::Reference<css::view::XSelectionSupplier> xSelectionSupplier( xChartController, uno::UNO_QUERY); + if (xSelectionSupplier.is()) + { + uno::Any aSel = xSelectionSupplier->getSelection(); + OUString aValue; + if (aSel >>= aValue) + { + OString aObjectCID(aValue.getStr(), aValue.getLength(), osl_getThreadTextEncoding()); + const std::vector<OString> aProps{"Draggable"_ostr, "Resizable"_ostr, "Rotatable"_ostr}; + for (const auto& rProp: aProps) + { + sal_Int32 nPos = aObjectCID.indexOf(rProp); + if (nPos == -1) continue; + nPos += rProp.getLength() + 1; // '=' + if (aExtraInfo.getLength() > 2) // != "{ " + aExtraInfo.append(", "); + aExtraInfo.append("\"is" + rProp + "\": " + + OString::boolean(aObjectCID[nPos] == '1')); + } + + std::u16string_view sDragMethod = lcl_getDragMethodServiceName(aValue); + if (sDragMethod == u"PieSegmentDragging") + { + // old initial offset inside the CID returned by xSelectionSupplier->getSelection() + // after a pie segment dragging; using SdrObject::GetName for getting a CID with the updated offset + aValue = pO->GetName(); + std::u16string_view sDragParameters = lcl_getDragParameterString(aValue); + if (!sDragParameters.empty()) + { + aExtraInfo.append(", \"dragInfo\": { " + "\"dragMethod\": \"" + + OUString(sDragMethod).toUtf8() + + "\""); + + sal_Int32 nStartIndex = 0; + std::array<int, 5> aDragParameters; + for (auto& rParam : aDragParameters) + { + std::u16string_view sParam = o3tl::getToken(sDragParameters, 0, ',', nStartIndex); + if (sParam.empty()) + break; + rParam = o3tl::toInt32(sParam); + } + + // initial offset in % + if (aDragParameters[0] < 0) + aDragParameters[0] = 0; + else if (aDragParameters[0] > 100) + aDragParameters[0] = 100; + + aExtraInfo.append(", \"initialOffset\": " + + OString::number(static_cast<sal_Int32>(aDragParameters[0]))); + + // drag direction constraint + Point aMinPos(aDragParameters[1], aDragParameters[2]); + Point aMaxPos(aDragParameters[3], aDragParameters[4]); + Point aDragDirection = aMaxPos - aMinPos; + aDragDirection = o3tl::convert(aDragDirection, o3tl::Length::mm100, o3tl::Length::twip); + + aExtraInfo.append(", \"dragDirection\": [" + + aDragDirection.toString() + + "]"); + + // polygon approximating the pie segment or donut segment + if (pO->GetObjIdentifier() == SdrObjKind::PathFill) + { + const basegfx::B2DPolyPolygon aPolyPolygon(pO->TakeXorPoly()); + if (aPolyPolygon.count() == 1) + { + const basegfx::B2DPolygon aPolygon = aPolyPolygon.getB2DPolygon(0); + if (sal_uInt32 nPolySize = aPolygon.count()) + { + const OutputDevice* pOut = this->GetFirstOutputDevice(); + const vcl::Window* pWin = pOut ? pOut->GetOwnerWindow() : nullptr; + const vcl::Window* pViewShellWindow = pViewShell->GetEditWindowForActiveOLEObj(); + if (pWin && pViewShellWindow && pViewShellWindow->IsAncestorOf(*pWin)) + { + // in the following code escaping sequences used inside raw literal strings + // are for making them understandable by the JSON parser + + Point aOffsetPx = pWin->GetOffsetPixelFrom(*pViewShellWindow); + Point aLogicOffset = pWin->PixelToLogic(aOffsetPx); + OString sPolygonElem("<polygon points=\\\""_ostr); + for (sal_uInt32 nIndex = 0; nIndex < nPolySize; ++nIndex) + { + const basegfx::B2DPoint aB2Point = aPolygon.getB2DPoint(nIndex); + Point aPoint(aB2Point.getX(), aB2Point.getY()); + aPoint.Move(aLogicOffset.getX(), aLogicOffset.getY()); + if (mbNegativeX) + aPoint.setX(-aPoint.X()); + if (nIndex > 0) + sPolygonElem += " "; + sPolygonElem += aPoint.toString(); + } + sPolygonElem += R"elem(\" style=\"stroke: none; fill: rgb(114,159,207); fill-opacity: 0.8\"/>)elem"; + + OString sSVGElem = R"elem(<svg version=\"1.2\" width=\")elem" + + OString::number(aSelection.GetWidth() / 100.0) + + R"elem(mm\" height=\")elem" + + OString::number(aSelection.GetHeight() / 100.0) + + R"elem(mm\" viewBox=\")elem" + + aSelection.toString() + + R"elem(\" preserveAspectRatio=\"xMidYMid\" xmlns=\"http://www.w3.org/2000/svg\">)elem"; + + aExtraInfo.append(", \"svg\": \"" + + sSVGElem + + "\\n " + + sPolygonElem + + "\\n</svg>" + "\""); // svg + } + } + } + } + aExtraInfo.append("}"); // dragInfo + } + } + } + } + } + if (!bTableSelection && !pOtherShell && maHdlList.GetHdlCount()) + { + boost::property_tree::ptree responseJSON; + boost::property_tree::ptree others; + boost::property_tree::ptree anchor; + boost::property_tree::ptree rectangle; + boost::property_tree::ptree poly; + boost::property_tree::ptree custom; + boost::property_tree::ptree nodes; + for (size_t i = 0; i < maHdlList.GetHdlCount(); i++) + { + SdrHdl *pHdl = maHdlList.GetHdl(i); + boost::property_tree::ptree child; + boost::property_tree::ptree point; + sal_Int32 kind = static_cast<sal_Int32>(pHdl->GetKind()); + child.put("id", pHdl->GetObjHdlNum()); + child.put("kind", kind); + child.put("pointer", static_cast<sal_Int32>(pHdl->GetPointer())); + Point pHdlPos = pHdl->GetPos(); + pHdlPos.Move(addLogicOffset.getX(), addLogicOffset.getY()); + if (convertMapMode) + { + pHdlPos = o3tl::convert(pHdlPos, o3tl::Length::mm100, o3tl::Length::twip); + } + point.put("x", pHdlPos.getX()); + point.put("y", pHdlPos.getY()); + child.add_child("point", point); + const auto node = std::make_pair("", child); + boost::property_tree::ptree* selectedNode = nullptr; + if (kind >= static_cast<sal_Int32>(SdrHdlKind::UpperLeft) && kind <= static_cast<sal_Int32>(SdrHdlKind::LowerRight)) + { + selectedNode = &rectangle; + } + else if (kind == static_cast<sal_Int32>(SdrHdlKind::Poly)) + { + selectedNode = &poly; + } + else if (kind == static_cast<sal_Int32>(SdrHdlKind::CustomShape1)) + { + selectedNode = &custom; + } + else if (kind == static_cast<sal_Int32>(SdrHdlKind::Anchor) || kind == static_cast<sal_Int32>(SdrHdlKind::Anchor_TR)) + { + if (getSdrModelFromSdrView().IsWriter()) + selectedNode = &anchor; + else + // put it to others as we don't render them except in writer + selectedNode = &others; + } + else + { + selectedNode = &others; + } + std::string sKind = std::to_string(kind); + boost::optional< boost::property_tree::ptree& > kindNode = selectedNode->get_child_optional(sKind.c_str()); + if (!kindNode) + { + boost::property_tree::ptree newChild; + newChild.push_back(node); + selectedNode->add_child(sKind.c_str(), newChild); + } + else + kindNode.get().push_back(node); + } + nodes.add_child("rectangle", rectangle); + nodes.add_child("poly", poly); + nodes.add_child("custom", custom); + nodes.add_child("anchor", anchor); + nodes.add_child("others", others); + responseJSON.add_child("kinds", nodes); + std::stringstream aStream; + boost::property_tree::write_json(aStream, responseJSON, /*pretty=*/ false); + handleArrayStr = ", \"handles\":"_ostr; + handleArrayStr = handleArrayStr + aStream.str().c_str(); + if (bConnectorSelection) + { + aStream.str(""); + boost::property_tree::write_json(aStream, aGluePointsTree, /*pretty=*/ false); + handleArrayStr = handleArrayStr + ", \"GluePoints\":"; + handleArrayStr = handleArrayStr + aStream.str().c_str(); + } + } + + if (mbNegativeX) + { + tools::Rectangle aNegatedRect(aSelection); + aNegatedRect.SetLeft(-aNegatedRect.Left()); + aNegatedRect.SetRight(-aNegatedRect.Right()); + aNegatedRect.Normalize(); + sSelectionText = aNegatedRect.toString() + + ", " + OString::number(nRotAngle.get()); + } + else + { + sSelectionText = aSelection.toString() + + ", " + OString::number(nRotAngle.get()); + } + + if (!aExtraInfo.isEmpty()) + { + sSelectionTextView = sSelectionText + ", " + aExtraInfo + "}"; + + if (bMediaObj && pOtherShell == nullptr) + { + // Add the URL only if we have a Media Object and + // we are the selecting view. + SdrMediaObj* mediaObj = dynamic_cast<SdrMediaObj*>(mpMarkedObj); + if (mediaObj) + aExtraInfo.append(", \"url\": \"" + mediaObj->getTempURL().toUtf8() + "\""); + } + + aExtraInfo.append(handleArrayStr + + "}"); + sSelectionText += ", " + aExtraInfo; + } + } + + if (sSelectionText.isEmpty()) + { + sSelectionText = "EMPTY"_ostr; + sSelectionTextView = "EMPTY"_ostr; + if (!pOtherShell) + pViewShell->NotifyOtherViews(LOK_CALLBACK_TEXT_VIEW_SELECTION, "selection"_ostr, OString()); + } + + if (bTableSelection) + { + boost::property_tree::ptree aTableRectangle; + aTableRectangle.put("x", aSelection.Left()); + aTableRectangle.put("y", aSelection.Top()); + aTableRectangle.put("width", aSelection.GetWidth()); + aTableRectangle.put("height", aSelection.GetHeight()); + aTableJsonTree.push_back(std::make_pair("rectangle", aTableRectangle)); + + std::stringstream aStream; + boost::property_tree::write_json(aStream, aTableJsonTree); + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TABLE_SELECTED, OString(aStream.str())); + } + else if (!getSdrModelFromSdrView().IsWriter()) + { + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_TABLE_SELECTED, "{}"_ostr); + } + + if (pOtherShell) + { + // Another shell wants to know about our existing + // selection. + if (pViewShell != pOtherShell) + SfxLokHelper::notifyOtherView(pViewShell, pOtherShell, LOK_CALLBACK_GRAPHIC_VIEW_SELECTION, "selection", sSelectionTextView); + } + else + { + // We have a new selection, so both pViewShell and the + // other views want to know about it. + pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_GRAPHIC_SELECTION, sSelectionText); + + SfxLokHelper::notifyOtherViews(pViewShell, LOK_CALLBACK_GRAPHIC_VIEW_SELECTION, "selection", sSelectionTextView); + } + } +} + +void SdrMarkView::SetMarkHandles(SfxViewShell* pOtherShell) +{ + // remember old focus handle values to search for it again + const SdrHdl* pSaveOldFocusHdl = maHdlList.GetFocusHdl(); + bool bSaveOldFocus(false); + sal_uInt32 nSavePolyNum(0), nSavePointNum(0); + SdrHdlKind eSaveKind(SdrHdlKind::Move); + SdrObject* pSaveObj = nullptr; + + mpMarkingSubSelectionOverlay.reset(); + + if(pSaveOldFocusHdl + && pSaveOldFocusHdl->GetObj() + && dynamic_cast<const SdrPathObj*>(pSaveOldFocusHdl->GetObj()) != nullptr + && (pSaveOldFocusHdl->GetKind() == SdrHdlKind::Poly || pSaveOldFocusHdl->GetKind() == SdrHdlKind::BezierWeight)) + { + bSaveOldFocus = true; + nSavePolyNum = pSaveOldFocusHdl->GetPolyNum(); + nSavePointNum = pSaveOldFocusHdl->GetPointNum(); + pSaveObj = pSaveOldFocusHdl->GetObj(); + eSaveKind = pSaveOldFocusHdl->GetKind(); + } + + // delete/clear all handles. This will always be done, even with areMarkHandlesHidden() + maHdlList.Clear(); + maHdlList.SetRotateShear(meDragMode==SdrDragMode::Rotate); + maHdlList.SetDistortShear(meDragMode==SdrDragMode::Shear); + mpMarkedObj=nullptr; + mpMarkedPV=nullptr; + + // are handles enabled at all? Create only then + if(areMarkHandlesHidden()) + return; + + // There can be multiple mark views, but we're only interested in the one that has a window associated. + const bool bTiledRendering = comphelper::LibreOfficeKit::isActive() && GetFirstOutputDevice() && GetFirstOutputDevice()->GetOutDevType() == OUTDEV_WINDOW; + + const size_t nMarkCount=GetMarkedObjectCount(); + bool bStdDrag=meDragMode==SdrDragMode::Move; + bool bSingleTextObjMark=false; + bool bLimitedRotation(false); + + if (nMarkCount==1) + { + mpMarkedObj=GetMarkedObjectByIndex(0); + + if(nullptr != mpMarkedObj) + { + bSingleTextObjMark = + DynCastSdrTextObj( mpMarkedObj) != nullptr && + static_cast<SdrTextObj*>(mpMarkedObj)->IsTextFrame(); + + // RotGrfFlyFrame: we may have limited rotation + bLimitedRotation = SdrDragMode::Rotate == meDragMode && mpMarkedObj->HasLimitedRotation(); + } + } + + bool bFrmHdl=ImpIsFrameHandles(); + + if (nMarkCount>0) + { + mpMarkedPV=GetSdrPageViewOfMarkedByIndex(0); + + for (size_t nMarkNum=0; nMarkNum<nMarkCount && (mpMarkedPV!=nullptr || !bFrmHdl); ++nMarkNum) + { + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + + if (mpMarkedPV!=pM->GetPageView()) + { + mpMarkedPV=nullptr; + } + } + } + + SfxViewShell* pViewShell = GetSfxViewShell(); + + // check if text edit or ole is active and handles need to be suppressed. This may be the case + // when a single object is selected + // Using a strict return statement is okay here; no handles means *no* handles. + if(mpMarkedObj) + { + // formerly #i33755#: If TextEdit is active the EditEngine will directly paint + // to the window, so suppress Overlay and handles completely; a text frame for + // the active text edit will be painted by the repaint mechanism in + // SdrObjEditView::ImpPaintOutlinerView in this case. This needs to be reworked + // in the future + // Also formerly #122142#: Pretty much the same for SdrCaptionObj's in calc. + if(static_cast<SdrView*>(this)->IsTextEdit()) + { + const SdrTextObj* pSdrTextObj = DynCastSdrTextObj(mpMarkedObj); + + if (pSdrTextObj && pSdrTextObj->IsInEditMode()) + { + if (!bTiledRendering) + return; + } + } + + // formerly #i118524#: if inplace activated OLE is selected, suppress handles + const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(mpMarkedObj); + + if(pSdrOle2Obj && (pSdrOle2Obj->isInplaceActive() || pSdrOle2Obj->isUiActive())) + { + return; + } + + if (!maSubSelectionList.empty()) + { + mpMarkingSubSelectionOverlay = std::make_unique<MarkingSubSelectionOverlay>(*this, maSubSelectionList); + } + } + + tools::Rectangle aRect(GetMarkedObjRect()); + + if (bFrmHdl) + { + if(!aRect.IsEmpty()) + { + // otherwise nothing is found + const size_t nSiz0(maHdlList.GetHdlCount()); + + if( bSingleTextObjMark ) + { + mpMarkedObj->AddToHdlList(maHdlList); + } + else + { + const bool bWdt0(aRect.Left() == aRect.Right()); + const bool bHgt0(aRect.Top() == aRect.Bottom()); + + if (bWdt0 && bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + } + else if (!bStdDrag && (bWdt0 || bHgt0)) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.BottomRight(), SdrHdlKind::LowerRight)); + } + else + { + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + } + + if (!bLimitedRotation && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.TopCenter(), SdrHdlKind::Upper)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.TopRight(), SdrHdlKind::UpperRight)); + } + + if (!bLimitedRotation && !bWdt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.LeftCenter(), SdrHdlKind::Left )); + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.RightCenter(), SdrHdlKind::Right)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.BottomLeft(), SdrHdlKind::LowerLeft)); + } + + if (!bLimitedRotation && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.BottomCenter(), SdrHdlKind::Lower)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique<SdrHdl>(aRect.BottomRight(), SdrHdlKind::LowerRight)); + } + } + } + + // Diagram selection visualization support + // Caution: CppunitTest_sd_tiledrendering shows that mpMarkedObj *can* actually be nullptr (!) + if(nullptr != mpMarkedObj && mpMarkedObj->isDiagram()) + { + mpMarkedObj->AddToHdlList(maHdlList); + } + + const size_t nSiz1(maHdlList.GetHdlCount()); + + // moved setting the missing parameters at SdrHdl here from the + // single loop above (bSingleTextObjMark), this was missing all + // the time. Setting SdrObject is now required to correctly get + // the View-Dependent evtl. GridOffset adapted + for (size_t i=nSiz0; i<nSiz1; ++i) + { + SdrHdl* pHdl=maHdlList.GetHdl(i); + pHdl->SetObj(mpMarkedObj); + pHdl->SetPageView(mpMarkedPV); + pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); + } + } + } + else + { + bool bDone(false); + + // moved crop handling to non-frame part and the handle creation to SdrGrafObj + if(1 == nMarkCount && mpMarkedObj && SdrDragMode::Crop == meDragMode) + { + // Default addCropHandles from SdrObject does nothing. When pMarkedObj is SdrGrafObj, previous + // behaviour occurs (code in svx/source/svdraw/svdograf.cxx). When pMarkedObj is SwVirtFlyDrawObj + // writer takes the responsibility of adding handles (code in sw/source/core/draw/dflyobj.cxx) + const size_t nSiz0(maHdlList.GetHdlCount()); + mpMarkedObj->addCropHandles(maHdlList); + const size_t nSiz1(maHdlList.GetHdlCount()); + + // Was missing: Set infos at SdrCropHdl + for (size_t i=nSiz0; i<nSiz1; ++i) + { + SdrHdl* pHdl=maHdlList.GetHdl(i); + pHdl->SetObj(mpMarkedObj); + pHdl->SetPageView(mpMarkedPV); + pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); + } + + bDone = true; + } + + if(!bDone) + { + for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) + { + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrPageView* pPV=pM->GetPageView(); + const size_t nSiz0=maHdlList.GetHdlCount(); + pObj->AddToHdlList(maHdlList); + const size_t nSiz1=maHdlList.GetHdlCount(); + bool bPoly=pObj->IsPolyObj(); + const SdrUShortCont& rMrkPnts = pM->GetMarkedPoints(); + for (size_t i=nSiz0; i<nSiz1; ++i) + { + SdrHdl* pHdl=maHdlList.GetHdl(i); + pHdl->SetObj(pObj); + pHdl->SetPageView(pPV); + pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); + + if (bPoly) + { + bool bSelected= rMrkPnts.find( sal_uInt16(i-nSiz0) ) != rMrkPnts.end(); + pHdl->SetSelected(bSelected); + if (mbPlusHdlAlways || bSelected) + { + SdrHdlList plusList(nullptr); + pObj->AddToPlusHdlList(plusList, *pHdl); + sal_uInt32 nPlusHdlCnt=plusList.GetHdlCount(); + for (sal_uInt32 nPlusNum=0; nPlusNum<nPlusHdlCnt; nPlusNum++) + { + SdrHdl* pPlusHdl=plusList.GetHdl(nPlusNum); + pPlusHdl->SetObj(pObj); + pPlusHdl->SetPageView(pPV); + pPlusHdl->SetPlusHdl(true); + } + plusList.MoveTo(maHdlList); + } + } + } + } + } + } + + // GluePoint handles + for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum) + { + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrObject* pObj=pM->GetMarkedSdrObj(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + if (!pGPL) + continue; + + SdrPageView* pPV=pM->GetPageView(); + const SdrUShortCont& rMrkGlue=pM->GetMarkedGluePoints(); + for (sal_uInt16 nId : rMrkGlue) + { + //nNum changed to nNumGP because already used in for loop + sal_uInt16 nNumGP=pGPL->FindGluePoint(nId); + if (nNumGP!=SDRGLUEPOINT_NOTFOUND) + { + const SdrGluePoint& rGP=(*pGPL)[nNumGP]; + Point aPos(rGP.GetAbsolutePos(*pObj)); + std::unique_ptr<SdrHdl> pGlueHdl(new SdrHdl(aPos,SdrHdlKind::Glue)); + pGlueHdl->SetObj(pObj); + pGlueHdl->SetPageView(pPV); + pGlueHdl->SetObjHdlNum(nId); + maHdlList.AddHdl(std::move(pGlueHdl)); + } + } + } + + // rotation point/axis of reflection + if(!bLimitedRotation) + { + AddDragModeHdl(meDragMode); + } + + // sort handles + maHdlList.Sort(); + + // add custom handles (used by other apps, e.g. AnchorPos) + AddCustomHdl(); + + // moved it here to access all the handles for callback. + if (bTiledRendering && pViewShell) + { + SetMarkHandlesForLOKit(aRect, pOtherShell); + } + + // try to restore focus handle index from remembered values + if(!bSaveOldFocus) + return; + + for(size_t a = 0; a < maHdlList.GetHdlCount(); ++a) + { + SdrHdl* pCandidate = maHdlList.GetHdl(a); + + if(pCandidate->GetObj() + && pCandidate->GetObj() == pSaveObj + && pCandidate->GetKind() == eSaveKind + && pCandidate->GetPolyNum() == nSavePolyNum + && pCandidate->GetPointNum() == nSavePointNum) + { + maHdlList.SetFocusHdl(pCandidate); + break; + } + } +} + +void SdrMarkView::AddCustomHdl() +{ + // add custom handles (used by other apps, e.g. AnchorPos) +} + +void SdrMarkView::SetDragMode(SdrDragMode eMode) +{ + SdrDragMode eMode0=meDragMode; + meDragMode=eMode; + if (meDragMode==SdrDragMode::Resize) meDragMode=SdrDragMode::Move; + if (meDragMode!=eMode0) { + ForceRefToMarked(); + SetMarkHandles(nullptr); + { + if (AreObjectsMarked()) MarkListHasChanged(); + } + } +} + +void SdrMarkView::AddDragModeHdl(SdrDragMode eMode) +{ + switch(eMode) + { + case SdrDragMode::Rotate: + { + // add rotation center + maHdlList.AddHdl(std::make_unique<SdrHdl>(maRef1, SdrHdlKind::Ref1)); + break; + } + case SdrDragMode::Mirror: + { + // add axis of reflection + std::unique_ptr<SdrHdl> pHdl3(new SdrHdl(maRef2, SdrHdlKind::Ref2)); + std::unique_ptr<SdrHdl> pHdl2(new SdrHdl(maRef1, SdrHdlKind::Ref1)); + std::unique_ptr<SdrHdl> pHdl1(new SdrHdlLine(*pHdl2, *pHdl3, SdrHdlKind::MirrorAxis)); + + pHdl1->SetObjHdlNum(1); // for sorting + pHdl2->SetObjHdlNum(2); // for sorting + pHdl3->SetObjHdlNum(3); // for sorting + + maHdlList.AddHdl(std::move(pHdl1)); // line comes first, so it is the last in HitTest + maHdlList.AddHdl(std::move(pHdl2)); + maHdlList.AddHdl(std::move(pHdl3)); + + break; + } + case SdrDragMode::Transparence: + { + // add interactive transparency handle + const size_t nMarkCount = GetMarkedObjectCount(); + if(nMarkCount == 1) + { + SdrObject* pObj = GetMarkedObjectByIndex(0); + SdrModel& rModel = GetModel(); + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + + if(SfxItemState::SET != rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, false)) + { + // add this item, it's not yet there + XFillFloatTransparenceItem aNewItem(rSet.Get(XATTR_FILLFLOATTRANSPARENCE)); + basegfx::BGradient aGrad = aNewItem.GetGradientValue(); + + aNewItem.SetEnabled(true); + aGrad.SetStartIntens(100); + aGrad.SetEndIntens(100); + aNewItem.SetGradientValue(aGrad); + + // add undo to allow user to take back this step + if (rModel.IsUndoEnabled()) + { + rModel.BegUndo(SvxResId(SIP_XA_FILLTRANSPARENCE)); + rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoAttrObject(*pObj)); + rModel.EndUndo(); + } + + SfxItemSet aNewSet(rModel.GetItemPool()); + aNewSet.Put(aNewItem); + pObj->SetMergedItemSetAndBroadcast(aNewSet); + } + + // set values and transform to vector set + GradTransVector aGradTransVector; + GradTransGradient aGradTransGradient; + + aGradTransGradient.aGradient = rSet.Get(XATTR_FILLFLOATTRANSPARENCE).GetGradientValue(); + GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, pObj); + + // build handles + const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY())); + const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY())); + std::unique_ptr<SdrHdlColor> pColHdl1(new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, SDR_HANDLE_COLOR_SIZE_NORMAL, true)); + std::unique_ptr<SdrHdlColor> pColHdl2(new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, SDR_HANDLE_COLOR_SIZE_NORMAL, true)); + std::unique_ptr<SdrHdlGradient> pGradHdl(new SdrHdlGradient(aTmpPos1, aTmpPos2, false)); + DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Could not get all necessary handles!"); + + // link them + pGradHdl->SetColorHandles(pColHdl1.get(), pColHdl2.get()); + pGradHdl->SetObj(pObj); + pColHdl1->SetColorChangeHdl(LINK(pGradHdl.get(), SdrHdlGradient, ColorChangeHdl)); + pColHdl2->SetColorChangeHdl(LINK(pGradHdl.get(), SdrHdlGradient, ColorChangeHdl)); + + // insert them + maHdlList.AddHdl(std::move(pColHdl1)); + maHdlList.AddHdl(std::move(pColHdl2)); + maHdlList.AddHdl(std::move(pGradHdl)); + } + break; + } + case SdrDragMode::Gradient: + { + // add interactive gradient handle + const size_t nMarkCount = GetMarkedObjectCount(); + if(nMarkCount == 1) + { + SdrObject* pObj = GetMarkedObjectByIndex(0); + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + drawing::FillStyle eFillStyle = rSet.Get(XATTR_FILLSTYLE).GetValue(); + + if(eFillStyle == drawing::FillStyle_GRADIENT) + { + // set values and transform to vector set + GradTransVector aGradTransVector; + GradTransGradient aGradTransGradient; + Size aHdlSize(15, 15); + + aGradTransGradient.aGradient = rSet.Get(XATTR_FILLGRADIENT).GetGradientValue(); + GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, pObj); + + // build handles + const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY())); + const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY())); + std::unique_ptr<SdrHdlColor> pColHdl1(new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, aHdlSize, false)); + std::unique_ptr<SdrHdlColor> pColHdl2(new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, aHdlSize, false)); + std::unique_ptr<SdrHdlGradient> pGradHdl(new SdrHdlGradient(aTmpPos1, aTmpPos2, true)); + DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Could not get all necessary handles!"); + + // link them + pGradHdl->SetColorHandles(pColHdl1.get(), pColHdl2.get()); + pGradHdl->SetObj(pObj); + pColHdl1->SetColorChangeHdl(LINK(pGradHdl.get(), SdrHdlGradient, ColorChangeHdl)); + pColHdl2->SetColorChangeHdl(LINK(pGradHdl.get(), SdrHdlGradient, ColorChangeHdl)); + + // insert them + maHdlList.AddHdl(std::move(pColHdl1)); + maHdlList.AddHdl(std::move(pColHdl2)); + maHdlList.AddHdl(std::move(pGradHdl)); + } + } + break; + } + case SdrDragMode::Crop: + { + // TODO + break; + } + default: break; + } +} + +/** handle mouse over effects for handles */ +bool SdrMarkView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + if(maHdlList.GetHdlCount()) + { + SdrHdl* pMouseOverHdl = nullptr; + if( !rMEvt.IsLeaveWindow() && pWin ) + { + Point aMDPos( pWin->PixelToLogic( rMEvt.GetPosPixel() ) ); + pMouseOverHdl = PickHandle(aMDPos); + } + + // notify last mouse over handle that he lost the mouse + const size_t nHdlCount = maHdlList.GetHdlCount(); + + for(size_t nHdl = 0; nHdl < nHdlCount; ++nHdl) + { + SdrHdl* pCurrentHdl = GetHdl(nHdl); + if( pCurrentHdl->mbMouseOver ) + { + if( pCurrentHdl != pMouseOverHdl ) + { + pCurrentHdl->mbMouseOver = false; + pCurrentHdl->onMouseLeave(); + } + break; + } + } + + // notify current mouse over handle + if( pMouseOverHdl ) + { + pMouseOverHdl->mbMouseOver = true; + pMouseOverHdl->onMouseEnter(rMEvt); + } + } + return SdrSnapView::MouseMove(rMEvt, pWin); +} + +bool SdrMarkView::RequestHelp(const HelpEvent& rHEvt) +{ + if (maHdlList.GetHdlCount()) + { + const size_t nHdlCount = maHdlList.GetHdlCount(); + + for (size_t nHdl = 0; nHdl < nHdlCount; ++nHdl) + { + SdrHdl* pCurrentHdl = GetHdl(nHdl); + if (pCurrentHdl->mbMouseOver) + { + pCurrentHdl->onHelpRequest(); + return true; + } + } + } + return SdrSnapView::RequestHelp(rHEvt); +} + +void SdrMarkView::ForceRefToMarked() +{ + switch(meDragMode) + { + case SdrDragMode::Rotate: + { + tools::Rectangle aR(GetMarkedObjRect()); + maRef1 = aR.Center(); + + break; + } + + case SdrDragMode::Mirror: + { + // first calculate the length of the axis of reflection + tools::Long nOutMin=0; + tools::Long nOutMax=0; + tools::Long nMinLen=0; + tools::Long nObjDst=0; + tools::Long nOutHgt=0; + OutputDevice* pOut=GetFirstOutputDevice(); + if (pOut!=nullptr) { + // minimum length: 50 pixels + nMinLen=pOut->PixelToLogic(Size(0,50)).Height(); + // 20 pixels distance to the Obj for the reference point + nObjDst=pOut->PixelToLogic(Size(0,20)).Height(); + // MinY/MaxY + // margin = minimum length = 10 pixels + tools::Long nDst=pOut->PixelToLogic(Size(0,10)).Height(); + nOutMin=-pOut->GetMapMode().GetOrigin().Y(); + nOutMax=pOut->GetOutputSize().Height()-1+nOutMin; + nOutMin+=nDst; + nOutMax-=nDst; + // absolute minimum length, however, is 10 pixels + if (nOutMax-nOutMin<nDst) { + nOutMin+=nOutMax+1; + nOutMin/=2; + nOutMin-=(nDst+1)/2; + nOutMax=nOutMin+nDst; + } + nOutHgt=nOutMax-nOutMin; + // otherwise minimum length = 1/4 OutHgt + tools::Long nTemp=nOutHgt/4; + if (nTemp>nMinLen) nMinLen=nTemp; + } + + tools::Rectangle aR(GetMarkedObjBoundRect()); + Point aCenter(aR.Center()); + tools::Long nMarkHgt=aR.GetHeight()-1; + tools::Long nHgt=nMarkHgt+nObjDst*2; // 20 pixels overlapping above and below + if (nHgt<nMinLen) nHgt=nMinLen; // minimum length 50 pixels or 1/4 OutHgt, respectively + + tools::Long nY1=aCenter.Y()-(nHgt+1)/2; + tools::Long nY2=nY1+nHgt; + + if (pOut!=nullptr && nMinLen>nOutHgt) nMinLen=nOutHgt; // TODO: maybe shorten this a little + + if (pOut!=nullptr) { // now move completely into the visible area + if (nY1<nOutMin) { + nY1=nOutMin; + if (nY2<nY1+nMinLen) nY2=nY1+nMinLen; + } + if (nY2>nOutMax) { + nY2=nOutMax; + if (nY1>nY2-nMinLen) nY1=nY2-nMinLen; + } + } + + maRef1.setX(aCenter.X() ); + maRef1.setY(nY1 ); + maRef2.setX(aCenter.X() ); + maRef2.setY(nY2 ); + + break; + } + + case SdrDragMode::Transparence: + case SdrDragMode::Gradient: + case SdrDragMode::Crop: + { + tools::Rectangle aRect(GetMarkedObjBoundRect()); + maRef1 = aRect.TopLeft(); + maRef2 = aRect.BottomRight(); + break; + } + default: break; + } +} + +void SdrMarkView::SetRef1(const Point& rPt) +{ + if(meDragMode == SdrDragMode::Rotate || meDragMode == SdrDragMode::Mirror) + { + maRef1 = rPt; + SdrHdl* pH = maHdlList.GetHdl(SdrHdlKind::Ref1); + if(pH) + pH->SetPos(rPt); + } +} + +void SdrMarkView::SetRef2(const Point& rPt) +{ + if(meDragMode == SdrDragMode::Mirror) + { + maRef2 = rPt; + SdrHdl* pH = maHdlList.GetHdl(SdrHdlKind::Ref2); + if(pH) + pH->SetPos(rPt); + } +} + +SfxViewShell* SdrMarkView::GetSfxViewShell() const +{ + return SfxViewShell::Current(); +} + +void SdrMarkView::CheckMarked() +{ + for (size_t nm=GetMarkedObjectCount(); nm>0;) { + --nm; + SdrMark* pM = GetSdrMarkByIndex(nm); + SdrObject* pObj = pM->GetMarkedSdrObj(); + SdrPageView* pPV = pM->GetPageView(); + bool bRaus = !pObj || !pPV->IsObjMarkable(pObj); + if (bRaus) + { + GetMarkedObjectListWriteAccess().DeleteMark(nm); + } + else + { + if (!IsGluePointEditMode()) { // selected gluepoints only in GlueEditMode + SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + rPts.clear(); + } + } + } + + // at least reset the remembered BoundRect to prevent handle + // generation if bForceFrameHandles is TRUE. + mbMarkedObjRectDirty = true; +} + +void SdrMarkView::SetMarkRects() +{ + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + pPV->SetHasMarkedObj(GetMarkedObjectList().TakeSnapRect(pPV, pPV->MarkSnap())); + GetMarkedObjectList().TakeBoundRect(pPV, pPV->MarkBound()); + } +} + +void SdrMarkView::SetFrameHandles(bool bOn) +{ + if (bOn!=mbForceFrameHandles) { + bool bOld=ImpIsFrameHandles(); + mbForceFrameHandles=bOn; + bool bNew=ImpIsFrameHandles(); + if (bNew!=bOld) { + AdjustMarkHdl(); + MarkListHasChanged(); + } + } +} + +void SdrMarkView::SetEditMode(SdrViewEditMode eMode) +{ + if (eMode==meEditMode) return; + + bool bGlue0=meEditMode==SdrViewEditMode::GluePointEdit; + bool bEdge0=static_cast<SdrCreateView*>(this)->IsEdgeTool(); + meEditMode0=meEditMode; + meEditMode=eMode; + bool bGlue1=meEditMode==SdrViewEditMode::GluePointEdit; + bool bEdge1=static_cast<SdrCreateView*>(this)->IsEdgeTool(); + // avoid flickering when switching between GlueEdit and EdgeTool + if (bGlue1 && !bGlue0) ImpSetGlueVisible2(bGlue1); + if (bEdge1!=bEdge0) ImpSetGlueVisible3(bEdge1); + if (!bGlue1 && bGlue0) ImpSetGlueVisible2(bGlue1); + if (bGlue0 && !bGlue1) UnmarkAllGluePoints(); +} + + +bool SdrMarkView::IsObjMarkable(SdrObject const * pObj, SdrPageView const * pPV) const +{ + if (pObj) + { + if (pObj->IsMarkProtect() || + (!mbDesignMode && pObj->IsUnoObj())) + { + // object not selectable or + // SdrUnoObj not in DesignMode + return false; + } + } + return pPV==nullptr || pPV->IsObjMarkable(pObj); +} + +bool SdrMarkView::IsMarkedObjHit(const Point& rPnt, short nTol) const +{ + bool bRet=false; + nTol=ImpGetHitTolLogic(nTol,nullptr); + for (size_t nm=0; nm<GetMarkedObjectCount() && !bRet; ++nm) { + SdrMark* pM=GetSdrMarkByIndex(nm); + bRet = nullptr != CheckSingleSdrObjectHit(rPnt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),SdrSearchOptions::NONE,nullptr); + } + return bRet; +} + +SdrHdl* SdrMarkView::PickHandle(const Point& rPnt) const +{ + if (mbSomeObjChgdFlag) { // recalculate handles, if necessary + FlushComeBackTimer(); + } + return maHdlList.IsHdlListHit(rPnt); +} + +bool SdrMarkView::MarkObj(const Point& rPnt, short nTol, bool bToggle, bool bDeep) +{ + SdrPageView* pPV; + nTol=ImpGetHitTolLogic(nTol,nullptr); + SdrSearchOptions nOptions=SdrSearchOptions::PICKMARKABLE; + if (bDeep) nOptions=nOptions|SdrSearchOptions::DEEP; + SdrObject* pObj = PickObj(rPnt, static_cast<sal_uInt16>(nTol), pPV, nOptions); + if (pObj) { + bool bUnmark=bToggle && IsObjMarked(pObj); + MarkObj(pObj,pPV,bUnmark); + } + return pObj != nullptr; +} + +bool SdrMarkView::MarkNextObj(bool bPrev) +{ + SdrPageView* pPageView = GetSdrPageView(); + + if(!pPageView) + { + return false; + } + + SortMarkedObjects(); + const size_t nMarkCount=GetMarkedObjectCount(); + size_t nChgMarkNum = SAL_MAX_SIZE; // number of the MarkEntry we want to replace + size_t nSearchObjNum = bPrev ? 0 : SAL_MAX_SIZE; + if (nMarkCount!=0) { + nChgMarkNum=bPrev ? 0 : nMarkCount-1; + SdrMark* pM=GetSdrMarkByIndex(nChgMarkNum); + OSL_ASSERT(pM!=nullptr); + if (pM->GetMarkedSdrObj() != nullptr) + nSearchObjNum = pM->GetMarkedSdrObj()->GetNavigationPosition(); + } + + SdrObject* pMarkObj=nullptr; + SdrObjList* pSearchObjList=pPageView->GetObjList(); + const size_t nObjCount = pSearchObjList->GetObjCount(); + if (nObjCount!=0) { + if (nSearchObjNum>nObjCount) nSearchObjNum=nObjCount; + while (pMarkObj==nullptr && ((!bPrev && nSearchObjNum>0) || (bPrev && nSearchObjNum<nObjCount))) + { + if (!bPrev) + nSearchObjNum--; + SdrObject* pSearchObj = pSearchObjList->GetObjectForNavigationPosition(nSearchObjNum); + if (IsObjMarkable(pSearchObj,pPageView)) + { + if (TryToFindMarkedObject(pSearchObj)==SAL_MAX_SIZE) + { + pMarkObj=pSearchObj; + } + } + if (bPrev) nSearchObjNum++; + } + } + + if(!pMarkObj) + { + return false; + } + + if (nChgMarkNum!=SAL_MAX_SIZE) + { + GetMarkedObjectListWriteAccess().DeleteMark(nChgMarkNum); + } + MarkObj(pMarkObj,pPageView); // also calls MarkListHasChanged(), AdjustMarkHdl() + return true; +} + +bool SdrMarkView::MarkNextObj(const Point& rPnt, short nTol, bool bPrev) +{ + SortMarkedObjects(); + nTol=ImpGetHitTolLogic(nTol,nullptr); + SdrMark* pTopMarkHit=nullptr; + SdrMark* pBtmMarkHit=nullptr; + size_t nTopMarkHit=0; + size_t nBtmMarkHit=0; + // find topmost of the selected objects that is hit by rPnt + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=nMarkCount; nm>0 && pTopMarkHit==nullptr;) { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + if(CheckSingleSdrObjectHit(rPnt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),SdrSearchOptions::NONE,nullptr)) + { + pTopMarkHit=pM; + nTopMarkHit=nm; + } + } + // nothing found, in this case, just select an object + if (pTopMarkHit==nullptr) return MarkObj(rPnt,sal_uInt16(nTol)); + + SdrObject* pTopObjHit=pTopMarkHit->GetMarkedSdrObj(); + SdrObjList* pObjList=pTopObjHit->getParentSdrObjListFromSdrObject(); + SdrPageView* pPV=pTopMarkHit->GetPageView(); + // find lowermost of the selected objects that is hit by rPnt + // and is placed on the same PageView as pTopMarkHit + for (size_t nm=0; nm<nMarkCount && pBtmMarkHit==nullptr; ++nm) { + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrPageView* pPV2=pM->GetPageView(); + if (pPV2==pPV && CheckSingleSdrObjectHit(rPnt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pPV2,SdrSearchOptions::NONE,nullptr)) + { + pBtmMarkHit=pM; + nBtmMarkHit=nm; + } + } + if (pBtmMarkHit==nullptr) { pBtmMarkHit=pTopMarkHit; nBtmMarkHit=nTopMarkHit; } + SdrObject* pBtmObjHit=pBtmMarkHit->GetMarkedSdrObj(); + const size_t nObjCount = pObjList->GetObjCount(); + + size_t nSearchBeg(0); + E3dScene* pScene(nullptr); + SdrObject* pObjHit(bPrev ? pBtmObjHit : pTopObjHit); + bool bRemap = + nullptr != dynamic_cast< const E3dCompoundObject* >(pObjHit); + if (bRemap) + { + pScene = DynCastE3dScene(pObjHit->getParentSdrObjectFromSdrObject()); + bRemap = nullptr != pScene; + } + + if(bPrev) + { + sal_uInt32 nOrdNumBtm(pBtmObjHit->GetOrdNum()); + + if(bRemap) + { + nOrdNumBtm = pScene->RemapOrdNum(nOrdNumBtm); + } + + nSearchBeg = nOrdNumBtm + 1; + } + else + { + sal_uInt32 nOrdNumTop(pTopObjHit->GetOrdNum()); + + if(bRemap) + { + nOrdNumTop = pScene->RemapOrdNum(nOrdNumTop); + } + + nSearchBeg = nOrdNumTop; + } + + size_t no=nSearchBeg; + SdrObject* pFndObj=nullptr; + while (pFndObj==nullptr && ((!bPrev && no>0) || (bPrev && no<nObjCount))) { + if (!bPrev) no--; + SdrObject* pObj; + + if(bRemap) + { + pObj = pObjList->GetObj(pScene->RemapOrdNum(no)); + } + else + { + pObj = pObjList->GetObj(no); + } + + if (CheckSingleSdrObjectHit(rPnt,sal_uInt16(nTol),pObj,pPV,SdrSearchOptions::TESTMARKABLE,nullptr)) + { + if (TryToFindMarkedObject(pObj)==SAL_MAX_SIZE) { + pFndObj=pObj; + } else { + // TODO: for performance reasons set on to Top or Btm, if necessary + } + } + if (bPrev) no++; + } + if (pFndObj!=nullptr) + { + GetMarkedObjectListWriteAccess().DeleteMark(bPrev?nBtmMarkHit:nTopMarkHit); + GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pFndObj,pPV)); + MarkListHasChanged(); + AdjustMarkHdl(); + } + return pFndObj!=nullptr; +} + +void SdrMarkView::MarkObj(const tools::Rectangle& rRect, bool bUnmark) +{ + bool bFnd=false; + tools::Rectangle aR(rRect); + SdrObjList* pObjList; + BrkAction(); + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + pObjList=pPV->GetObjList(); + tools::Rectangle aFrm1(aR); + for (const rtl::Reference<SdrObject>& pObj : *pObjList) { + tools::Rectangle aRect(pObj->GetCurrentBoundRect()); + if (aFrm1.Contains(aRect)) { + if (!bUnmark) { + if (IsObjMarkable(pObj.get(),pPV)) + { + GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj.get(),pPV)); + bFnd=true; + } + } else { + const size_t nPos=TryToFindMarkedObject(pObj.get()); + if (nPos!=SAL_MAX_SIZE) + { + GetMarkedObjectListWriteAccess().DeleteMark(nPos); + bFnd=true; + } + } + } + } + } + if (bFnd) { + SortMarkedObjects(); + MarkListHasChanged(); + AdjustMarkHdl(); + } +} + +namespace { + +void collectUIInformation(const SdrObject* pObj) +{ + EventDescription aDescription; + aDescription.aAction = "SELECT"; + aDescription.aParent = "MainWindow"; + aDescription.aKeyWord = "CurrentApp"; + + if (!pObj->GetName().isEmpty()) + aDescription.aParameters = {{"OBJECT", pObj->GetName()}}; + else + aDescription.aParameters = {{"OBJECT", "Unnamed_Obj_" + OUString::number(pObj->GetOrdNum())}}; + + UITestLogger::getInstance().logEvent(aDescription); +} + +} + + void SdrMarkView::MarkObj(SdrObject* pObj, SdrPageView* pPV, bool bUnmark, bool bDoNoSetMarkHdl, + std::vector<basegfx::B2DRectangle> && rSubSelections) +{ + if (!(pObj!=nullptr && pPV!=nullptr && IsObjMarkable(pObj, pPV))) + return; + + BrkAction(); + if (!bUnmark) + { + GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj,pPV)); + collectUIInformation(pObj); + } + else + { + const size_t nPos=TryToFindMarkedObject(pObj); + if (nPos!=SAL_MAX_SIZE) + { + GetMarkedObjectListWriteAccess().DeleteMark(nPos); + } + } + + maSubSelectionList = std::move(rSubSelections); + + if (!bDoNoSetMarkHdl) { + MarkListHasChanged(); + AdjustMarkHdl(); + } +} + +bool SdrMarkView::IsObjMarked(SdrObject const * pObj) const +{ + return TryToFindMarkedObject(pObj)!=SAL_MAX_SIZE; +} + +sal_uInt16 SdrMarkView::GetMarkHdlSizePixel() const +{ + return maHdlList.GetHdlSize()*2+1; +} + +void SdrMarkView::SetMarkHdlSizePixel(sal_uInt16 nSiz) +{ + if (nSiz<3) nSiz=3; + nSiz/=2; + if (nSiz!=maHdlList.GetHdlSize()) { + maHdlList.SetHdlSize(nSiz); + } +} + +bool SdrMarkView::getPossibleGridOffsetForSdrObject( + basegfx::B2DVector& rOffset, + const SdrObject* pObj, + const SdrPageView* pPV) const +{ + if(nullptr == pObj || nullptr == pPV) + { + return false; + } + + const OutputDevice* pOutputDevice(GetFirstOutputDevice()); + + if(nullptr == pOutputDevice) + { + return false; + } + + const SdrPageWindow* pSdrPageWindow(pPV->FindPageWindow(*pOutputDevice)); + + if(nullptr == pSdrPageWindow) + { + return false; + } + + const sdr::contact::ObjectContact& rObjectContact(pSdrPageWindow->GetObjectContact()); + + if(!rObjectContact.supportsGridOffsets()) + { + return false; + } + + const sdr::contact::ViewObjectContact& rVOC(pObj->GetViewContact().GetViewObjectContact( + const_cast<sdr::contact::ObjectContact&>(rObjectContact))); + + rOffset = rVOC.getGridOffset(); + + return !rOffset.equalZero(); +} + +bool SdrMarkView::getPossibleGridOffsetForPosition( + basegfx::B2DVector& rOffset, + const basegfx::B2DPoint& rPoint, + const SdrPageView* pPV) const +{ + if(nullptr == pPV) + { + return false; + } + + const OutputDevice* pOutputDevice(GetFirstOutputDevice()); + + if(nullptr == pOutputDevice) + { + return false; + } + + const SdrPageWindow* pSdrPageWindow(pPV->FindPageWindow(*pOutputDevice)); + + if(nullptr == pSdrPageWindow) + { + return false; + } + + const sdr::contact::ObjectContact& rObjectContact(pSdrPageWindow->GetObjectContact()); + + if(!rObjectContact.supportsGridOffsets()) + { + return false; + } + + rObjectContact.calculateGridOffsetForB2DRange(rOffset, basegfx::B2DRange(rPoint)); + + return !rOffset.equalZero(); +} + +SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay) const +{ + if(((nOptions & SdrSearchOptions::IMPISMASTER) && pObj->IsNotVisibleAsMaster()) || (!pObj->IsVisible())) + { + return nullptr; + } + + const bool bCheckIfMarkable(nOptions & SdrSearchOptions::TESTMARKABLE); + const bool bDeep(nOptions & SdrSearchOptions::DEEP); + const bool bOLE(dynamic_cast< const SdrOle2Obj* >(pObj) != nullptr); + auto pTextObj = DynCastSdrTextObj( pObj); + const bool bTXT(pTextObj && pTextObj->IsTextFrame()); + SdrObject* pRet=nullptr; + tools::Rectangle aRect(pObj->GetCurrentBoundRect()); + + // add possible GridOffset to up-to-now view-independent BoundRect data + basegfx::B2DVector aGridOffset(0.0, 0.0); + if(getPossibleGridOffsetForSdrObject(aGridOffset, pObj, pPV)) + { + aRect += Point( + basegfx::fround(aGridOffset.getX()), + basegfx::fround(aGridOffset.getY())); + } + + double nTol2(nTol); + + // double tolerance for OLE, text frames and objects in + // active text edit + if(bOLE || bTXT || pObj==static_cast<const SdrObjEditView*>(this)->GetTextEditObject()) + { + nTol2*=2; + } + + aRect.AdjustLeft( -nTol2 ); // add 1 tolerance for all objects + aRect.AdjustTop( -nTol2 ); + aRect.AdjustRight(nTol2 ); + aRect.AdjustBottom(nTol2 ); + + if (aRect.Contains(rPnt)) + { + if (!bCheckIfMarkable || IsObjMarkable(pObj,pPV)) + { + SdrObjList* pOL=pObj->GetSubList(); + + if (pOL!=nullptr && pOL->GetObjCount()!=0) + { + SdrObject* pTmpObj; + // adjustment hit point for virtual objects + Point aPnt( rPnt ); + + if ( auto pVirtObj = dynamic_cast<const SdrVirtObj*>( pObj) ) + { + Point aOffset = pVirtObj->GetOffset(); + aPnt.Move( -aOffset.X(), -aOffset.Y() ); + } + + pRet=CheckSingleSdrObjectHit(aPnt,nTol,pOL,pPV,nOptions,pMVisLay,pTmpObj); + } + else + { + if(!pMVisLay || pMVisLay->IsSet(pObj->GetLayer())) + { + pRet = SdrObjectPrimitiveHit(*pObj, rPnt, {nTol2, nTol2}, *pPV, &pPV->GetVisibleLayers(), false); + } + } + } + } + + if (!bDeep && pRet!=nullptr) + { + pRet=pObj; + } + + return pRet; +} + +SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj) const +{ + return (*this).CheckSingleSdrObjectHit(rPnt,nTol,pOL,pPV,nOptions,pMVisLay,rpRootObj,nullptr); +} +SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj,const SdrMarkList * pMarkList) const +{ + SdrObject* pRet=nullptr; + rpRootObj=nullptr; + if (!pOL) + return nullptr; + const E3dScene* pRemapScene = DynCastE3dScene(pOL->getSdrObjectFromSdrObjList()); + const size_t nObjCount(pOL->GetObjCount()); + size_t nObjNum(nObjCount); + + while (pRet==nullptr && nObjNum>0) + { + nObjNum--; + SdrObject* pObj; + + if(pRemapScene) + { + pObj = pOL->GetObj(pRemapScene->RemapOrdNum(nObjNum)); + } + else + { + pObj = pOL->GetObj(nObjNum); + } + if (nOptions & SdrSearchOptions::BEFOREMARK) + { + if (pMarkList!=nullptr) + { + if ((*pMarkList).FindObject(pObj)!=SAL_MAX_SIZE) + { + return nullptr; + } + } + } + pRet=CheckSingleSdrObjectHit(rPnt,nTol,pObj,pPV,nOptions,pMVisLay); + if (pRet!=nullptr) rpRootObj=pObj; + } + return pRet; +} + +SdrObject* SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions) const +{ + return PickObj(rPnt, nTol, rpPV, nOptions, nullptr); +} + +SdrObject* SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions, SdrObject** ppRootObj, bool* pbHitPassDirect) const +{ // TODO: lacks a Pass2,Pass3 + SortMarkedObjects(); + if (ppRootObj!=nullptr) *ppRootObj=nullptr; + if (pbHitPassDirect!=nullptr) *pbHitPassDirect=true; + SdrObject* pRet = nullptr; + rpPV=nullptr; + bool bMarked(nOptions & SdrSearchOptions::MARKED); + bool bMasters=!bMarked && bool(nOptions & SdrSearchOptions::ALSOONMASTER); + // nOptions & SdrSearchOptions::NEXT: n.i. + // nOptions & SdrSearchOptions::PASS2BOUND: n.i. + // nOptions & SdrSearchOptions::PASS3NEAREST// n.i. + if (nTol<0) nTol=ImpGetHitTolLogic(nTol,nullptr); + SdrObject* pObj=nullptr; + SdrObject* pHitObj=nullptr; + SdrPageView* pPV=nullptr; + if (static_cast<const SdrObjEditView*>(this)->IsTextEditFrameHit(rPnt)) { + pObj=static_cast<const SdrObjEditView*>(this)->GetTextEditObject(); + pHitObj=pObj; + pPV=static_cast<const SdrObjEditView*>(this)->GetTextEditPageView(); + } + if (bMarked) { + const size_t nMrkCnt=GetMarkedObjectCount(); + size_t nMrkNum=nMrkCnt; + while (pHitObj==nullptr && nMrkNum>0) { + nMrkNum--; + SdrMark* pM=GetSdrMarkByIndex(nMrkNum); + pObj=pM->GetMarkedSdrObj(); + pPV=pM->GetPageView(); + pHitObj=CheckSingleSdrObjectHit(rPnt,nTol,pObj,pPV,nOptions,nullptr); + } + } + else + { + pPV = GetSdrPageView(); + + if(pPV) + { + SdrPage* pPage=pPV->GetPage(); + sal_uInt16 nPgCount=1; + + if(bMasters && pPage->TRG_HasMasterPage()) + { + nPgCount++; + } + bool bWholePage(nOptions & SdrSearchOptions::WHOLEPAGE); + bool bExtraPassForWholePage=bWholePage && pPage!=pPV->GetObjList(); + if (bExtraPassForWholePage) nPgCount++; // First search in AktObjList, then on the entire page + sal_uInt16 nPgNum=nPgCount; + while (pHitObj==nullptr && nPgNum>0) { + SdrSearchOptions nTmpOptions=nOptions; + nPgNum--; + const SdrLayerIDSet* pMVisLay=nullptr; + SdrObjList* pObjList=nullptr; + if (pbHitPassDirect!=nullptr) *pbHitPassDirect = true; + if (nPgNum>=nPgCount-1 || (bExtraPassForWholePage && nPgNum>=nPgCount-2)) + { + pObjList=pPV->GetObjList(); + if (bExtraPassForWholePage && nPgNum==nPgCount-2) { + pObjList=pPage; + if (pbHitPassDirect!=nullptr) *pbHitPassDirect = false; + } + } + else + { + // otherwise MasterPage + SdrPage& rMasterPage = pPage->TRG_GetMasterPage(); + pMVisLay = &pPage->TRG_GetMasterPageVisibleLayers(); + pObjList = &rMasterPage; + + if (pbHitPassDirect!=nullptr) *pbHitPassDirect = false; + nTmpOptions=nTmpOptions | SdrSearchOptions::IMPISMASTER; + } + pHitObj=CheckSingleSdrObjectHit(rPnt,nTol,pObjList,pPV,nTmpOptions,pMVisLay,pObj,&(GetMarkedObjectList())); + } + } + } + if (pHitObj!=nullptr) { + if (ppRootObj!=nullptr) *ppRootObj=pObj; + if (nOptions & SdrSearchOptions::DEEP) pObj=pHitObj; + if (nOptions & SdrSearchOptions::TESTTEXTEDIT) { + if (!pObj->HasTextEdit() || pPV->GetLockedLayers().IsSet(pObj->GetLayer())) { + pObj=nullptr; + } + } + if (pObj!=nullptr && (nOptions & SdrSearchOptions::TESTMACRO)) { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos=rPnt; + aHitRec.nTol=nTol; + aHitRec.pVisiLayer=&pPV->GetVisibleLayers(); + aHitRec.pPageView=pPV; + if (!pObj->HasMacro() || !pObj->IsMacroHit(aHitRec)) pObj=nullptr; + } + if (pObj!=nullptr) { + pRet=pObj; + rpPV=pPV; + } + } + return pRet; +} + +bool SdrMarkView::PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const +{ + SortMarkedObjects(); + const bool bBoundCheckOn2ndPass(nOptions & SdrSearchOptions::PASS2BOUND); + rpObj=nullptr; + rpPV=nullptr; + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nMarkNum=nMarkCount; nMarkNum>0;) { + --nMarkNum; + SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrPageView* pPV=pM->GetPageView(); + SdrObject* pObj=pM->GetMarkedSdrObj(); + if (CheckSingleSdrObjectHit(rPnt,mnHitTolLog,pObj,pPV,SdrSearchOptions::TESTMARKABLE,nullptr)) { + rpObj=pObj; + rpPV=pPV; + return true; + } + } + if (bBoundCheckOn2ndPass) { + for (size_t nMarkNum=nMarkCount; nMarkNum>0;) { + --nMarkNum; + SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrPageView* pPV=pM->GetPageView(); + SdrObject* pObj=pM->GetMarkedSdrObj(); + tools::Rectangle aRect(pObj->GetCurrentBoundRect()); + aRect.AdjustLeft( -mnHitTolLog ); + aRect.AdjustTop( -mnHitTolLog ); + aRect.AdjustRight(mnHitTolLog ); + aRect.AdjustBottom(mnHitTolLog ); + if (aRect.Contains(rPnt)) { + rpObj=pObj; + rpPV=pPV; + return true; + } + } + } + return false; +} + + +void SdrMarkView::UnmarkAllObj(SdrPageView const * pPV) +{ + if (GetMarkedObjectCount()==0) + return; + + BrkAction(); + if (pPV!=nullptr) + { + GetMarkedObjectListWriteAccess().DeletePageView(*pPV); + } + else + { + GetMarkedObjectListWriteAccess().Clear(); + } + mpMarkedObj=nullptr; + mpMarkedPV=nullptr; + MarkListHasChanged(); + AdjustMarkHdl(); +} + +void SdrMarkView::MarkAllObj(SdrPageView* pPV) +{ + BrkAction(); + + if(!pPV) + { + pPV = GetSdrPageView(); + } + + // #i69171# pPV may still be NULL if there is no SDrPageView (!), e.g. when inserting + // other files + if(pPV) + { + const bool bMarkChg(GetMarkedObjectListWriteAccess().InsertPageView(*pPV)); + + if(bMarkChg) + { + MarkListHasChanged(); + } + } + + if(GetMarkedObjectCount()) + { + AdjustMarkHdl(); + } +} + +void SdrMarkView::AdjustMarkHdl(SfxViewShell* pOtherShell) +{ + CheckMarked(); + SetMarkRects(); + SetMarkHandles(pOtherShell); +} + +// BoundRect in model coordinates, no GridOffset added +tools::Rectangle SdrMarkView::GetMarkedObjBoundRect() const +{ + tools::Rectangle aRect; + for (size_t nm=0; nm<GetMarkedObjectCount(); ++nm) { + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pO=pM->GetMarkedSdrObj(); + tools::Rectangle aR1(pO->GetCurrentBoundRect()); + if (aRect.IsEmpty()) aRect=aR1; + else aRect.Union(aR1); + } + return aRect; +} + +// ObjRect in model coordinates, no GridOffset added +const tools::Rectangle& SdrMarkView::GetMarkedObjRect() const +{ + if (mbMarkedObjRectDirty) { + const_cast<SdrMarkView*>(this)->mbMarkedObjRectDirty=false; + tools::Rectangle aRect; + for (size_t nm=0; nm<GetMarkedObjectCount(); ++nm) { + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pO = pM->GetMarkedSdrObj(); + if (!pO) + continue; + tools::Rectangle aR1(pO->GetSnapRect()); + if (aRect.IsEmpty()) aRect=aR1; + else aRect.Union(aR1); + } + const_cast<SdrMarkView*>(this)->maMarkedObjRect=aRect; + } + return maMarkedObjRect; +} + + +OUString SdrMarkView::ImpGetDescriptionString(TranslateId pStrCacheID, ImpGetDescriptionOptions nOpt) const +{ + OUString sStr = SvxResId(pStrCacheID); + const sal_Int32 nPos = sStr.indexOf("%1"); + + if(nPos != -1) + { + if(nOpt == ImpGetDescriptionOptions::POINTS) + { + sStr = sStr.replaceAt(nPos, 2, GetDescriptionOfMarkedPoints()); + } + else if(nOpt == ImpGetDescriptionOptions::GLUEPOINTS) + { + sStr = sStr.replaceAt(nPos, 2, GetDescriptionOfMarkedGluePoints()); + } + else + { + sStr = sStr.replaceAt(nPos, 2, GetDescriptionOfMarkedObjects()); + } + } + + return sStr.replaceFirst("%2", "0"); +} + + +void SdrMarkView::EnterMarkedGroup() +{ + // We enter only the first group found (in only one PageView), because + // PageView::EnterGroup calls an AdjustMarkHdl. + // TODO: I'll have to prevent that via a flag. + SdrPageView* pPV = GetSdrPageView(); + + if(!pPV) + return; + + bool bEnter=false; + for (size_t nm = GetMarkedObjectCount(); nm > 0 && !bEnter;) + { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + if (pM->GetPageView()==pPV) { + SdrObject* pObj=pM->GetMarkedSdrObj(); + if (pObj->IsGroupObject()) { + if (pPV->EnterGroup(pObj)) { + bEnter=true; + } + } + } + } +} + + +void SdrMarkView::MarkListHasChanged() +{ + GetMarkedObjectListWriteAccess().SetNameDirty(); + maSdrViewSelection.SetEdgesOfMarkedNodesDirty(); + + mbMarkedObjRectDirty=true; + mbMarkedPointsRectsDirty=true; + bool bOneEdgeMarked=false; + if (GetMarkedObjectCount()==1) { + const SdrObject* pObj=GetMarkedObjectByIndex(0); + if (pObj->GetObjInventor()==SdrInventor::Default) { + bOneEdgeMarked = pObj->GetObjIdentifier() == SdrObjKind::Edge; + } + } + ImpSetGlueVisible4(bOneEdgeMarked); +} + + +void SdrMarkView::SetMoveOutside(bool bOn) +{ + maHdlList.SetMoveOutside(bOn); +} + +void SdrMarkView::SetDesignMode( bool bOn ) +{ + if ( mbDesignMode != bOn ) + { + mbDesignMode = bOn; + SdrPageView* pPageView = GetSdrPageView(); + if ( pPageView ) + pPageView->SetDesignMode( bOn ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |