From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- svx/source/svdraw/ActionDescriptionProvider.cxx | 66 + svx/source/svdraw/MediaShellHelpers.cxx | 108 + svx/source/svdraw/charthelper.cxx | 134 + svx/source/svdraw/clonelist.cxx | 107 + svx/source/svdraw/constructhelper.cxx | 191 + svx/source/svdraw/gradtrns.cxx | 531 +++ svx/source/svdraw/gradtrns.hxx | 56 + svx/source/svdraw/polypolygoneditor.cxx | 183 + .../svdraw/presetooxhandleadjustmentrelations.cxx | 343 ++ .../svdraw/presetooxhandleadjustmentrelations.hxx | 34 + svx/source/svdraw/sdrhittesthelper.cxx | 175 + svx/source/svdraw/sdrmasterpagedescriptor.cxx | 104 + svx/source/svdraw/sdrpagewindow.cxx | 533 +++ svx/source/svdraw/sdrpaintwindow.cxx | 337 ++ svx/source/svdraw/sdrundomanager.cxx | 184 + svx/source/svdraw/selectioncontroller.cxx | 125 + svx/source/svdraw/svdattr.cxx | 2060 +++++++++++ svx/source/svdraw/svdcrtv.cxx | 904 +++++ svx/source/svdraw/svddrag.cxx | 129 + svx/source/svdraw/svddrgm1.hxx | 232 ++ svx/source/svdraw/svddrgmt.cxx | 3861 ++++++++++++++++++++ svx/source/svdraw/svddrgv.cxx | 920 +++++ svx/source/svdraw/svdedtv.cxx | 1084 ++++++ svx/source/svdraw/svdedtv1.cxx | 2019 ++++++++++ svx/source/svdraw/svdedtv2.cxx | 2238 ++++++++++++ svx/source/svdraw/svdedxv.cxx | 3002 +++++++++++++++ svx/source/svdraw/svdetc.cxx | 704 ++++ svx/source/svdraw/svdfmtf.cxx | 1608 ++++++++ svx/source/svdraw/svdfmtf.hxx | 173 + svx/source/svdraw/svdglev.cxx | 402 ++ svx/source/svdraw/svdglue.cxx | 394 ++ svx/source/svdraw/svdhdl.cxx | 2674 ++++++++++++++ svx/source/svdraw/svdhlpln.cxx | 109 + svx/source/svdraw/svditer.cxx | 140 + svx/source/svdraw/svdlayer.cxx | 362 ++ svx/source/svdraw/svdmark.cxx | 780 ++++ svx/source/svdraw/svdmodel.cxx | 2009 ++++++++++ svx/source/svdraw/svdmrkv.cxx | 2735 ++++++++++++++ svx/source/svdraw/svdmrkv1.cxx | 547 +++ svx/source/svdraw/svdoashp.cxx | 3267 +++++++++++++++++ svx/source/svdraw/svdoattr.cxx | 98 + svx/source/svdraw/svdobj.cxx | 3434 +++++++++++++++++ svx/source/svdraw/svdobjplusdata.cxx | 63 + svx/source/svdraw/svdobjuserdatalist.cxx | 36 + svx/source/svdraw/svdocapt.cxx | 757 ++++ svx/source/svdraw/svdocirc.cxx | 1157 ++++++ svx/source/svdraw/svdoedge.cxx | 2715 ++++++++++++++ svx/source/svdraw/svdograf.cxx | 1252 +++++++ svx/source/svdraw/svdogrp.cxx | 794 ++++ svx/source/svdraw/svdomeas.cxx | 1429 ++++++++ svx/source/svdraw/svdomedia.cxx | 472 +++ svx/source/svdraw/svdoole2.cxx | 1996 ++++++++++ svx/source/svdraw/svdopage.cxx | 180 + svx/source/svdraw/svdopath.cxx | 2986 +++++++++++++++ svx/source/svdraw/svdorect.cxx | 573 +++ svx/source/svdraw/svdotext.cxx | 2251 ++++++++++++ svx/source/svdraw/svdotextdecomposition.cxx | 1838 ++++++++++ svx/source/svdraw/svdotextpathdecomposition.cxx | 748 ++++ svx/source/svdraw/svdotxat.cxx | 458 +++ svx/source/svdraw/svdotxdr.cxx | 253 ++ svx/source/svdraw/svdotxed.cxx | 360 ++ svx/source/svdraw/svdotxfl.cxx | 28 + svx/source/svdraw/svdotxln.cxx | 279 ++ svx/source/svdraw/svdotxtr.cxx | 498 +++ svx/source/svdraw/svdouno.cxx | 497 +++ svx/source/svdraw/svdoutl.cxx | 120 + svx/source/svdraw/svdoutlinercache.cxx | 95 + svx/source/svdraw/svdovirt.cxx | 586 +++ svx/source/svdraw/svdpage.cxx | 1877 ++++++++++ svx/source/svdraw/svdpagv.cxx | 895 +++++ svx/source/svdraw/svdpdf.cxx | 1046 ++++++ svx/source/svdraw/svdpntv.cxx | 1218 ++++++ svx/source/svdraw/svdpoev.cxx | 647 ++++ svx/source/svdraw/svdsnpv.cxx | 633 ++++ svx/source/svdraw/svdtext.cxx | 132 + svx/source/svdraw/svdtrans.cxx | 882 +++++ svx/source/svdraw/svdundo.cxx | 1789 +++++++++ svx/source/svdraw/svdview.cxx | 1553 ++++++++ svx/source/svdraw/svdviter.cxx | 126 + svx/source/svdraw/svdxcgv.cxx | 791 ++++ svx/source/svdraw/textchain.cxx | 128 + svx/source/svdraw/textchaincursor.cxx | 203 + svx/source/svdraw/textchainflow.cxx | 314 ++ 83 files changed, 73751 insertions(+) create mode 100644 svx/source/svdraw/ActionDescriptionProvider.cxx create mode 100644 svx/source/svdraw/MediaShellHelpers.cxx create mode 100644 svx/source/svdraw/charthelper.cxx create mode 100644 svx/source/svdraw/clonelist.cxx create mode 100644 svx/source/svdraw/constructhelper.cxx create mode 100644 svx/source/svdraw/gradtrns.cxx create mode 100644 svx/source/svdraw/gradtrns.hxx create mode 100644 svx/source/svdraw/polypolygoneditor.cxx create mode 100644 svx/source/svdraw/presetooxhandleadjustmentrelations.cxx create mode 100644 svx/source/svdraw/presetooxhandleadjustmentrelations.hxx create mode 100644 svx/source/svdraw/sdrhittesthelper.cxx create mode 100644 svx/source/svdraw/sdrmasterpagedescriptor.cxx create mode 100644 svx/source/svdraw/sdrpagewindow.cxx create mode 100644 svx/source/svdraw/sdrpaintwindow.cxx create mode 100644 svx/source/svdraw/sdrundomanager.cxx create mode 100644 svx/source/svdraw/selectioncontroller.cxx create mode 100644 svx/source/svdraw/svdattr.cxx create mode 100644 svx/source/svdraw/svdcrtv.cxx create mode 100644 svx/source/svdraw/svddrag.cxx create mode 100644 svx/source/svdraw/svddrgm1.hxx create mode 100644 svx/source/svdraw/svddrgmt.cxx create mode 100644 svx/source/svdraw/svddrgv.cxx create mode 100644 svx/source/svdraw/svdedtv.cxx create mode 100644 svx/source/svdraw/svdedtv1.cxx create mode 100644 svx/source/svdraw/svdedtv2.cxx create mode 100644 svx/source/svdraw/svdedxv.cxx create mode 100644 svx/source/svdraw/svdetc.cxx create mode 100644 svx/source/svdraw/svdfmtf.cxx create mode 100644 svx/source/svdraw/svdfmtf.hxx create mode 100644 svx/source/svdraw/svdglev.cxx create mode 100644 svx/source/svdraw/svdglue.cxx create mode 100644 svx/source/svdraw/svdhdl.cxx create mode 100644 svx/source/svdraw/svdhlpln.cxx create mode 100644 svx/source/svdraw/svditer.cxx create mode 100644 svx/source/svdraw/svdlayer.cxx create mode 100644 svx/source/svdraw/svdmark.cxx create mode 100644 svx/source/svdraw/svdmodel.cxx create mode 100644 svx/source/svdraw/svdmrkv.cxx create mode 100644 svx/source/svdraw/svdmrkv1.cxx create mode 100644 svx/source/svdraw/svdoashp.cxx create mode 100644 svx/source/svdraw/svdoattr.cxx create mode 100644 svx/source/svdraw/svdobj.cxx create mode 100644 svx/source/svdraw/svdobjplusdata.cxx create mode 100644 svx/source/svdraw/svdobjuserdatalist.cxx create mode 100644 svx/source/svdraw/svdocapt.cxx create mode 100644 svx/source/svdraw/svdocirc.cxx create mode 100644 svx/source/svdraw/svdoedge.cxx create mode 100644 svx/source/svdraw/svdograf.cxx create mode 100644 svx/source/svdraw/svdogrp.cxx create mode 100644 svx/source/svdraw/svdomeas.cxx create mode 100644 svx/source/svdraw/svdomedia.cxx create mode 100644 svx/source/svdraw/svdoole2.cxx create mode 100644 svx/source/svdraw/svdopage.cxx create mode 100644 svx/source/svdraw/svdopath.cxx create mode 100644 svx/source/svdraw/svdorect.cxx create mode 100644 svx/source/svdraw/svdotext.cxx create mode 100644 svx/source/svdraw/svdotextdecomposition.cxx create mode 100644 svx/source/svdraw/svdotextpathdecomposition.cxx create mode 100644 svx/source/svdraw/svdotxat.cxx create mode 100644 svx/source/svdraw/svdotxdr.cxx create mode 100644 svx/source/svdraw/svdotxed.cxx create mode 100644 svx/source/svdraw/svdotxfl.cxx create mode 100644 svx/source/svdraw/svdotxln.cxx create mode 100644 svx/source/svdraw/svdotxtr.cxx create mode 100644 svx/source/svdraw/svdouno.cxx create mode 100644 svx/source/svdraw/svdoutl.cxx create mode 100644 svx/source/svdraw/svdoutlinercache.cxx create mode 100644 svx/source/svdraw/svdovirt.cxx create mode 100644 svx/source/svdraw/svdpage.cxx create mode 100644 svx/source/svdraw/svdpagv.cxx create mode 100644 svx/source/svdraw/svdpdf.cxx create mode 100644 svx/source/svdraw/svdpntv.cxx create mode 100644 svx/source/svdraw/svdpoev.cxx create mode 100644 svx/source/svdraw/svdsnpv.cxx create mode 100644 svx/source/svdraw/svdtext.cxx create mode 100644 svx/source/svdraw/svdtrans.cxx create mode 100644 svx/source/svdraw/svdundo.cxx create mode 100644 svx/source/svdraw/svdview.cxx create mode 100644 svx/source/svdraw/svdviter.cxx create mode 100644 svx/source/svdraw/svdxcgv.cxx create mode 100644 svx/source/svdraw/textchain.cxx create mode 100644 svx/source/svdraw/textchaincursor.cxx create mode 100644 svx/source/svdraw/textchainflow.cxx (limited to 'svx/source/svdraw') diff --git a/svx/source/svdraw/ActionDescriptionProvider.cxx b/svx/source/svdraw/ActionDescriptionProvider.cxx new file mode 100644 index 0000000000..0dc5e895c7 --- /dev/null +++ b/svx/source/svdraw/ActionDescriptionProvider.cxx @@ -0,0 +1,66 @@ +/* -*- 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 +#include +#include + +OUString ActionDescriptionProvider::createDescription( ActionType eActionType + , std::u16string_view rObjectName ) +{ + TranslateId pResID; + switch( eActionType ) + { + case ActionType::Insert: + pResID=STR_UndoInsertObj; + break; + case ActionType::Delete: + pResID= STR_EditDelete; + break; + case ActionType::Move: + pResID= STR_EditMove; + break; + case ActionType::Resize: + pResID= STR_EditResize; + break; + case ActionType::Rotate: + pResID= STR_EditRotate; + break; + case ActionType::Format: + pResID= STR_EditSetAttributes; + break; + case ActionType::MoveToTop: + pResID= STR_EditMovToTop; + break; + case ActionType::MoveToBottom: + pResID= STR_EditMovToBtm; + break; + case ActionType::PosSize: + pResID = STR_EditPosSize; + break; + } + if (!pResID) + return OUString(); + + OUString aStr(SvxResId(pResID)); + return aStr.replaceAll("%1", rObjectName); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/MediaShellHelpers.cxx b/svx/source/svdraw/MediaShellHelpers.cxx new file mode 100644 index 0000000000..8cf760a7b0 --- /dev/null +++ b/svx/source/svdraw/MediaShellHelpers.cxx @@ -0,0 +1,108 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include + +namespace svx::MediaShellHelpers +{ +void GetState(const SdrMarkView* pSdrView, SfxItemSet& rSet) +{ + if (!pSdrView) + return; + + SfxWhichIter aIter(rSet); + + for (sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich()) + { + if (SID_AVMEDIA_TOOLBOX != nWhich) + continue; + +#if HAVE_FEATURE_AVMEDIA + const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList(); + bool bDisable = true; + + if (1 == rMarkList.GetMarkCount()) + { + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + + if (dynamic_cast(pObj)) + { + ::avmedia::MediaItem aItem(SID_AVMEDIA_TOOLBOX); + + static_cast(pObj->GetViewContact()) + .updateMediaItem(aItem); + rSet.Put(aItem); + bDisable = false; + } + } + + if (bDisable) +#endif + rSet.DisableItem(SID_AVMEDIA_TOOLBOX); + } +} + +const ::avmedia::MediaItem* Execute(const SdrMarkView* pSdrView, SfxRequest const& rReq) +{ +#if !HAVE_FEATURE_AVMEDIA + (void)pSdrView; + (void)rReq; + return nullptr; +#else + if (!pSdrView) + return nullptr; + + if (SID_AVMEDIA_TOOLBOX != rReq.GetSlot()) + return nullptr; + + const SfxItemSet* pArgs = rReq.GetArgs(); + if (!pArgs) + return nullptr; + + const ::avmedia::MediaItem* pMediaItem = pArgs->GetItemIfSet(SID_AVMEDIA_TOOLBOX, false); + if (!pMediaItem) + return nullptr; + + const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList(); + + if (1 != rMarkList.GetMarkCount()) + return nullptr; + + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + + if (!dynamic_cast(pObj)) + return nullptr; + + static_cast(pObj->GetViewContact()) + .executeMediaItem(*pMediaItem); + + return pMediaItem; +#endif +} + +} // end of namespace svx::MediaShellHelpers + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/charthelper.cxx b/svx/source/svdraw/charthelper.cxx new file mode 100644 index 0000000000..2c75be5d27 --- /dev/null +++ b/svx/source/svdraw/charthelper.cxx @@ -0,0 +1,134 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +void ChartHelper::updateChart( const uno::Reference< ::frame::XModel >& rXModel ) +{ + if (!rXModel.is()) + return; + + try + { + const uno::Reference< lang::XMultiServiceFactory > xChartFact(rXModel, uno::UNO_QUERY_THROW); + const uno::Reference< util::XUpdatable2 > xChartView(xChartFact->createInstance("com.sun.star.chart2.ChartView"), uno::UNO_QUERY_THROW); + + xChartView->updateHard(); + } + catch(uno::Exception&) + { + TOOLS_WARN_EXCEPTION("svx", ""); + } +} + +drawinglayer::primitive2d::Primitive2DContainer ChartHelper::tryToGetChartContentAsPrimitive2DSequence( + const uno::Reference< ::frame::XModel >& rXModel, + basegfx::B2DRange& rRange) +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if (!rXModel.is()) + return aRetval; + + // don't broadcast until we're finished building, more efficient + rXModel->lockControllers(); + updateChart(rXModel); + rXModel->unlockControllers(); + + try + { + const uno::Reference< drawing::XDrawPageSupplier > xDrawPageSupplier(rXModel, uno::UNO_QUERY_THROW); + const uno::Reference< container::XIndexAccess > xShapeAccess(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY_THROW); + + if(xShapeAccess->getCount()) + { + const sal_Int32 nShapeCount(xShapeAccess->getCount()); + const uno::Sequence< beans::PropertyValue > aParams; + uno::Reference< drawing::XShape > xShape; + + for(sal_Int32 a(0); a < nShapeCount; a++) + { + xShapeAccess->getByIndex(a) >>= xShape; + + if(xShape.is()) + { + PrimitiveFactory2D::createPrimitivesFromXShape( + xShape, + aParams, + aRetval); + } + } + } + } + catch(uno::Exception&) + { + TOOLS_WARN_EXCEPTION("svx", ""); + } + + if(!aRetval.empty()) + { + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + + rRange = aRetval.getB2DRange(aViewInformation2D); + } + + return aRetval; +} + +void ChartHelper::AdaptDefaultsForChart( + const uno::Reference < embed::XEmbeddedObject > & xEmbObj) +{ + if( !xEmbObj.is()) + return; + + uno::Reference< chart2::XChartDocument > xChartDoc( xEmbObj->getComponent(), uno::UNO_QUERY ); + OSL_ENSURE( xChartDoc.is(), "Trying to set chart property to non-chart OLE" ); + if( !xChartDoc.is()) + return; + + try + { + if (uno::Reference< beans::XPropertySet > xPageProp = xChartDoc->getPageBackground()) + { + // set background to transparent (none) + xPageProp->setPropertyValue("FillStyle", uno::Any(drawing::FillStyle_NONE)); + // set no border + xPageProp->setPropertyValue("LineStyle", uno::Any(drawing::LineStyle_NONE)); + } + } + catch( const uno::Exception & ) + { + TOOLS_WARN_EXCEPTION("svx.svdraw", ""); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/clonelist.cxx b/svx/source/svdraw/clonelist.cxx new file mode 100644 index 0000000000..ffb1ccc676 --- /dev/null +++ b/svx/source/svdraw/clonelist.cxx @@ -0,0 +1,107 @@ +/* -*- 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 . + */ + + +// #i13033# +// New mechanism to hold a list of all original and cloned objects for later +// re-creating the connections for contained connectors +#include +#include +#include + +void CloneList::AddPair(const SdrObject* pOriginal, SdrObject* pClone) +{ + maOriginalList.push_back(pOriginal); + maCloneList.push_back(pClone); + + // look for subobjects, too. + bool bOriginalIsGroup(pOriginal->IsGroupObject()); + bool bCloneIsGroup(pClone->IsGroupObject()); + + if(bOriginalIsGroup && DynCastE3dObject(pOriginal) != nullptr && DynCastE3dScene(pOriginal) == nullptr ) + bOriginalIsGroup = false; + + if(bCloneIsGroup && DynCastE3dObject(pClone) != nullptr && DynCastE3dScene(pClone) == nullptr) + bCloneIsGroup = false; + + if(!(bOriginalIsGroup && bCloneIsGroup)) + return; + + const SdrObjList* pOriginalList = pOriginal->GetSubList(); + SdrObjList* pCloneList = pClone->GetSubList(); + + if(pOriginalList && pCloneList + && pOriginalList->GetObjCount() == pCloneList->GetObjCount()) + { + for(size_t a = 0; a < pOriginalList->GetObjCount(); ++a) + { + // recursive call + AddPair(pOriginalList->GetObj(a), pCloneList->GetObj(a)); + } + } +} + +const SdrObject* CloneList::GetOriginal(sal_uInt32 nIndex) const +{ + return maOriginalList[nIndex]; +} + +SdrObject* CloneList::GetClone(sal_uInt32 nIndex) const +{ + return maCloneList[nIndex]; +} + +void CloneList::CopyConnections() const +{ + sal_uInt32 cloneCount = maCloneList.size(); + + for(size_t a = 0; a < maOriginalList.size(); a++) + { + const SdrEdgeObj* pOriginalEdge = dynamic_cast( GetOriginal(a) ); + SdrEdgeObj* pCloneEdge = dynamic_cast( GetClone(a) ); + + if(pOriginalEdge && pCloneEdge) + { + for (bool bTail1 : { true, false }) + { + SdrObject* pOriginalNode = pOriginalEdge->GetConnectedNode(bTail1); + if (pOriginalNode) + { + std::vector::const_iterator it = std::find(maOriginalList.begin(), + maOriginalList.end(), + pOriginalNode); + + if(it != maOriginalList.end()) + { + sal_uInt32 nPos = it - maOriginalList.begin(); + SdrObject *cObj = nullptr; + + if (nPos < cloneCount) + cObj = GetClone(nPos); + + if(pOriginalNode != cObj) + pCloneEdge->ConnectToNode(bTail1, cObj); + } + } + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/constructhelper.cxx b/svx/source/svdraw/constructhelper.cxx new file mode 100644 index 0000000000..d7c7f20a5c --- /dev/null +++ b/svx/source/svdraw/constructhelper.cxx @@ -0,0 +1,191 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//using namespace ::com::sun::star; + +::basegfx::B2DPolyPolygon ConstructHelper::GetLineEndPoly(TranslateId pResId, + const SdrModel& rModel) +{ + ::basegfx::B2DPolyPolygon aRetval; + XLineEndListRef pLineEndList(rModel.GetLineEndList()); + + if (pLineEndList.is()) + { + OUString aArrowName(SvxResId(pResId)); + tools::Long nCount = pLineEndList->Count(); + tools::Long nIndex; + for (nIndex = 0; nIndex < nCount; nIndex++) + { + const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nIndex); + if (pEntry->GetName() == aArrowName) + { + aRetval = pEntry->GetLineEnd(); + break; + } + } + } + + return aRetval; +} + +void ConstructHelper::SetLineEnds(SfxItemSet& rAttr, const SdrObject& rObj, sal_uInt16 nSlotId, + tools::Long nWidth) +{ + SdrModel& rModel(rObj.getSdrModelFromSdrObject()); + + if (!(nSlotId == SID_LINE_ARROW_START || nSlotId == SID_LINE_ARROW_END + || nSlotId == SID_LINE_ARROWS || nSlotId == SID_LINE_ARROW_CIRCLE + || nSlotId == SID_LINE_CIRCLE_ARROW || nSlotId == SID_LINE_ARROW_SQUARE + || nSlotId == SID_LINE_SQUARE_ARROW || nSlotId == SID_DRAW_MEASURELINE)) + return; + + // set attributes of line start and ends + + // arrowhead + ::basegfx::B2DPolyPolygon aArrow(GetLineEndPoly(RID_SVXSTR_ARROW, rModel)); + if (!aArrow.count()) + { + ::basegfx::B2DPolygon aNewArrow; + aNewArrow.append(::basegfx::B2DPoint(10.0, 0.0)); + aNewArrow.append(::basegfx::B2DPoint(0.0, 30.0)); + aNewArrow.append(::basegfx::B2DPoint(20.0, 30.0)); + aNewArrow.setClosed(true); + aArrow.append(aNewArrow); + } + + // Circles + ::basegfx::B2DPolyPolygon aCircle(GetLineEndPoly(RID_SVXSTR_CIRCLE, rModel)); + if (!aCircle.count()) + { + ::basegfx::B2DPolygon aNewCircle = ::basegfx::utils::createPolygonFromEllipse( + ::basegfx::B2DPoint(0.0, 0.0), 250.0, 250.0); + aNewCircle.setClosed(true); + aCircle.append(aNewCircle); + } + + // Square + ::basegfx::B2DPolyPolygon aSquare(GetLineEndPoly(RID_SVXSTR_SQUARE, rModel)); + if (!aSquare.count()) + { + ::basegfx::B2DPolygon aNewSquare; + aNewSquare.append(::basegfx::B2DPoint(0.0, 0.0)); + aNewSquare.append(::basegfx::B2DPoint(10.0, 0.0)); + aNewSquare.append(::basegfx::B2DPoint(10.0, 10.0)); + aNewSquare.append(::basegfx::B2DPoint(0.0, 10.0)); + aNewSquare.setClosed(true); + aSquare.append(aNewSquare); + } + + SfxItemSet aSet(rModel.GetItemPool()); + + // determine line width and calculate with it the line end width + if (aSet.GetItemState(XATTR_LINEWIDTH) != SfxItemState::DONTCARE) + { + tools::Long nValue = aSet.Get(XATTR_LINEWIDTH).GetValue(); + if (nValue > 0) + nWidth = nValue * 3; + } + + switch (nSlotId) + { + case SID_LINE_ARROWS: + case SID_DRAW_MEASURELINE: + { + // connector with arrow ends + rAttr.Put(XLineStartItem(SvxResId(RID_SVXSTR_ARROW), aArrow)); + rAttr.Put(XLineStartWidthItem(nWidth)); + rAttr.Put(XLineEndItem(SvxResId(RID_SVXSTR_ARROW), aArrow)); + rAttr.Put(XLineEndWidthItem(nWidth)); + } + break; + + case SID_LINE_ARROW_START: + case SID_LINE_ARROW_CIRCLE: + case SID_LINE_ARROW_SQUARE: + { + // connector with arrow start + rAttr.Put(XLineStartItem(SvxResId(RID_SVXSTR_ARROW), aArrow)); + rAttr.Put(XLineStartWidthItem(nWidth)); + } + break; + + case SID_LINE_ARROW_END: + case SID_LINE_CIRCLE_ARROW: + case SID_LINE_SQUARE_ARROW: + { + // connector with arrow end + rAttr.Put(XLineEndItem(SvxResId(RID_SVXSTR_ARROW), aArrow)); + rAttr.Put(XLineEndWidthItem(nWidth)); + } + break; + } + + // and again, for the still missing ends + switch (nSlotId) + { + case SID_LINE_ARROW_CIRCLE: + { + // circle end + rAttr.Put(XLineEndItem(SvxResId(RID_SVXSTR_CIRCLE), aCircle)); + rAttr.Put(XLineEndWidthItem(nWidth)); + } + break; + + case SID_LINE_CIRCLE_ARROW: + { + // circle start + rAttr.Put(XLineStartItem(SvxResId(RID_SVXSTR_CIRCLE), aCircle)); + rAttr.Put(XLineStartWidthItem(nWidth)); + } + break; + + case SID_LINE_ARROW_SQUARE: + { + // square end + rAttr.Put(XLineEndItem(SvxResId(RID_SVXSTR_SQUARE), aSquare)); + rAttr.Put(XLineEndWidthItem(nWidth)); + } + break; + + case SID_LINE_SQUARE_ARROW: + { + // square start + rAttr.Put(XLineStartItem(SvxResId(RID_SVXSTR_SQUARE), aSquare)); + rAttr.Put(XLineStartWidthItem(nWidth)); + } + break; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/gradtrns.cxx b/svx/source/svdraw/gradtrns.cxx new file mode 100644 index 0000000000..82a4ea0a29 --- /dev/null +++ b/svx/source/svdraw/gradtrns.cxx @@ -0,0 +1,531 @@ +/* -*- 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 "gradtrns.hxx" +#include +#include +#include +#include +#include +#include + + +void GradTransformer::GradToVec(GradTransGradient const & rG, GradTransVector& rV, const SdrObject* pObj) +{ + // handle start color + rV.aCol1 = Color(rG.aGradient.GetColorStops().front().getStopColor()); + if(100 != rG.aGradient.GetStartIntens()) + { + const double fFact(static_cast(rG.aGradient.GetStartIntens()) / 100.0); + rV.aCol1 = Color(rV.aCol1.getBColor() * fFact); + } + + // handle end color + rV.aCol2 = Color(rG.aGradient.GetColorStops().back().getStopColor()); + if(100 != rG.aGradient.GetEndIntens()) + { + const double fFact(static_cast(rG.aGradient.GetEndIntens()) / 100.0); + rV.aCol2 = Color(rV.aCol2.getBColor() * fFact); + } + + // calc the basic positions + const tools::Rectangle aObjectSnapRectangle(pObj->GetSnapRect()); + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aObjectSnapRectangle); + const basegfx::B2DPoint aCenter(aRange.getCenter()); + basegfx::B2DPoint aStartPos, aEndPos; + + switch(rG.aGradient.GetGradientStyle()) + { + case css::awt::GradientStyle_LINEAR : + { + aStartPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMinY()); + aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()); + + if(rG.aGradient.GetBorder()) + { + basegfx::B2DVector aFullVec(aStartPos - aEndPos); + const double fLen = (aFullVec.getLength() * (100.0 - static_cast(rG.aGradient.GetBorder()))) / 100.0; + aFullVec.normalize(); + aStartPos = aEndPos + (aFullVec * fLen); + } + + if(rG.aGradient.GetAngle()) + { + const double fAngle = toRadians(rG.aGradient.GetAngle()); + const basegfx::B2DHomMatrix aTransformation(basegfx::utils::createRotateAroundPoint(aCenter, -fAngle)); + + aStartPos *= aTransformation; + aEndPos *= aTransformation; + } + break; + } + case css::awt::GradientStyle_AXIAL : + { + aStartPos = aCenter; + aEndPos = basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()); + + if(rG.aGradient.GetBorder()) + { + basegfx::B2DVector aFullVec(aEndPos - aStartPos); + const double fLen = (aFullVec.getLength() * (100.0 - static_cast(rG.aGradient.GetBorder()))) / 100.0; + aFullVec.normalize(); + aEndPos = aStartPos + (aFullVec * fLen); + } + + if(rG.aGradient.GetAngle()) + { + const double fAngle = toRadians(rG.aGradient.GetAngle()); + const basegfx::B2DHomMatrix aTransformation(basegfx::utils::createRotateAroundPoint(aCenter, -fAngle)); + + aStartPos *= aTransformation; + aEndPos *= aTransformation; + } + break; + } + case css::awt::GradientStyle_RADIAL : + case css::awt::GradientStyle_SQUARE : + { + aStartPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMaximum().getY()); + aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY()); + + if(rG.aGradient.GetBorder()) + { + basegfx::B2DVector aFullVec(aStartPos - aEndPos); + const double fLen = (aFullVec.getLength() * (100.0 - static_cast(rG.aGradient.GetBorder()))) / 100.0; + aFullVec.normalize(); + aStartPos = aEndPos + (aFullVec * fLen); + } + + if(rG.aGradient.GetAngle()) + { + const double fAngle = toRadians(rG.aGradient.GetAngle()); + const basegfx::B2DHomMatrix aTransformation(basegfx::utils::createRotateAroundPoint(aEndPos, -fAngle)); + + aStartPos *= aTransformation; + aEndPos *= aTransformation; + } + + if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset()) + { + basegfx::B2DPoint aOffset( + (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0, + (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0); + + aStartPos += aOffset; + aEndPos += aOffset; + } + + break; + } + case css::awt::GradientStyle_ELLIPTICAL : + case css::awt::GradientStyle_RECT : + { + aStartPos = basegfx::B2DPoint(aRange.getMinX(), aCenter.getY()); + aEndPos = basegfx::B2DPoint(aRange.getMinX(), aRange.getMinY()); + + if(rG.aGradient.GetBorder()) + { + basegfx::B2DVector aFullVec(aStartPos - aEndPos); + const double fLen = (aFullVec.getLength() * (100.0 - static_cast(rG.aGradient.GetBorder()))) / 100.0; + aFullVec.normalize(); + aStartPos = aEndPos + (aFullVec * fLen); + } + + if(rG.aGradient.GetAngle()) + { + const double fAngle = toRadians(rG.aGradient.GetAngle()); + const basegfx::B2DHomMatrix aTransformation(basegfx::utils::createRotateAroundPoint(aEndPos, -fAngle)); + + aStartPos *= aTransformation; + aEndPos *= aTransformation; + } + + if(rG.aGradient.GetXOffset() || rG.aGradient.GetYOffset()) + { + basegfx::B2DPoint aOffset( + (aRange.getWidth() * rG.aGradient.GetXOffset()) / 100.0, + (aRange.getHeight() * rG.aGradient.GetYOffset()) / 100.0); + + aStartPos += aOffset; + aEndPos += aOffset; + } + + break; + } + default: + break; + } + + // set values for vector positions now + rV.maPositionA = aStartPos; + rV.maPositionB = aEndPos; +} + + +void GradTransformer::VecToGrad(GradTransVector const & rV, GradTransGradient& rG, GradTransGradient const & rGOld, const SdrObject* pObj, + bool bMoveSingle, bool bMoveFirst) +{ + // fill old gradient to new gradient to have a base + rG = rGOld; + + // handle color changes + if(rV.aCol1 != Color(rGOld.aGradient.GetColorStops().front().getStopColor())) + { + basegfx::BColorStops aNewColorStops(rG.aGradient.GetColorStops()); + aNewColorStops.replaceStartColor(rV.aCol1.getBColor()); + rG.aGradient.SetColorStops(aNewColorStops); + rG.aGradient.SetStartIntens(100); + } + if(rV.aCol2 != Color(rGOld.aGradient.GetColorStops().back().getStopColor())) + { + basegfx::BColorStops aNewColorStops(rG.aGradient.GetColorStops()); + aNewColorStops.replaceEndColor(rV.aCol2.getBColor()); + rG.aGradient.SetColorStops(aNewColorStops); + rG.aGradient.SetEndIntens(100); + } + + // calc the basic positions + const tools::Rectangle aObjectSnapRectangle(pObj->GetSnapRect()); + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aObjectSnapRectangle); + const basegfx::B2DPoint aCenter(aRange.getCenter()); + basegfx::B2DPoint aStartPos(rV.maPositionA); + basegfx::B2DPoint aEndPos(rV.maPositionB); + + switch(rG.aGradient.GetGradientStyle()) + { + case css::awt::GradientStyle_LINEAR : + { + if(!bMoveSingle || !bMoveFirst) + { + basegfx::B2DVector aFullVec(aEndPos - aStartPos); + + if(bMoveSingle) + { + aFullVec = aEndPos - aCenter; + } + + aFullVec.normalize(); + + double fNewFullAngle(basegfx::rad2deg(atan2(aFullVec.getY(), aFullVec.getX()))); + fNewFullAngle *= -10.0; + fNewFullAngle += 900.0; + + // clip + while(fNewFullAngle < 0.0) + { + fNewFullAngle += 3600.0; + } + + while(fNewFullAngle >= 3600.0) + { + fNewFullAngle -= 3600.0; + } + + // to int and set + Degree10 nNewAngle( FRound(fNewFullAngle)); + + if(nNewAngle != rGOld.aGradient.GetAngle()) + { + rG.aGradient.SetAngle(nNewAngle); + } + } + + if(!bMoveSingle || bMoveFirst) + { + const basegfx::B2DVector aFullVec(aEndPos - aStartPos); + const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY()); + const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY()); + const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft); + const double fFullLen(aFullVec.getLength()); + const double fOldLen(aOldVec.getLength()); + const double fNewBorder((fFullLen * 100.0) / fOldLen); + sal_Int32 nNewBorder(100 - FRound(fNewBorder)); + + // clip + if(nNewBorder < 0) + { + nNewBorder = 0; + } + + if(nNewBorder > 100) + { + nNewBorder = 100; + } + + // set + if(nNewBorder != rG.aGradient.GetBorder()) + { + rG.aGradient.SetBorder(static_cast(nNewBorder)); + } + } + + break; + } + case css::awt::GradientStyle_AXIAL : + { + if(!bMoveSingle || !bMoveFirst) + { + basegfx::B2DVector aFullVec(aEndPos - aCenter); + const basegfx::B2DVector aOldVec(basegfx::B2DPoint(aCenter.getX(), aRange.getMaximum().getY()) - aCenter); + const double fFullLen(aFullVec.getLength()); + const double fOldLen(aOldVec.getLength()); + const double fNewBorder((fFullLen * 100.0) / fOldLen); + sal_Int32 nNewBorder = 100 - FRound(fNewBorder); + + // clip + if(nNewBorder < 0) + { + nNewBorder = 0; + } + + if(nNewBorder > 100) + { + nNewBorder = 100; + } + + // set + if(nNewBorder != rG.aGradient.GetBorder()) + { + rG.aGradient.SetBorder(static_cast(nNewBorder)); + } + + aFullVec.normalize(); + double fNewFullAngle(basegfx::rad2deg(atan2(aFullVec.getY(), aFullVec.getX()))); + fNewFullAngle *= -10.0; + fNewFullAngle += 900.0; + + // clip + while(fNewFullAngle < 0.0) + { + fNewFullAngle += 3600.0; + } + + while(fNewFullAngle >= 3600.0) + { + fNewFullAngle -= 3600.0; + } + + // to int and set + const Degree10 nNewAngle(FRound(fNewFullAngle)); + + if(nNewAngle != rGOld.aGradient.GetAngle()) + { + rG.aGradient.SetAngle(nNewAngle); + } + } + + break; + } + case css::awt::GradientStyle_RADIAL : + case css::awt::GradientStyle_SQUARE : + { + if(!bMoveSingle || !bMoveFirst) + { + const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY()); + const basegfx::B2DPoint aOffset(aEndPos - aTopLeft); + sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth())); + sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight())); + + // clip + if(nNewXOffset < 0) + { + nNewXOffset = 0; + } + + if(nNewXOffset > 100) + { + nNewXOffset = 100; + } + + if(nNewYOffset < 0) + { + nNewYOffset = 0; + } + + if(nNewYOffset > 100) + { + nNewYOffset = 100; + } + + rG.aGradient.SetXOffset(static_cast(nNewXOffset)); + rG.aGradient.SetYOffset(static_cast(nNewYOffset)); + + aStartPos -= aOffset; + aEndPos -= aOffset; + } + + if(!bMoveSingle || bMoveFirst) + { + basegfx::B2DVector aFullVec(aStartPos - aEndPos); + const basegfx::B2DPoint aBottomLeft(aRange.getMinX(), aRange.getMaximum().getY()); + const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY()); + const basegfx::B2DVector aOldVec(aBottomLeft - aTopLeft); + const double fFullLen(aFullVec.getLength()); + const double fOldLen(aOldVec.getLength()); + const double fNewBorder((fFullLen * 100.0) / fOldLen); + sal_Int32 nNewBorder(100 - FRound(fNewBorder)); + + // clip + if(nNewBorder < 0) + { + nNewBorder = 0; + } + + if(nNewBorder > 100) + { + nNewBorder = 100; + } + + // set + if(nNewBorder != rG.aGradient.GetBorder()) + { + rG.aGradient.SetBorder(static_cast(nNewBorder)); + } + + // angle is not definitely necessary for these modes, but it makes + // controlling more fun for the user + aFullVec.normalize(); + double fNewFullAngle(basegfx::rad2deg(atan2(aFullVec.getY(), aFullVec.getX()))); + fNewFullAngle *= -10.0; + fNewFullAngle += 900.0; + + // clip + while(fNewFullAngle < 0.0) + { + fNewFullAngle += 3600.0; + } + + while(fNewFullAngle >= 3600.0) + { + fNewFullAngle -= 3600.0; + } + + // to int and set + const Degree10 nNewAngle(FRound(fNewFullAngle)); + + if(nNewAngle != rGOld.aGradient.GetAngle()) + { + rG.aGradient.SetAngle(nNewAngle); + } + } + + break; + } + case css::awt::GradientStyle_ELLIPTICAL : + case css::awt::GradientStyle_RECT : + { + if(!bMoveSingle || !bMoveFirst) + { + const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY()); + const basegfx::B2DPoint aOffset(aEndPos - aTopLeft); + sal_Int32 nNewXOffset(FRound((aOffset.getX() * 100.0) / aRange.getWidth())); + sal_Int32 nNewYOffset(FRound((aOffset.getY() * 100.0) / aRange.getHeight())); + + // clip + if(nNewXOffset < 0) + { + nNewXOffset = 0; + } + + if(nNewXOffset > 100) + { + nNewXOffset = 100; + } + + if(nNewYOffset < 0) + { + nNewYOffset = 0; + } + + if(nNewYOffset > 100) + { + nNewYOffset = 100; + } + + rG.aGradient.SetXOffset(static_cast(nNewXOffset)); + rG.aGradient.SetYOffset(static_cast(nNewYOffset)); + + aStartPos -= aOffset; + aEndPos -= aOffset; + } + + if(!bMoveSingle || bMoveFirst) + { + basegfx::B2DVector aFullVec(aStartPos - aEndPos); + const basegfx::B2DPoint aTopLeft(aRange.getMinX(), aRange.getMinY()); + const basegfx::B2DPoint aCenterLeft(aRange.getMinX(), aCenter.getY()); + const basegfx::B2DVector aOldVec(aCenterLeft - aTopLeft); + const double fFullLen(aFullVec.getLength()); + const double fOldLen(aOldVec.getLength()); + const double fNewBorder((fFullLen * 100.0) / fOldLen); + sal_Int32 nNewBorder(100 - FRound(fNewBorder)); + + // clip + if(nNewBorder < 0) + { + nNewBorder = 0; + } + + if(nNewBorder > 100) + { + nNewBorder = 100; + } + + // set + if(nNewBorder != rG.aGradient.GetBorder()) + { + rG.aGradient.SetBorder(static_cast(nNewBorder)); + } + + // angle is not definitely necessary for these modes, but it makes + // controlling more fun for the user + aFullVec.normalize(); + double fNewFullAngle(basegfx::rad2deg(atan2(aFullVec.getY(), aFullVec.getX()))); + fNewFullAngle *= -10.0; + fNewFullAngle += 900.0; + + // clip + while(fNewFullAngle < 0.0) + { + fNewFullAngle += 3600.0; + } + + while(fNewFullAngle >= 3600.0) + { + fNewFullAngle -= 3600.0; + } + + // to int and set + const Degree10 nNewAngle(FRound(fNewFullAngle)); + + if(nNewAngle != rGOld.aGradient.GetAngle()) + { + rG.aGradient.SetAngle(nNewAngle); + } + } + + break; + } + default: + break; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/gradtrns.hxx b/svx/source/svdraw/gradtrns.hxx new file mode 100644 index 0000000000..f53e236b73 --- /dev/null +++ b/svx/source/svdraw/gradtrns.hxx @@ -0,0 +1,56 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_SVDRAW_GRADTRNS_HXX +#define INCLUDED_SVX_SOURCE_SVDRAW_GRADTRNS_HXX + +#include +#include +#include + +class SdrObject; + +class GradTransVector +{ +public: + basegfx::B2DPoint maPositionA; + basegfx::B2DPoint maPositionB; + Color aCol1; + Color aCol2; +}; + +class GradTransGradient +{ +public: + basegfx::BGradient aGradient; +}; + +struct GradTransformer +{ + GradTransformer() = delete; + + static void GradToVec(GradTransGradient const & rG, GradTransVector& rV, + const SdrObject* pObj); + static void VecToGrad(GradTransVector const & rV, GradTransGradient& rG, + GradTransGradient const & rGOld, const SdrObject* pObj, bool bMoveSingle, bool bMoveFirst); +}; + +#endif // INCLUDED_SVX_SOURCE_SVDRAW_GRADTRNS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/polypolygoneditor.cxx b/svx/source/svdraw/polypolygoneditor.cxx new file mode 100644 index 0000000000..4a9c888454 --- /dev/null +++ b/svx/source/svdraw/polypolygoneditor.cxx @@ -0,0 +1,183 @@ +/* -*- 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 +#include + +#include +#include + +namespace sdr { + +PolyPolygonEditor::PolyPolygonEditor( basegfx::B2DPolyPolygon aPolyPolygon) +: maPolyPolygon(std::move( aPolyPolygon )) +{ +} + +bool PolyPolygonEditor::DeletePoints( const o3tl::sorted_vector< sal_uInt16 >& rAbsPoints ) +{ + bool bPolyPolyChanged = false; + + auto aIter( rAbsPoints.rbegin() ); + for( ; aIter != rAbsPoints.rend(); ++aIter ) + { + sal_uInt32 nPoly, nPnt; + if( GetRelativePolyPoint(maPolyPolygon,(*aIter), nPoly, nPnt) ) + { + // remove point + basegfx::B2DPolygon aCandidate(maPolyPolygon.getB2DPolygon(nPoly)); + + aCandidate.remove(nPnt); + + + if( aCandidate.count() < 2 ) + { + maPolyPolygon.remove(nPoly); + } + else + { + maPolyPolygon.setB2DPolygon(nPoly, aCandidate); + } + + bPolyPolyChanged = true; + } + } + + return bPolyPolyChanged; +} + +bool PolyPolygonEditor::SetSegmentsKind(SdrPathSegmentKind eKind, const o3tl::sorted_vector< sal_uInt16 >& rAbsPoints ) +{ + bool bPolyPolyChanged = false; + + auto aIter( rAbsPoints.rbegin() ); + for( ; aIter != rAbsPoints.rend(); ++aIter ) + { + sal_uInt32 nPolyNum, nPntNum; + + if(PolyPolygonEditor::GetRelativePolyPoint(maPolyPolygon, (*aIter), nPolyNum, nPntNum)) + { + // do change at aNewPolyPolygon. Take a look at edge. + basegfx::B2DPolygon aCandidate(maPolyPolygon.getB2DPolygon(nPolyNum)); + const sal_uInt32 nCount(aCandidate.count()); + + if(nCount && (nPntNum + 1 < nCount || aCandidate.isClosed())) + { + bool bCandidateChanged(false); + + // it's a valid edge, check control point usage + const sal_uInt32 nNextIndex((nPntNum + 1) % nCount); + const bool bContolUsed(aCandidate.areControlPointsUsed() + && (aCandidate.isNextControlPointUsed(nPntNum) || aCandidate.isPrevControlPointUsed(nNextIndex))); + + if(bContolUsed) + { + if(SdrPathSegmentKind::Toggle == eKind || SdrPathSegmentKind::Line == eKind) + { + // remove control + aCandidate.resetNextControlPoint(nPntNum); + aCandidate.resetPrevControlPoint(nNextIndex); + bCandidateChanged = true; + } + } + else + { + if(SdrPathSegmentKind::Toggle == eKind || SdrPathSegmentKind::Curve == eKind) + { + // add control + const basegfx::B2DPoint aStart(aCandidate.getB2DPoint(nPntNum)); + const basegfx::B2DPoint aEnd(aCandidate.getB2DPoint(nNextIndex)); + + aCandidate.setNextControlPoint(nPntNum, interpolate(aStart, aEnd, (1.0 / 3.0))); + aCandidate.setPrevControlPoint(nNextIndex, interpolate(aStart, aEnd, (2.0 / 3.0))); + bCandidateChanged = true; + } + } + + if(bCandidateChanged) + { + maPolyPolygon.setB2DPolygon(nPolyNum, aCandidate); + bPolyPolyChanged = true; + } + } + } + } + + return bPolyPolyChanged; +} + +bool PolyPolygonEditor::SetPointsSmooth( basegfx::B2VectorContinuity eFlags, const o3tl::sorted_vector< sal_uInt16 >& rAbsPoints) +{ + bool bPolyPolygonChanged(false); + + auto aIter( rAbsPoints.rbegin() ); + for( ; aIter != rAbsPoints.rend(); ++aIter ) + { + sal_uInt32 nPolyNum, nPntNum; + + if(PolyPolygonEditor::GetRelativePolyPoint(maPolyPolygon, (*aIter), nPolyNum, nPntNum)) + { + // do change at aNewPolyPolygon... + basegfx::B2DPolygon aCandidate(maPolyPolygon.getB2DPolygon(nPolyNum)); + + // set continuity in point, make sure there is a curve + bool bPolygonChanged = basegfx::utils::expandToCurveInPoint(aCandidate, nPntNum); + bPolygonChanged |= basegfx::utils::setContinuityInPoint(aCandidate, nPntNum, eFlags); + + if(bPolygonChanged) + { + maPolyPolygon.setB2DPolygon(nPolyNum, aCandidate); + bPolyPolygonChanged = true; + } + } + } + + return bPolyPolygonChanged; +} + +bool PolyPolygonEditor::GetRelativePolyPoint( const basegfx::B2DPolyPolygon& rPoly, sal_uInt32 nAbsPnt, sal_uInt32& rPolyNum, sal_uInt32& rPointNum ) +{ + const sal_uInt32 nPolyCount(rPoly.count()); + sal_uInt32 nPolyNum(0); + + while(nPolyNum < nPolyCount) + { + const sal_uInt32 nPointCount(rPoly.getB2DPolygon(nPolyNum).count()); + + if(nAbsPnt < nPointCount) + { + rPolyNum = nPolyNum; + rPointNum = nAbsPnt; + + return true; + } + else + { + nPolyNum++; + nAbsPnt -= nPointCount; + } + } + + return false; +} + +} // end of namespace sdr + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/presetooxhandleadjustmentrelations.cxx b/svx/source/svdraw/presetooxhandleadjustmentrelations.cxx new file mode 100644 index 0000000000..528c8b35cd --- /dev/null +++ b/svx/source/svdraw/presetooxhandleadjustmentrelations.cxx @@ -0,0 +1,343 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include + +#include + +#include +#include +#include +#include "presetooxhandleadjustmentrelations.hxx" + +namespace +{ +typedef std::unordered_map HandleAdjRelHashMap; + +struct HandleAdjRel +{ + // Shape name without leading "ooxml-", underscore, zero based handle index + // e.g. The third handle in shape of type "ooxml-circularArrow" will be + // identified by key "circularArrow_2" + const char* sShape_Handle; + + // 4 tokens with separator "|" + // first: RefX or RefR, na if not exists + // second: adj, or adj1 or adj2, etc. as in preset, na if not exists + // third: RefY or RefAngle, na if not exists + // forth: adj, or adj1 or adj2, etc. as in preset, na if not exists + // e.g. The third handle in shape has in the preset + // the tag . + // The resulting value in the map here is "RefR|adj5|na|na" + const char* sAdjReferences; +}; + +// The array initializer has been extracted from +// oox/source/drawingml/customshapes/presetShapeDefinitions.xml +// by using an XSLT file. That file is attached to tdf#126512. +constexpr HandleAdjRel aHandleAdjRelArray[] + = { { "accentBorderCallout1_0", "RefX|adj2|RefY|adj1" }, + { "accentBorderCallout1_1", "RefX|adj4|RefY|adj3" }, + { "accentBorderCallout2_0", "RefX|adj2|RefY|adj1" }, + { "accentBorderCallout2_1", "RefX|adj4|RefY|adj3" }, + { "accentBorderCallout2_2", "RefX|adj6|RefY|adj5" }, + { "accentBorderCallout3_0", "RefX|adj2|RefY|adj1" }, + { "accentBorderCallout3_1", "RefX|adj4|RefY|adj3" }, + { "accentBorderCallout3_2", "RefX|adj6|RefY|adj5" }, + { "accentBorderCallout3_3", "RefX|adj8|RefY|adj7" }, + { "accentCallout1_0", "RefX|adj2|RefY|adj1" }, + { "accentCallout1_1", "RefX|adj4|RefY|adj3" }, + { "accentCallout2_0", "RefX|adj2|RefY|adj1" }, + { "accentCallout2_1", "RefX|adj4|RefY|adj3" }, + { "accentCallout2_2", "RefX|adj6|RefY|adj5" }, + { "accentCallout3_0", "RefX|adj2|RefY|adj1" }, + { "accentCallout3_1", "RefX|adj4|RefY|adj3" }, + { "accentCallout3_2", "RefX|adj6|RefY|adj5" }, + { "accentCallout3_3", "RefX|adj8|RefY|adj7" }, + { "arc_0", "na|na|RefAngle|adj1" }, + { "arc_1", "na|na|RefAngle|adj2" }, + { "bentArrow_0", "RefX|adj1|na|na" }, + { "bentArrow_1", "na|na|RefY|adj2" }, + { "bentArrow_2", "RefX|adj3|na|na" }, + { "bentArrow_3", "RefX|adj4|na|na" }, + { "bentConnector3_0", "RefX|adj1|na|na" }, + { "bentConnector4_0", "RefX|adj1|na|na" }, + { "bentConnector4_1", "na|na|RefY|adj2" }, + { "bentConnector5_0", "RefX|adj1|na|na" }, + { "bentConnector5_1", "na|na|RefY|adj2" }, + { "bentConnector5_2", "RefX|adj3|na|na" }, + { "bentUpArrow_0", "na|na|RefY|adj1" }, + { "bentUpArrow_1", "RefX|adj2|na|na" }, + { "bentUpArrow_2", "na|na|RefY|adj3" }, + { "bevel_0", "RefX|adj|na|na" }, + { "blockArc_0", "na|na|RefAngle|adj1" }, + { "blockArc_1", "RefR|adj3|RefAngle|adj2" }, + { "borderCallout1_0", "RefX|adj2|RefY|adj1" }, + { "borderCallout1_1", "RefX|adj4|RefY|adj3" }, + { "borderCallout2_0", "RefX|adj2|RefY|adj1" }, + { "borderCallout2_1", "RefX|adj4|RefY|adj3" }, + { "borderCallout2_2", "RefX|adj6|RefY|adj5" }, + { "borderCallout3_0", "RefX|adj2|RefY|adj1" }, + { "borderCallout3_1", "RefX|adj4|RefY|adj3" }, + { "borderCallout3_2", "RefX|adj6|RefY|adj5" }, + { "borderCallout3_3", "RefX|adj8|RefY|adj7" }, + { "bracePair_0", "na|na|RefY|adj" }, + { "bracketPair_0", "na|na|RefY|adj" }, + { "callout1_0", "RefX|adj2|RefY|adj1" }, + { "callout1_1", "RefX|adj4|RefY|adj3" }, + { "callout2_0", "RefX|adj2|RefY|adj1" }, + { "callout2_1", "RefX|adj4|RefY|adj3" }, + { "callout2_2", "RefX|adj6|RefY|adj5" }, + { "callout3_0", "RefX|adj2|RefY|adj1" }, + { "callout3_1", "RefX|adj4|RefY|adj3" }, + { "callout3_2", "RefX|adj6|RefY|adj5" }, + { "callout3_3", "RefX|adj8|RefY|adj7" }, + { "can_0", "na|na|RefY|adj" }, + { "chevron_0", "RefX|adj|na|na" }, + { "chord_0", "na|na|RefAngle|adj1" }, + { "chord_1", "na|na|RefAngle|adj2" }, + { "circularArrow_0", "na|na|RefAngle|adj2" }, + { "circularArrow_1", "na|na|RefAngle|adj4" }, + { "circularArrow_2", "RefR|adj1|RefAngle|adj3" }, + { "circularArrow_3", "RefR|adj5|na|na" }, + { "cloudCallout_0", "RefX|adj1|RefY|adj2" }, + { "corner_0", "na|na|RefY|adj1" }, + { "corner_1", "RefX|adj2|na|na" }, + { "cube_0", "na|na|RefY|adj" }, + { "curvedConnector3_0", "RefX|adj1|na|na" }, + { "curvedConnector4_0", "RefX|adj1|na|na" }, + { "curvedConnector4_1", "na|na|RefY|adj2" }, + { "curvedConnector5_0", "RefX|adj1|na|na" }, + { "curvedConnector5_1", "na|na|RefY|adj2" }, + { "curvedConnector5_2", "RefX|adj3|na|na" }, + { "curvedDownArrow_0", "RefX|adj1|na|na" }, + { "curvedDownArrow_1", "RefX|adj2|na|na" }, + { "curvedDownArrow_2", "na|na|RefY|adj3" }, + { "curvedLeftArrow_0", "na|na|RefY|adj1" }, + { "curvedLeftArrow_1", "na|na|RefY|adj2" }, + { "curvedLeftArrow_2", "RefX|adj3|na|na" }, + { "curvedRightArrow_0", "na|na|RefY|adj1" }, + { "curvedRightArrow_1", "na|na|RefY|adj2" }, + { "curvedRightArrow_2", "RefX|adj3|na|na" }, + { "curvedUpArrow_0", "RefX|adj1|na|na" }, + { "curvedUpArrow_1", "RefX|adj2|na|na" }, + { "curvedUpArrow_2", "na|na|RefY|adj3" }, + { "diagStripe_0", "na|na|RefY|adj" }, + { "donut_0", "RefR|adj|na|na" }, + { "doubleWave_0", "na|na|RefY|adj1" }, + { "doubleWave_1", "RefX|adj2|na|na" }, + { "downArrow_0", "RefX|adj1|na|na" }, + { "downArrow_1", "na|na|RefY|adj2" }, + { "downArrowCallout_0", "RefX|adj1|na|na" }, + { "downArrowCallout_1", "RefX|adj2|na|na" }, + { "downArrowCallout_2", "na|na|RefY|adj3" }, + { "downArrowCallout_3", "na|na|RefY|adj4" }, + { "ellipseRibbon_0", "na|na|RefY|adj1" }, + { "ellipseRibbon_1", "RefX|adj2|na|na" }, + { "ellipseRibbon_2", "na|na|RefY|adj3" }, + { "ellipseRibbon2_0", "na|na|RefY|adj1" }, + { "ellipseRibbon2_1", "RefX|adj2|na|na" }, + { "ellipseRibbon2_2", "na|na|RefY|adj3" }, + { "foldedCorner_0", "RefX|adj|na|na" }, + { "frame_0", "RefX|adj1|na|na" }, + { "gear6_0", "na|na|RefY|adj1" }, + { "gear6_1", "RefX|adj2|na|na" }, + { "gear9_0", "na|na|RefY|adj1" }, + { "gear9_1", "RefX|adj2|na|na" }, + { "halfFrame_0", "na|na|RefY|adj1" }, + { "halfFrame_1", "RefX|adj2|na|na" }, + { "hexagon_0", "RefX|adj|na|na" }, + { "homePlate_0", "RefX|adj|na|na" }, + { "horizontalScroll_0", "RefX|adj|na|na" }, + { "leftArrow_0", "na|na|RefY|adj1" }, + { "leftArrow_1", "RefX|adj2|na|na" }, + { "leftArrowCallout_0", "na|na|RefY|adj1" }, + { "leftArrowCallout_1", "na|na|RefY|adj2" }, + { "leftArrowCallout_2", "RefX|adj3|na|na" }, + { "leftArrowCallout_3", "RefX|adj4|na|na" }, + { "leftBrace_0", "na|na|RefY|adj1" }, + { "leftBrace_1", "na|na|RefY|adj2" }, + { "leftBracket_0", "na|na|RefY|adj" }, + { "leftCircularArrow_0", "na|na|RefAngle|adj2" }, + { "leftCircularArrow_1", "na|na|RefAngle|adj4" }, + { "leftCircularArrow_2", "RefR|adj1|RefAngle|adj3" }, + { "leftCircularArrow_3", "RefR|adj5|na|na" }, + { "leftRightArrow_0", "na|na|RefY|adj1" }, + { "leftRightArrow_1", "RefX|adj2|na|na" }, + { "leftRightArrowCallout_0", "na|na|RefY|adj1" }, + { "leftRightArrowCallout_1", "na|na|RefY|adj2" }, + { "leftRightArrowCallout_2", "RefX|adj3|na|na" }, + { "leftRightArrowCallout_3", "RefX|adj4|na|na" }, + { "leftRightCircularArrow_0", "na|na|RefAngle|adj2" }, + { "leftRightCircularArrow_1", "na|na|RefAngle|adj4" }, + { "leftRightCircularArrow_2", "RefR|adj1|RefAngle|adj3" }, + { "leftRightCircularArrow_3", "RefR|adj5|na|na" }, + { "leftRightRibbon_0", "na|na|RefY|adj1" }, + { "leftRightRibbon_1", "RefX|adj2|na|na" }, + { "leftRightRibbon_2", "na|na|RefY|adj3" }, + { "leftRightUpArrow_0", "RefX|adj1|na|na" }, + { "leftRightUpArrow_1", "RefX|adj2|na|na" }, + { "leftRightUpArrow_2", "na|na|RefY|adj3" }, + { "leftUpArrow_0", "na|na|RefY|adj1" }, + { "leftUpArrow_1", "RefX|adj2|na|na" }, + { "leftUpArrow_2", "na|na|RefY|adj3" }, + { "mathDivide_0", "na|na|RefY|adj1" }, + { "mathDivide_1", "na|na|RefY|adj2" }, + { "mathDivide_2", "RefX|adj3|na|na" }, + { "mathEqual_0", "na|na|RefY|adj1" }, + { "mathEqual_1", "na|na|RefY|adj2" }, + { "mathMinus_0", "na|na|RefY|adj1" }, + { "mathMultiply_0", "na|na|RefY|adj1" }, + { "mathNotEqual_0", "na|na|RefY|adj1" }, + { "mathNotEqual_1", "na|na|RefAngle|adj2" }, + { "mathNotEqual_2", "na|na|RefY|adj3" }, + { "mathPlus_0", "na|na|RefY|adj1" }, + { "moon_0", "RefX|adj|na|na" }, + { "nonIsoscelesTrapezoid_0", "RefX|adj1|na|na" }, + { "nonIsoscelesTrapezoid_1", "RefX|adj2|na|na" }, + { "noSmoking_0", "RefR|adj|na|na" }, + { "notchedRightArrow_0", "na|na|RefY|adj1" }, + { "notchedRightArrow_1", "RefX|adj2|na|na" }, + { "octagon_0", "RefX|adj|na|na" }, + { "parallelogram_0", "RefX|adj|na|na" }, + { "pie_0", "na|na|RefAngle|adj1" }, + { "pie_1", "na|na|RefAngle|adj2" }, + { "plaque_0", "RefX|adj|na|na" }, + { "plus_0", "RefX|adj|na|na" }, + { "quadArrow_0", "RefX|adj1|na|na" }, + { "quadArrow_1", "RefX|adj2|na|na" }, + { "quadArrow_2", "na|na|RefY|adj3" }, + { "quadArrowCallout_0", "RefX|adj1|na|na" }, + { "quadArrowCallout_1", "RefX|adj2|na|na" }, + { "quadArrowCallout_2", "na|na|RefY|adj3" }, + { "quadArrowCallout_3", "na|na|RefY|adj4" }, + { "ribbon_0", "na|na|RefY|adj1" }, + { "ribbon_1", "RefX|adj2|na|na" }, + { "ribbon2_0", "na|na|RefY|adj1" }, + { "ribbon2_1", "RefX|adj2|na|na" }, + { "rightArrow_0", "na|na|RefY|adj1" }, + { "rightArrow_1", "RefX|adj2|na|na" }, + { "rightArrowCallout_0", "na|na|RefY|adj1" }, + { "rightArrowCallout_1", "na|na|RefY|adj2" }, + { "rightArrowCallout_2", "RefX|adj3|na|na" }, + { "rightArrowCallout_3", "RefX|adj4|na|na" }, + { "rightBrace_0", "na|na|RefY|adj1" }, + { "rightBrace_1", "na|na|RefY|adj2" }, + { "rightBracket_0", "na|na|RefY|adj" }, + { "round1Rect_0", "RefX|adj|na|na" }, + { "round2DiagRect_0", "RefX|adj1|na|na" }, + { "round2DiagRect_1", "RefX|adj2|na|na" }, + { "round2SameRect_0", "RefX|adj1|na|na" }, + { "round2SameRect_1", "RefX|adj2|na|na" }, + { "roundRect_0", "RefX|adj|na|na" }, + { "smileyFace_0", "na|na|RefY|adj" }, + { "snip1Rect_0", "RefX|adj|na|na" }, + { "snip2DiagRect_0", "RefX|adj1|na|na" }, + { "snip2DiagRect_1", "RefX|adj2|na|na" }, + { "snip2SameRect_0", "RefX|adj1|na|na" }, + { "snip2SameRect_1", "RefX|adj2|na|na" }, + { "snipRoundRect_0", "RefX|adj1|na|na" }, + { "snipRoundRect_1", "RefX|adj2|na|na" }, + { "star10_0", "na|na|RefY|adj" }, + { "star12_0", "na|na|RefY|adj" }, + { "star16_0", "na|na|RefY|adj" }, + { "star24_0", "na|na|RefY|adj" }, + { "star32_0", "na|na|RefY|adj" }, + { "star4_0", "na|na|RefY|adj" }, + { "star5_0", "na|na|RefY|adj" }, + { "star6_0", "na|na|RefY|adj" }, + { "star7_0", "na|na|RefY|adj" }, + { "star8_0", "na|na|RefY|adj" }, + { "stripedRightArrow_0", "na|na|RefY|adj1" }, + { "stripedRightArrow_1", "RefX|adj2|na|na" }, + { "sun_0", "RefX|adj|na|na" }, + { "swooshArrow_0", "na|na|RefY|adj1" }, + { "swooshArrow_1", "RefX|adj2|na|na" }, + { "teardrop_0", "RefX|adj|na|na" }, + { "trapezoid_0", "RefX|adj|na|na" }, + { "triangle_0", "RefX|adj|na|na" }, + { "upArrowCallout_0", "RefX|adj1|na|na" }, + { "upArrowCallout_1", "RefX|adj2|na|na" }, + { "upArrowCallout_2", "na|na|RefY|adj3" }, + { "upArrowCallout_3", "na|na|RefY|adj4" }, + { "upDownArrow_0", "RefX|adj1|na|na" }, + { "upDownArrow_1", "na|na|RefY|adj2" }, + { "upArrow_0", "RefX|adj1|na|na" }, + { "upArrow_1", "na|na|RefY|adj2" }, + { "upDownArrowCallout_0", "RefX|adj1|na|na" }, + { "upDownArrowCallout_1", "RefX|adj2|na|na" }, + { "upDownArrowCallout_2", "na|na|RefY|adj3" }, + { "upDownArrowCallout_3", "na|na|RefY|adj4" }, + { "uturnArrow_0", "RefX|adj1|na|na" }, + { "uturnArrow_1", "RefX|adj2|na|na" }, + { "uturnArrow_2", "na|na|RefY|adj3" }, + { "uturnArrow_3", "RefX|adj4|na|na" }, + { "uturnArrow_4", "na|na|RefY|adj5" }, + { "verticalScroll_0", "na|na|RefY|adj" }, + { "wave_0", "na|na|RefY|adj1" }, + { "wave_1", "RefX|adj2|na|na" }, + { "wedgeEllipseCallout_0", "RefX|adj1|RefY|adj2" }, + { "wedgeRectCallout_0", "RefX|adj1|RefY|adj2" }, + { "wedgeRoundRectCallout_0", "RefX|adj1|RefY|adj2" } }; +} + +static sal_Int32 lcl_getAdjIndexFromToken(const sal_Int32 nTokenPos, std::u16string_view rMapValue) +{ + std::u16string_view sAdjRef = o3tl::getToken(rMapValue, nTokenPos, '|'); + std::u16string_view sNumber; // number part from "adj1", "adj2" etc. + if (o3tl::starts_with(sAdjRef, u"adj", &sNumber)) + { + if (sNumber.empty() || sNumber == u"1") + return 0; + else + return o3tl::toInt32(sNumber) - 1; + } + else + return -1; +} + +void PresetOOXHandleAdj::GetOOXHandleAdjRelation( + std::u16string_view sFullOOXShapeName, const sal_Int32 nHandleIndex, OUString& rFirstRefType, + sal_Int32& rFirstAdjValueIndex, OUString& rSecondRefType, sal_Int32& rSecondAdjValueIndex) +{ + static const HandleAdjRelHashMap s_HashMap = []() { + HandleAdjRelHashMap aH; + aH.reserve(std::size(aHandleAdjRelArray)); + for (const auto& item : aHandleAdjRelArray) + aH.emplace(OUString::createFromAscii(item.sShape_Handle), + OUString::createFromAscii(item.sAdjReferences)); + return aH; + }(); + + std::u16string_view sKey; + OUString sValue; + rFirstRefType = "na"; + rFirstAdjValueIndex = -1; + rSecondRefType = "na"; + rSecondAdjValueIndex = -1; + if (o3tl::starts_with(sFullOOXShapeName, u"ooxml-", &sKey)) + { + HandleAdjRelHashMap::const_iterator aHashIter( + s_HashMap.find(OUString::Concat(sKey) + "_" + OUString::number(nHandleIndex))); + if (aHashIter != s_HashMap.end()) + sValue = (*aHashIter).second; + else + return; + } + else + return; + + rFirstRefType = sValue.getToken(0, '|'); + rFirstAdjValueIndex = lcl_getAdjIndexFromToken(1, sValue); + rSecondRefType = sValue.getToken(2, '|'); + rSecondAdjValueIndex = lcl_getAdjIndexFromToken(3, sValue); + return; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/svdraw/presetooxhandleadjustmentrelations.hxx b/svx/source/svdraw/presetooxhandleadjustmentrelations.hxx new file mode 100644 index 0000000000..b9404e5987 --- /dev/null +++ b/svx/source/svdraw/presetooxhandleadjustmentrelations.hxx @@ -0,0 +1,34 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#ifndef INCLUDED_SVX_SOURCE_SVDRAW_PRESETOOXHANDLEADJUSTMENTRELATIONS_HXX +#define INCLUDED_SVX_SOURCE_SVDRAW_PRESETOOXHANDLEADJUSTMENTRELATIONS_HXX + +#include + +#include + +#include + +namespace PresetOOXHandleAdj +{ +/* This method is used in SdrObjCustomShape::MergeDefaultAttributes() */ +void GetOOXHandleAdjRelation( + std::u16string_view sFullOOXShapeName, /* e.g. "ooxml-circularArrow" */ + const sal_Int32 nHandleIndex, /* index in sequence from property "Handles" */ + OUString& rFirstRefType, /* Propertyname, same as by pptx import, e.g. "RefX" */ + sal_Int32& rFirstAdjValueIndex, /* index in sequence from property "AdjustmentValues" */ + OUString& rSecondRefType, /* Propertyname, same as by pptx import, e.g. "RefY" */ + sal_Int32& rSecondAdjValueIndex /* index in sequence from property "AdjustmentValues" */ +); +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/svx/source/svdraw/sdrhittesthelper.cxx b/svx/source/svdraw/sdrhittesthelper.cxx new file mode 100644 index 0000000000..9dc3b9118f --- /dev/null +++ b/svx/source/svdraw/sdrhittesthelper.cxx @@ -0,0 +1,175 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +// #i101872# new Object HitTest as View-tooling + +SdrObject* SdrObjectPrimitiveHit( + const SdrObject& rObject, + const Point& rPnt, + const basegfx::B2DVector& rHitTolerance, + const SdrPageView& rSdrPageView, + const SdrLayerIDSet* pVisiLayer, + bool bTextOnly, + drawinglayer::primitive2d::Primitive2DContainer* pHitContainer) +{ + SdrObject* pResult = nullptr; + + if(rObject.GetSubList() && rObject.GetSubList()->GetObjCount()) + { + // group or scene with content. Single 3D objects also have a + // true == rObject.GetSubList(), but no content + pResult = SdrObjListPrimitiveHit(*rObject.GetSubList(), rPnt, rHitTolerance, rSdrPageView, pVisiLayer, bTextOnly); + } + else + { + if( rObject.IsVisible() && (!pVisiLayer || pVisiLayer->IsSet(rObject.GetLayer()))) + { + // single object, 3d object, empty scene or empty group. Check if + // it's a single 3D object + const E3dCompoundObject* pE3dCompoundObject = dynamic_cast< const E3dCompoundObject* >(&rObject); + + if(pE3dCompoundObject) + { + const basegfx::B2DPoint aHitPosition(rPnt.X(), rPnt.Y()); + + if(checkHitSingle3DObject(aHitPosition, *pE3dCompoundObject)) + { + pResult = const_cast< E3dCompoundObject* >(pE3dCompoundObject); + } + } + else + { + // not a single 3D object; Check in first PageWindow using primitives (only SC + // with split views uses multiple PageWindows nowadays) + if(rSdrPageView.PageWindowCount()) + { + const basegfx::B2DPoint aHitPosition(rPnt.X(), rPnt.Y()); + const sdr::contact::ViewObjectContact& rVOC = rObject.GetViewContact().GetViewObjectContact( + rSdrPageView.GetPageWindow(0)->GetObjectContact()); + + if(ViewObjectContactPrimitiveHit(rVOC, aHitPosition, rHitTolerance, bTextOnly, pHitContainer)) + { + pResult = const_cast< SdrObject* >(&rObject); + } + } + } + } + } + + return pResult; +} + + +SdrObject* SdrObjListPrimitiveHit( + const SdrObjList& rList, + const Point& rPnt, + const basegfx::B2DVector& rHitTolerance, + const SdrPageView& rSdrPageView, + const SdrLayerIDSet* pVisiLayer, + bool bTextOnly) +{ + size_t nObjNum(rList.GetObjCount()); + SdrObject* pRetval = nullptr; + + while(!pRetval && nObjNum > 0) + { + nObjNum--; + SdrObject* pObj = rList.GetObj(nObjNum); + + pRetval = SdrObjectPrimitiveHit(*pObj, rPnt, rHitTolerance, rSdrPageView, pVisiLayer, bTextOnly); + } + + return pRetval; +} + + +bool ViewObjectContactPrimitiveHit( + const sdr::contact::ViewObjectContact& rVOC, + const basegfx::B2DPoint& rHitPosition, + const basegfx::B2DVector& rLogicHitTolerance, + bool bTextOnly, + drawinglayer::primitive2d::Primitive2DContainer* pHitContainer) +{ + basegfx::B2DRange aObjectRange(rVOC.getObjectRange()); + + if(!aObjectRange.isEmpty()) + { + // first do a rough B2DRange based HitTest; do not forget to + // include the HitTolerance if given + if(rLogicHitTolerance.getX() > 0 || rLogicHitTolerance.getY() > 0) + { + aObjectRange.grow(rLogicHitTolerance); + } + + if(aObjectRange.isInside(rHitPosition)) + { + // get primitive sequence + sdr::contact::DisplayInfo aDisplayInfo; + // have to make a copy of this container here, because it might be changed underneath us + const drawinglayer::primitive2d::Primitive2DContainer aSequence(rVOC.getPrimitive2DSequence(aDisplayInfo)); + + if(!aSequence.empty()) + { + // create a HitTest processor + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D = rVOC.GetObjectContact().getViewInformation2D(); + drawinglayer::processor2d::HitTestProcessor2D aHitTestProcessor2D( + rViewInformation2D, + rHitPosition, + rLogicHitTolerance, + bTextOnly); + + // ask for HitStack + aHitTestProcessor2D.collectHitStack(pHitContainer != nullptr); + + // feed it with the primitives + aHitTestProcessor2D.process(aSequence); + + // deliver result + if (aHitTestProcessor2D.getHit()) + { + if (pHitContainer) + { + // fetch HitStack primitives if requested + *pHitContainer = aHitTestProcessor2D.getHitStack(); + } + + return true; + } + } + } + } + + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/sdrmasterpagedescriptor.cxx b/svx/source/svdraw/sdrmasterpagedescriptor.cxx new file mode 100644 index 0000000000..1d08439189 --- /dev/null +++ b/svx/source/svdraw/sdrmasterpagedescriptor.cxx @@ -0,0 +1,104 @@ +/* -*- 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 +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +namespace sdr +{ + MasterPageDescriptor::MasterPageDescriptor(SdrPage& aOwnerPage, SdrPage& aUsedPage) + : maOwnerPage(aOwnerPage), + maUsedPage(aUsedPage) + { + // all layers visible + maVisibleLayers.SetAll(); + + // register at used page + maUsedPage.AddPageUser(*this); + } + + MasterPageDescriptor::~MasterPageDescriptor() + { + // de-register at used page + maUsedPage.RemovePageUser(*this); + + mpViewContact.reset(); + } + + // ViewContact part + sdr::contact::ViewContact& MasterPageDescriptor::GetViewContact() const + { + if(!mpViewContact) + { + mpViewContact.reset( + new sdr::contact::ViewContactOfMasterPageDescriptor(*const_cast< MasterPageDescriptor* >(this)) ); + } + + return *mpViewContact; + } + + // this method is called from the destructor of the referenced page. + // do all necessary action to forget the page. It is not necessary to call + // RemovePageUser(), that is done from the destructor. + void MasterPageDescriptor::PageInDestruction(const SdrPage& /*rPage*/) + { + maOwnerPage.TRG_ClearMasterPage(); + } + + void MasterPageDescriptor::SetVisibleLayers(const SdrLayerIDSet& rNew) + { + if(rNew != maVisibleLayers) + { + maVisibleLayers = rNew; + GetViewContact().ActionChanged(); + } + } + + + const SdrPageProperties* MasterPageDescriptor::getCorrectSdrPageProperties() const + { + const SdrPage* pCorrectPage = &GetOwnerPage(); + const SdrPageProperties* pCorrectProperties = &pCorrectPage->getSdrPageProperties(); + + if(drawing::FillStyle_NONE == pCorrectProperties->GetItemSet().Get(XATTR_FILLSTYLE).GetValue()) + { + pCorrectPage = &GetUsedPage(); + pCorrectProperties = &pCorrectPage->getSdrPageProperties(); + } + + if(pCorrectPage->IsMasterPage() && !pCorrectProperties->GetStyleSheet()) + { + // #i110846# Suppress SdrPage FillStyle for MasterPages without StyleSheets, + // else the PoolDefault (XFILL_COLOR and Blue8) will be used. Normally, all + // MasterPages should have a StyleSheet exactly for this reason, but historically + // e.g. the Notes MasterPage has no StyleSheet set (and there maybe others). + pCorrectProperties = nullptr; + } + + return pCorrectProperties; + } +} // end of namespace sdr + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/sdrpagewindow.cxx b/svx/source/svdraw/sdrpagewindow.cxx new file mode 100644 index 0000000000..fa8e5f4d7f --- /dev/null +++ b/svx/source/svdraw/sdrpagewindow.cxx @@ -0,0 +1,533 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +struct SdrPageWindow::Impl +{ + // #110094# ObjectContact section + mutable sdr::contact::ObjectContact* mpObjectContact; + + // the SdrPageView this window belongs to + SdrPageView& mrPageView; + + // the PaintWindow to paint on. Here is access to OutDev etc. + // #i72752# change to pointer to allow patcing it in DrawLayer() if necessary + SdrPaintWindow* mpPaintWindow; + SdrPaintWindow* mpOriginalPaintWindow; + + // UNO stuff for xControls + uno::Reference mxControlContainer; + + Impl( SdrPageView& rPageView, SdrPaintWindow& rPaintWindow ) : + mpObjectContact(nullptr), + mrPageView(rPageView), + mpPaintWindow(&rPaintWindow), + mpOriginalPaintWindow(nullptr) + { + } +}; + + +uno::Reference const & SdrPageWindow::GetControlContainer( bool _bCreateIfNecessary ) const +{ + if (!mpImpl->mxControlContainer.is() && _bCreateIfNecessary) + { + SdrView& rView = GetPageView().GetView(); + + const SdrPaintWindow& rPaintWindow( GetOriginalPaintWindow() ? *GetOriginalPaintWindow() : GetPaintWindow() ); + if ( rPaintWindow.OutputToWindow() && !rView.IsPrintPreview() ) + { + vcl::Window* pWindow = rPaintWindow.GetOutputDevice().GetOwnerWindow(); + const_cast< SdrPageWindow* >( this )->mpImpl->mxControlContainer = VCLUnoHelper::CreateControlContainer( pWindow ); + + // #100394# xC->setVisible triggers window->Show() and this has + // problems when the view is not completely constructed which may + // happen when loading. This leads to accessibility broadcasts which + // throw asserts due to the not finished view. All this chain can be avoided + // since xC->setVisible is here called only for the side effect in + // UnoControlContainer::setVisible(...) which calls createPeer(...). + // This will now be called directly from here. + + uno::Reference< awt::XControl > xControl(mpImpl->mxControlContainer, uno::UNO_QUERY); + if(xControl.is()) + { + uno::Reference< uno::XInterface > xContext = xControl->getContext(); + if(!xContext.is()) + { + xControl->createPeer( uno::Reference(), uno::Reference() ); + } + } + } + else + { + // Printer and VirtualDevice, or rather: no OutDev + uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() ); + const_cast< SdrPageWindow* >( this )->mpImpl->mxControlContainer.set(xFactory->createInstance("com.sun.star.awt.UnoControlContainer"), uno::UNO_QUERY); + uno::Reference< awt::XControlModel > xModel(xFactory->createInstance("com.sun.star.awt.UnoControlContainerModel"), uno::UNO_QUERY); + uno::Reference< awt::XControl > xControl(mpImpl->mxControlContainer, uno::UNO_QUERY); + if (xControl.is()) + xControl->setModel(xModel); + + OutputDevice& rOutDev = rPaintWindow.GetOutputDevice(); + Point aPosPix = rOutDev.GetMapMode().GetOrigin(); + Size aSizePix = rOutDev.GetOutputSizePixel(); + + uno::Reference< awt::XWindow > xContComp(mpImpl->mxControlContainer, uno::UNO_QUERY); + if( xContComp.is() ) + xContComp->setPosSize(aPosPix.X(), aPosPix.Y(), aSizePix.Width(), aSizePix.Height(), awt::PosSize::POSSIZE); + } + + FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView ); + if ( pViewAsFormView ) + pViewAsFormView->InsertControlContainer(mpImpl->mxControlContainer); + } + return mpImpl->mxControlContainer; +} + +SdrPageWindow::SdrPageWindow(SdrPageView& rPageView, SdrPaintWindow& rPaintWindow) : + mpImpl(new Impl(rPageView, rPaintWindow)) +{ +} + +SdrPageWindow::~SdrPageWindow() +{ + // #i26631# + ResetObjectContact(); + + if (!mpImpl->mxControlContainer.is()) + return; + + auto & rView = static_cast(GetPageView().GetView()); + + // notify derived views + FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView ); + if ( pViewAsFormView ) + pViewAsFormView->RemoveControlContainer(mpImpl->mxControlContainer); + + // dispose the control container + uno::Reference< lang::XComponent > xComponent(mpImpl->mxControlContainer, uno::UNO_QUERY); + xComponent->dispose(); +} + +SdrPageView& SdrPageWindow::GetPageView() const +{ + return mpImpl->mrPageView; +} + +SdrPaintWindow& SdrPageWindow::GetPaintWindow() const +{ + return *mpImpl->mpPaintWindow; +} + +const SdrPaintWindow* SdrPageWindow::GetOriginalPaintWindow() const +{ + return mpImpl->mpOriginalPaintWindow; +} + +// OVERLAY MANAGER +rtl::Reference< sdr::overlay::OverlayManager > const & SdrPageWindow::GetOverlayManager() const +{ + return GetPaintWindow().GetOverlayManager(); +} + +SdrPaintWindow* SdrPageWindow::patchPaintWindow(SdrPaintWindow& rPaintWindow) +{ + if (!mpImpl) + return nullptr; + + if (!mpImpl->mpOriginalPaintWindow) + { + // first patch + mpImpl->mpOriginalPaintWindow = mpImpl->mpPaintWindow; + mpImpl->mpPaintWindow = &rPaintWindow; + mpImpl->mpOriginalPaintWindow->setPatched(&rPaintWindow); + return mpImpl->mpOriginalPaintWindow; + } + else + { + // second or more patch + auto pPreviousPaintWindow = mpImpl->mpPaintWindow; + mpImpl->mpPaintWindow = &rPaintWindow; + mpImpl->mpOriginalPaintWindow->setPatched(&rPaintWindow); + return pPreviousPaintWindow; + } +} + +void SdrPageWindow::unpatchPaintWindow(SdrPaintWindow* pPreviousPaintWindow) +{ + if (pPreviousPaintWindow == mpImpl->mpOriginalPaintWindow) + { + // first patch + mpImpl->mpPaintWindow = mpImpl->mpOriginalPaintWindow; + mpImpl->mpOriginalPaintWindow->setPatched(nullptr); + mpImpl->mpOriginalPaintWindow = nullptr; + } + else + { + // second or more patch + mpImpl->mpPaintWindow = pPreviousPaintWindow; + mpImpl->mpOriginalPaintWindow->setPatched(pPreviousPaintWindow); + } +} + +void SdrPageWindow::PrePaint() +{ + // give OC the chance to do ProcessDisplay preparations + if(HasObjectContact()) + { + GetObjectContact().PrepareProcessDisplay(); + } +} + +void SdrPageWindow::PrepareRedraw(const vcl::Region& rReg) +{ + // give OC the chance to do ProcessDisplay preparations + if(HasObjectContact()) + { + GetObjectContact().PrepareProcessDisplay(); + } + + // if necessary, remember changed RedrawArea at PaintWindow for usage with + // overlay and PreRenderDevice stuff + GetPaintWindow().SetRedrawRegion(rReg); +} + + +// clip test +#ifdef CLIPPER_TEST +#include +#include +#include +#include +#include +#include +#include + +// for ::std::sort +#include + +namespace +{ + void impPaintStrokePolygon(const basegfx::B2DPolygon& rCandidate, OutputDevice& rOutDev, Color aColor) + { + basegfx::B2DPolygon aCandidate(rCandidate); + + if(aCandidate.areControlPointsUsed()) + { + aCandidate = basegfx::utils::adaptiveSubdivideByAngle(rCandidate); + } + + if(aCandidate.count()) + { + const sal_uInt32 nLoopCount(aCandidate.isClosed() ? aCandidate.count() : aCandidate.count() - 1); + rOutDev.SetFillColor(); + rOutDev.SetLineColor(aColor); + + for(sal_uInt32 a(0); a < nLoopCount; a++) + { + const basegfx::B2DPoint aBStart(aCandidate.getB2DPoint(a)); + const basegfx::B2DPoint aBEnd(aCandidate.getB2DPoint((a + 1) % aCandidate.count())); + const Point aStart(FRound(aBStart.getX()), FRound(aBStart.getY())); + const Point aEnd(FRound(aBEnd.getX()), FRound(aBEnd.getY())); + rOutDev.DrawLine(aStart, aEnd); + } + } + } + + void impTryTest(const SdrPageView& rPageView, OutputDevice& rOutDev) + { + if(rPageView.GetPage() && rPageView.GetPage()->GetObjCount() >= 2) + { + SdrPage* pPage = rPageView.GetPage(); + SdrObject* pObjA = pPage->GetObj(0); + + if(dynamic_cast( pObjA)) + { + basegfx::B2DPolyPolygon aPolyA(pObjA->GetPathPoly()); + aPolyA = basegfx::utils::correctOrientations(aPolyA); + + basegfx::B2DPolyPolygon aPolyB; + + for (const rtl::Reference& pObjB : *rPageView.GetPage()) + { + if(dynamic_cast( pObjB.get())) + { + basegfx::B2DPolyPolygon aCandidate(pObjB->GetPathPoly()); + aCandidate = basegfx::utils::correctOrientations(aCandidate); + aPolyB.append(aCandidate); + } + } + + if(aPolyA.count() && aPolyA.isClosed() && aPolyB.count()) + { + // poly A is the clipregion, clip poly b against it. Algo depends on + // poly b being closed. + basegfx::B2DPolyPolygon aResult(basegfx::utils::clipPolyPolygonOnPolyPolygon(aPolyB, aPolyA)); + + for(auto const& rPolygon : aResult) + { + int nR = comphelper::rng::uniform_int_distribution(0, 254); + int nG = comphelper::rng::uniform_int_distribution(0, 254); + int nB = comphelper::rng::uniform_int_distribution(0, 254); + Color aColor(nR, nG, nB); + impPaintStrokePolygon(rPolygon, rOutDev, aColor); + } + } + } + } + } +} // end of anonymous namespace +#endif // CLIPPER_TEST + + +void SdrPageWindow::RedrawAll( sdr::contact::ViewObjectContactRedirector* pRedirector ) +{ + // set Redirector + GetObjectContact().SetViewObjectContactRedirector(pRedirector); + + // set PaintingPageView + const SdrView& rView = mpImpl->mrPageView.GetView(); + SdrModel& rModel = rView.GetModel(); + + // get to be processed layers + const bool bPrinter(GetPaintWindow().OutputToPrinter()); + SdrLayerIDSet aProcessLayers = bPrinter ? mpImpl->mrPageView.GetPrintableLayers() : mpImpl->mrPageView.GetVisibleLayers(); + + // create PaintInfoRec; use Rectangle only temporarily + const vcl::Region& rRegion = GetPaintWindow().GetRedrawRegion(); + + // create processing data + sdr::contact::DisplayInfo aDisplayInfo; + + // Draw all layers. do NOT draw form layer from CompleteRedraw, this is done separately + // as a single layer paint + const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin(); + const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName()); + aProcessLayers.Clear(nControlLayerId); + + // still something to paint? + if(!aProcessLayers.IsEmpty()) + { + aDisplayInfo.SetProcessLayers(aProcessLayers); + + // Set region as redraw area + aDisplayInfo.SetRedrawArea(rRegion); + + // paint page + GetObjectContact().ProcessDisplay(aDisplayInfo); + } + + // reset redirector + GetObjectContact().SetViewObjectContactRedirector(nullptr); + + // LineClip test +#ifdef CLIPPER_TEST + if(true) + { + impTryTest(GetPageView(), GetPaintWindow().GetOutputDevice()); + } +#endif // CLIPPER_TEST +} + +void SdrPageWindow::RedrawLayer(const SdrLayerID* pId, + sdr::contact::ViewObjectContactRedirector* pRedirector, + basegfx::B2IRectangle const*const pPageFrame) +{ + // set redirector + GetObjectContact().SetViewObjectContactRedirector(pRedirector); + + // set PaintingPageView + const SdrView& rView = mpImpl->mrPageView.GetView(); + SdrModel& rModel = rView.GetModel(); + + // get the layers to process + const bool bPrinter(GetPaintWindow().OutputToPrinter()); + SdrLayerIDSet aProcessLayers = bPrinter ? mpImpl->mrPageView.GetPrintableLayers() : mpImpl->mrPageView.GetVisibleLayers(); + + // is the given layer visible at all? + if(aProcessLayers.IsSet(*pId)) + { + // find out if we are painting the ControlLayer + const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin(); + const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName()); + const bool bControlLayerProcessingActive(nControlLayerId == *pId); + + // create PaintInfoRec, use Rectangle only temporarily + const vcl::Region& rRegion = GetPaintWindow().GetRedrawRegion(); + + // create processing data + sdr::contact::DisplayInfo aDisplayInfo; + + // is it the control layer? If Yes, set flag + aDisplayInfo.SetControlLayerProcessingActive(bControlLayerProcessingActive); + + // Draw just the one given layer + aProcessLayers.ClearAll(); + aProcessLayers.Set(*pId); + + aDisplayInfo.SetProcessLayers(aProcessLayers); + + // Set region as redraw area + aDisplayInfo.SetRedrawArea(rRegion); + + // Writer or calc, coming from original RedrawOneLayer. + // #i72889# no page painting or MasterPage painting for layer painting + const bool bOldPageDecorationAllowed(GetPageView().GetView().IsPageDecorationAllowed()); + const bool bOldMasterPageVisualizationAllowed(GetPageView().GetView().IsMasterPageVisualizationAllowed()); + GetPageView().GetView().SetPageDecorationAllowed(false); + GetPageView().GetView().SetMasterPageVisualizationAllowed(false); + + if (pPageFrame) // Writer page frame for anchor based clipping + { + aDisplayInfo.SetWriterPageFrame(*pPageFrame); + } + + // paint page + GetObjectContact().ProcessDisplay(aDisplayInfo); + + // reset temporarily changed flags + GetPageView().GetView().SetPageDecorationAllowed(bOldPageDecorationAllowed); + GetPageView().GetView().SetMasterPageVisualizationAllowed(bOldMasterPageVisualizationAllowed); + } + + // reset redirector + GetObjectContact().SetViewObjectContactRedirector(nullptr); +} + +// Invalidate call, used from ObjectContact(OfPageView) in InvalidatePartOfView(...) +void SdrPageWindow::InvalidatePageWindow(const basegfx::B2DRange& rRange) +{ + if (GetPageView().IsVisible() && GetPaintWindow().OutputToWindow()) + { + OutputDevice& rWindow(GetPaintWindow().GetOutputDevice()); + basegfx::B2DRange aDiscreteRange(rRange); + aDiscreteRange.transform(rWindow.GetViewTransformation()); + + if (SvtOptionsDrawinglayer::IsAntiAliasing()) + { + // invalidate one discrete unit more under the assumption that AA + // needs one pixel more + aDiscreteRange.grow(1.0); + } + + // If the shapes use negative X coordinates, make them positive before sending + // the invalidation rectangle. + bool bNegativeX = mpImpl->mrPageView.GetView().IsNegativeX(); + + const tools::Rectangle aVCLDiscreteRectangle( + static_cast(bNegativeX ? std::max(0.0, ceil(-aDiscreteRange.getMaxX())) : floor(aDiscreteRange.getMinX())), + static_cast(floor(aDiscreteRange.getMinY())), + static_cast(bNegativeX ? std::max(0.0, floor(-aDiscreteRange.getMinX())) : ceil(aDiscreteRange.getMaxX())), + static_cast(ceil(aDiscreteRange.getMaxY()))); + + const bool bWasMapModeEnabled(rWindow.IsMapModeEnabled()); + rWindow.EnableMapMode(false); + GetPageView().GetView().InvalidateOneWin(rWindow, aVCLDiscreteRectangle); + rWindow.EnableMapMode(bWasMapModeEnabled); + } + else if (comphelper::LibreOfficeKit::isActive()) + { + // we don't really have to have a paint window with LOK; OTOH we know + // that the drawinglayer units are 100ths of mm, so they are easy to + // convert to twips + + // If the shapes use negative X coordinates, make them positive before sending + // the invalidation rectangle. + bool bNegativeX = mpImpl->mrPageView.GetView().IsNegativeX(); + const tools::Rectangle aRect100thMM( + static_cast(bNegativeX ? std::max(0.0, ceil(-rRange.getMaxX())) : floor(rRange.getMinX())), + static_cast(floor(rRange.getMinY())), + static_cast(bNegativeX ? std::max(0.0, floor(-rRange.getMinX())) : ceil(rRange.getMaxX())), + static_cast(ceil(rRange.getMaxY()))); + + const tools::Rectangle aRectTwips = o3tl::convert(aRect100thMM, o3tl::Length::mm100, o3tl::Length::twip); + + if (SfxViewShell* pViewShell = SfxViewShell::Current()) + SfxLokHelper::notifyInvalidation(pViewShell, &aRectTwips); + } +} + +// ObjectContact section +const sdr::contact::ObjectContact& SdrPageWindow::GetObjectContact() const +{ + if (!mpImpl->mpObjectContact) + { + mpImpl->mpObjectContact = GetPageView().GetView().createViewSpecificObjectContact( + const_cast(*this), + "svx::svdraw::SdrPageWindow mpObjectContact"); + } + + return *mpImpl->mpObjectContact; +} + +sdr::contact::ObjectContact& SdrPageWindow::GetObjectContact() +{ + if (!mpImpl->mpObjectContact) + { + mpImpl->mpObjectContact = GetPageView().GetView().createViewSpecificObjectContact( + *this, + "svx::svdraw::SdrPageWindow mpObjectContact" ); + } + + return *mpImpl->mpObjectContact; +} + +bool SdrPageWindow::HasObjectContact() const +{ + return mpImpl->mpObjectContact != nullptr; +} + +// #i26631# +void SdrPageWindow::ResetObjectContact() +{ + if (mpImpl->mpObjectContact) + { + delete mpImpl->mpObjectContact; + mpImpl->mpObjectContact = nullptr; + } +} + +void SdrPageWindow::SetDesignMode( bool _bDesignMode ) const +{ + const sdr::contact::ObjectContactOfPageView* pOC = dynamic_cast< const sdr::contact::ObjectContactOfPageView* >( &GetObjectContact() ); + DBG_ASSERT( pOC, "SdrPageWindow::SetDesignMode: invalid object contact!" ); + if ( pOC ) + pOC->SetUNOControlsDesignMode( _bDesignMode ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/sdrpaintwindow.cxx b/svx/source/svdraw/sdrpaintwindow.cxx new file mode 100644 index 0000000000..ebed55326a --- /dev/null +++ b/svx/source/svdraw/sdrpaintwindow.cxx @@ -0,0 +1,337 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +//rhbz#1007697 do this in two loops, one to collect the candidates +//and another to update them because updating a candidate can +//trigger the candidate to be deleted, so asking for its +//sibling after that is going to fail hard +class CandidateMgr +{ + std::vector > m_aCandidates; + std::set > m_aDeletedCandidates; + DECL_LINK(WindowEventListener, VclWindowEvent&, void); +public: + void PaintTransparentChildren(vcl::Window const & rWindow, tools::Rectangle const& rPixelRect); + ~CandidateMgr(); +}; + +} + +IMPL_LINK(CandidateMgr, WindowEventListener, VclWindowEvent&, rEvent, void) +{ + vcl::Window* pWindow = rEvent.GetWindow(); + if (rEvent.GetId() == VclEventId::ObjectDying) + { + m_aDeletedCandidates.insert(pWindow); + } +} + +CandidateMgr::~CandidateMgr() +{ + for (VclPtr& pCandidate : m_aCandidates) + { + if (m_aDeletedCandidates.find(pCandidate) != m_aDeletedCandidates.end()) + continue; + pCandidate->RemoveEventListener(LINK(this, CandidateMgr, WindowEventListener)); + } +} + +void PaintTransparentChildren(vcl::Window const & rWindow, tools::Rectangle const& rPixelRect) +{ + if (!rWindow.IsChildTransparentModeEnabled()) + return; + + CandidateMgr aManager; + aManager.PaintTransparentChildren(rWindow, rPixelRect); +} + +void CandidateMgr::PaintTransparentChildren(vcl::Window const & rWindow, tools::Rectangle const& rPixelRect) +{ + vcl::Window * pCandidate = rWindow.GetWindow( GetWindowType::FirstChild ); + while (pCandidate) + { + if (pCandidate->IsPaintTransparent()) + { + const tools::Rectangle aCandidatePosSizePixel( + pCandidate->GetPosPixel(), + pCandidate->GetSizePixel()); + + if (aCandidatePosSizePixel.Overlaps(rPixelRect)) + { + m_aCandidates.emplace_back(pCandidate); + pCandidate->AddEventListener(LINK(this, CandidateMgr, WindowEventListener)); + } + } + pCandidate = pCandidate->GetWindow( GetWindowType::Next ); + } + + for (const auto& rpCandidate : m_aCandidates) + { + pCandidate = rpCandidate.get(); + if (m_aDeletedCandidates.find(pCandidate) != m_aDeletedCandidates.end()) + continue; + //rhbz#1007697 this can cause the window itself to be + //deleted. So we are listening to see if that happens + //and if so, then skip the update + pCandidate->Invalidate(InvalidateFlags::NoTransparent|InvalidateFlags::Children); + // important: actually paint the child here! + if (m_aDeletedCandidates.find(pCandidate) != m_aDeletedCandidates.end()) + continue; + pCandidate->PaintImmediately(); + } +} + +SdrPreRenderDevice::SdrPreRenderDevice(OutputDevice& rOriginal) +: mpOutputDevice(&rOriginal), + mpPreRenderDevice(VclPtr::Create()) +{ +} + +SdrPreRenderDevice::~SdrPreRenderDevice() +{ + mpPreRenderDevice.disposeAndClear(); +} + +void SdrPreRenderDevice::PreparePreRenderDevice() +{ + // compare size of mpPreRenderDevice with size of visible area + if(mpPreRenderDevice->GetOutputSizePixel() != mpOutputDevice->GetOutputSizePixel()) + { + mpPreRenderDevice->SetOutputSizePixel(mpOutputDevice->GetOutputSizePixel()); + } + + // Also compare the MapModes for zoom/scroll changes + if(mpPreRenderDevice->GetMapMode() != mpOutputDevice->GetMapMode()) + { + mpPreRenderDevice->SetMapMode(mpOutputDevice->GetMapMode()); + } + + // #i29186# + mpPreRenderDevice->SetDrawMode(mpOutputDevice->GetDrawMode()); + mpPreRenderDevice->SetSettings(mpOutputDevice->GetSettings()); +} + +void SdrPreRenderDevice::OutputPreRenderDevice(const vcl::Region& rExpandedRegion) +{ + // region to pixels + const vcl::Region aRegionPixel(mpOutputDevice->LogicToPixel(rExpandedRegion)); + //RegionHandle aRegionHandle(aRegionPixel.BeginEnumRects()); + //Rectangle aRegionRectanglePixel; + + // MapModes off + bool bMapModeWasEnabledDest(mpOutputDevice->IsMapModeEnabled()); + bool bMapModeWasEnabledSource(mpPreRenderDevice->IsMapModeEnabled()); + mpOutputDevice->EnableMapMode(false); + mpPreRenderDevice->EnableMapMode(false); + + RectangleVector aRectangles; + aRegionPixel.GetRegionRectangles(aRectangles); + + for(const auto& rRect : aRectangles) + { + // for each rectangle, copy the area + const Point aTopLeft(rRect.TopLeft()); + const Size aSize(rRect.GetSize()); + + mpOutputDevice->DrawOutDev( + aTopLeft, aSize, + aTopLeft, aSize, + *mpPreRenderDevice); + } + + mpOutputDevice->EnableMapMode(bMapModeWasEnabledDest); + mpPreRenderDevice->EnableMapMode(bMapModeWasEnabledSource); +} + +void SdrPaintView::InitOverlayManager(rtl::Reference xOverlayManager) +{ + Color aColA(SvtOptionsDrawinglayer::GetStripeColorA()); + Color aColB(SvtOptionsDrawinglayer::GetStripeColorB()); + + if (Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + aColA = aColB = Application::GetSettings().GetStyleSettings().GetHighlightColor(); + aColB.Invert(); + } + + xOverlayManager->setStripeColorA(aColA); + xOverlayManager->setStripeColorB(aColB); + xOverlayManager->setStripeLengthPixel(SvtOptionsDrawinglayer::GetStripeLength()); +} + +rtl::Reference SdrPaintView::CreateOverlayManager(OutputDevice& rOutputDevice) const +{ + rtl::Reference xOverlayManager; + // is it a window? + if (OUTDEV_WINDOW == rOutputDevice.GetOutDevType()) + { + vcl::Window* pWindow = rOutputDevice.GetOwnerWindow(); + // decide which OverlayManager to use + if (IsBufferedOverlayAllowed() && !pWindow->SupportsDoubleBuffering()) + { + // buffered OverlayManager, buffers its background and refreshes from there + // for pure overlay changes (no system redraw). The 3rd parameter specifies + // whether that refresh itself will use a 2nd vdev to avoid flickering. + // Also hand over the old OverlayManager if existent; this means to take over + // the registered OverlayObjects from it + xOverlayManager = sdr::overlay::OverlayManagerBuffered::create(rOutputDevice); + } + else + { + // unbuffered OverlayManager, just invalidates places where changes + // take place + // Also hand over the old OverlayManager if existent; this means to take over + // the registered OverlayObjects from it + xOverlayManager = sdr::overlay::OverlayManager::create(rOutputDevice); + } + + OSL_ENSURE(xOverlayManager.is(), "SdrPaintWindow::SdrPaintWindow: Could not allocate an overlayManager (!)"); + + // Request a repaint so that the buffered overlay manager fills + // its buffer properly. This is a workaround for missing buffer + // updates. + if (!comphelper::LibreOfficeKit::isActive()) + { + pWindow->Invalidate(); + } + + InitOverlayManager(xOverlayManager); + } + return xOverlayManager; +} + +void SdrPaintWindow::impCreateOverlayManager() +{ + // not yet one created? + if(!mxOverlayManager.is()) + mxOverlayManager = mrPaintView.CreateOverlayManager(GetOutputDevice()); +} + +SdrPaintWindow::SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut, vcl::Window* pWindow) +: mpOutputDevice(&rOut), + mpWindow(pWindow), + mrPaintView(rNewPaintView), + mbTemporaryTarget(false), // #i72889# + mbOutputToWindow(OUTDEV_WINDOW == mpOutputDevice->GetOutDevType()), + mpPatched(nullptr) +{ +} + +SdrPaintWindow::~SdrPaintWindow() +{ + mxOverlayManager.clear(); + + mpPreRenderDevice.reset(); +} + +rtl::Reference< sdr::overlay::OverlayManager > const & SdrPaintWindow::GetOverlayManager() const +{ + if(!mxOverlayManager.is()) + { + // Create buffered overlay manager by default. + const_cast< SdrPaintWindow* >(this)->impCreateOverlayManager(); + } + + return mxOverlayManager; +} + +tools::Rectangle SdrPaintWindow::GetVisibleArea() const +{ + Size aVisSizePixel(GetOutputDevice().GetOutputSizePixel()); + return GetOutputDevice().PixelToLogic(tools::Rectangle(Point(0,0), aVisSizePixel)); +} + +bool SdrPaintWindow::OutputToRecordingMetaFile() const +{ + GDIMetaFile* pMetaFile = mpOutputDevice->GetConnectMetaFile(); + return (pMetaFile && pMetaFile->IsRecord() && !pMetaFile->IsPause()); +} + +void SdrPaintWindow::PreparePreRenderDevice() +{ + const bool bPrepareBufferedOutput( + mrPaintView.IsBufferedOutputAllowed() + && !OutputToPrinter() + && !mpOutputDevice->IsVirtual() + && !OutputToRecordingMetaFile()); + + if(bPrepareBufferedOutput) + { + if(!mpPreRenderDevice) + { + mpPreRenderDevice.reset(new SdrPreRenderDevice(*mpOutputDevice)); + } + mpPreRenderDevice->PreparePreRenderDevice(); + } + else + { + mpPreRenderDevice.reset(); + } +} + +void SdrPaintWindow::OutputPreRenderDevice(const vcl::Region& rExpandedRegion) +{ + if(mpPreRenderDevice) + { + mpPreRenderDevice->OutputPreRenderDevice(rExpandedRegion); + } +} + +// #i73602# add flag if buffer shall be used +void SdrPaintWindow::DrawOverlay(const vcl::Region& rRegion) +{ + // ## force creation of OverlayManager since the first repaint needs to + // save the background to get a controlled start into overlay mechanism + impCreateOverlayManager(); + + if(mxOverlayManager.is() && !OutputToPrinter()) + { + if(mpPreRenderDevice) + { + mxOverlayManager->completeRedraw(rRegion, &mpPreRenderDevice->GetPreRenderDevice()); + } + else + { + mxOverlayManager->completeRedraw(rRegion); + } + } +} + + +void SdrPaintWindow::SetRedrawRegion(const vcl::Region& rNew) +{ + maRedrawRegion = rNew; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/sdrundomanager.cxx b/svx/source/svdraw/sdrundomanager.cxx new file mode 100644 index 0000000000..3d5fde475a --- /dev/null +++ b/svx/source/svdraw/sdrundomanager.cxx @@ -0,0 +1,184 @@ +/* -*- 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 +#include +#include +#include + +SdrUndoManager::SdrUndoManager() + : EditUndoManager(20 /*nMaxUndoActionCount*/) + , mpLastUndoActionBeforeTextEdit(nullptr) + , mnRedoActionCountBeforeTextEdit(0) + , mbEndTextEditTriggeredFromUndo(false) + , m_pDocSh(nullptr) +{ +} + +SdrUndoManager::~SdrUndoManager() {} + +bool SdrUndoManager::Undo() +{ + if (isTextEditActive()) + { + bool bRetval(false); + + // we are in text edit mode + if (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction()) + { + // there is an undo action for text edit, trigger it + bRetval = EditUndoManager::Undo(); + } + else + { + // no more text edit undo, end text edit + mbEndTextEditTriggeredFromUndo = true; + maEndTextEditHdl.Call(this); + mbEndTextEditTriggeredFromUndo = false; + } + + return bRetval; + } + else + { + // no undo triggered up to now, trigger local one + return SfxUndoManager::Undo(); + } +} + +bool SdrUndoManager::Redo() +{ + bool bRetval(false); + bool bClearRedoStack(false); + + if (isTextEditActive()) + { + // we are in text edit mode + bRetval = EditUndoManager::Redo(); + } + + if (!bRetval) + { + // Check if the current and thus to-be undone UndoAction is a SdrUndoDiagramModelData action + const bool bCurrentIsDiagramChange( + GetRedoActionCount() + && nullptr != dynamic_cast(GetRedoAction())); + + // no redo triggered up to now, trigger local one + bRetval = SfxUndoManager::Redo(); + + // it was a SdrUndoDiagramModelData action and we have more Redo actions + if (bCurrentIsDiagramChange && GetRedoActionCount()) + { + const bool bNextIsDiagramChange( + nullptr != dynamic_cast(GetRedoAction())); + + // We have more Redo-actions and the 'next' one to be executed is *not* a + // SdrUndoDiagramModelData-action. This means that the already executed + // one had done a re-Layout/Re-create of the Diagram XShape/SdrObject + // representation based on the restored Diagram ModelData. When the next + // Redo action is something else (and thus will not itself re-create + // XShapes/SdrShapes) it may be that it is an UnGroup/Delete where a former + // as-content-of-Diagram created XShape/SdrShape is referenced, an action + // that references a XShape/SdrShape by pointer/reference. That + // pointer/reference *cannot* be valid anymore (now). + + // The problem here is that Undo/Redo actions historically reference + // XShapes/SdrShapes by pointer/reference, e.g. deleting means: remove + // from an SdrObjList and add to an Undo action. I is *not* + // address/incarnation-invariant in the sense to remember e.g. to + // remove the Nth object in the list (that would work). + + // It might be possible to solve/correct this better, but since it's + // a rare corner case just avoid the possible crash when continuing Redos + // by clearing the Redo-Stack here as a consequence + bClearRedoStack = !bNextIsDiagramChange; + } + } + + if (bClearRedoStack) + { + // clear Redo-Stack (explanation see above) + ClearRedo(); + } + + return bRetval; +} + +void SdrUndoManager::Clear() +{ + if (isTextEditActive()) + { + while (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction()) + { + RemoveLastUndoAction(); + } + + // urgently needed: RemoveLastUndoAction does NOT correct the Redo stack by itself (!) + ClearRedo(); + } + else + { + // call parent + EditUndoManager::Clear(); + } +} + +void SdrUndoManager::SetEndTextEditHdl(const Link& rLink) +{ + maEndTextEditHdl = rLink; + + if (isTextEditActive()) + { + // text edit start, remember last non-textedit action for later cleanup + mpLastUndoActionBeforeTextEdit = GetUndoActionCount() ? GetUndoAction() : nullptr; + mnRedoActionCountBeforeTextEdit = GetRedoActionCount(); + } + else + { + // text edit ends, pop all textedit actions up to the remembered non-textedit action from the start + // to set back the UndoManager to the state before text edit started. If that action is already gone + // (due to being removed from the undo stack in the meantime), all need to be removed anyways + while (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction()) + { + RemoveLastUndoAction(); + } + + // urgently needed: RemoveLastUndoAction does NOT correct the Redo stack by itself (!) + ClearRedo(); + + // forget marker again + mpLastUndoActionBeforeTextEdit = nullptr; + mnRedoActionCountBeforeTextEdit = 0; + } +} + +bool SdrUndoManager::isTextEditActive() const { return maEndTextEditHdl.IsSet(); } + +void SdrUndoManager::SetDocShell(SfxObjectShell* pDocShell) { m_pDocSh = pDocShell; } + +void SdrUndoManager::EmptyActionsChanged() +{ + if (m_pDocSh) + { + m_pDocSh->Broadcast(SfxHint(SfxHintId::DocumentRepair)); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/selectioncontroller.cxx b/svx/source/svdraw/selectioncontroller.cxx new file mode 100644 index 0000000000..43112953fa --- /dev/null +++ b/svx/source/svdraw/selectioncontroller.cxx @@ -0,0 +1,125 @@ +/* -*- 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 +#include + +namespace sdr +{ + +bool SelectionController::onKeyInput(const KeyEvent& /*rKEvt*/, vcl::Window* /*pWin*/) +{ + return false; +} + +bool SelectionController::onMouseButtonDown(const MouseEvent& /*rMEvt*/, vcl::Window* /*pWin*/) +{ + return false; +} + +bool SelectionController::onMouseButtonUp(const MouseEvent& /*rMEvt*/, vcl::Window* /*pWin*/) +{ + return false; +} + +bool SelectionController::onMouseMove(const MouseEvent& /*rMEvt*/, vcl::Window* /*pWin*/) +{ + return false; +} + +void SelectionController::onSelectionHasChanged() +{ +} + +void SelectionController::onSelectAll() +{ +} + +void SelectionController::GetState( SfxItemSet& /*rSet*/ ) +{ +} + +void SelectionController::Execute( SfxRequest& /*rReq*/ ) +{ +} + +bool SelectionController::DeleteMarked() +{ + return false; +} + +bool SelectionController::GetAttributes(SfxItemSet& /*rTargetSet*/, bool /*bOnlyHardAttr*/) const +{ + return false; +} + +bool SelectionController::SetAttributes(const SfxItemSet& /*rSet*/, bool /*bReplaceAll*/) +{ + return false; +} + +bool SelectionController::GetStyleSheet( SfxStyleSheet* &/*rpStyleSheet*/ ) const +{ + return false; +} + +bool SelectionController::SetStyleSheet( SfxStyleSheet* /*pStyleSheet*/, bool /*bDontRemoveHardAttr*/ ) +{ + return false; +} + +rtl::Reference SelectionController::GetMarkedSdrObjClone( SdrModel& /*rTargetModel*/ ) +{ + return nullptr; +} + +bool SelectionController::PasteObjModel( const SdrModel& /*rModel*/ ) +{ + return false; +} + +bool SelectionController::ApplyFormatPaintBrush( SfxItemSet& /*rFormatSet*/, bool /*bNoCharacterFormats*/, bool /*bNoParagraphFormats*/ ) +{ + return false; +} + +bool SelectionController::hasSelectedCells() const +{ + return false; +} + +void SelectionController::getSelectedCells(table::CellPos& /*rFirstPos*/, table::CellPos& /*rLastPos*/) +{ +} + +bool SelectionController::setCursorLogicPosition(const Point& /*rPosition*/, bool /*bPoint*/) +{ + return false; +} + + +bool SelectionController::ChangeFontSize(bool /*bGrow*/, const FontList* /*pFontList*/) +{ + return false; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdattr.cxx b/svx/source/svdraw/svdattr.cxx new file mode 100644 index 0000000000..c518900e6f --- /dev/null +++ b/svx/source/svdraw/svdattr.cxx @@ -0,0 +1,2060 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +SdrItemPool::SdrItemPool( + SfxItemPool* _pMaster) +: XOutdevItemPool(_pMaster) +{ + // prepare some constants + const Color aNullCol(COL_BLACK); + const sal_Int32 nDefEdgeDist(500); // Defaulting hard for Draw (100TH_MM) currently. MapMode will have to be taken into account in the future. + + // init the non-persistent items + for(sal_uInt16 i(SDRATTR_NOTPERSIST_FIRST); i <= SDRATTR_NOTPERSIST_LAST; i++) + { + mpLocalItemInfos[i - SDRATTR_START]._bNeedsPoolRegistration = false; + } + + // these slots need _bNeedsPoolRegistration == true, see + // text @svl/source/items/itempool.cxx + mpLocalItemInfos[SDRATTR_XMLATTRIBUTES -SDRATTR_START]._bNeedsPoolRegistration = true; + + // init own PoolDefaults + std::vector& rPoolDefaults = *mpLocalPoolDefaults; + rPoolDefaults[SDRATTR_SHADOW -SDRATTR_START]=new SdrOnOffItem(SDRATTR_SHADOW, false); + rPoolDefaults[SDRATTR_SHADOWCOLOR -SDRATTR_START]=new XColorItem(SDRATTR_SHADOWCOLOR, aNullCol); + rPoolDefaults[SDRATTR_SHADOWXDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_SHADOWXDIST, 0); + rPoolDefaults[SDRATTR_SHADOWYDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_SHADOWYDIST, 0); + rPoolDefaults[SDRATTR_SHADOWSIZEX -SDRATTR_START]=new SdrMetricItem(SDRATTR_SHADOWSIZEX, 100000); + rPoolDefaults[SDRATTR_SHADOWSIZEY -SDRATTR_START]=new SdrMetricItem(SDRATTR_SHADOWSIZEY, 100000); + rPoolDefaults[SDRATTR_SHADOWTRANSPARENCE-SDRATTR_START]=new SdrPercentItem(SDRATTR_SHADOWTRANSPARENCE, 0); + rPoolDefaults[SDRATTR_SHADOWBLUR -SDRATTR_START]=new SdrMetricItem(SDRATTR_SHADOWBLUR, 0); + rPoolDefaults[SDRATTR_SHADOWALIGNMENT -SDRATTR_START]=new SvxRectangleAlignmentItem(SDRATTR_SHADOWALIGNMENT, model::RectangleAlignment::Unset); + rPoolDefaults[SDRATTR_SHADOW3D -SDRATTR_START]=new SfxVoidItem(SDRATTR_SHADOW3D ); + rPoolDefaults[SDRATTR_SHADOWPERSP -SDRATTR_START]=new SfxVoidItem(SDRATTR_SHADOWPERSP ); + rPoolDefaults[SDRATTR_CAPTIONTYPE -SDRATTR_START]=new SdrCaptionTypeItem ; + rPoolDefaults[SDRATTR_CAPTIONFIXEDANGLE-SDRATTR_START]=new SdrOnOffItem(SDRATTR_CAPTIONFIXEDANGLE, true); + rPoolDefaults[SDRATTR_CAPTIONANGLE -SDRATTR_START]=new SdrCaptionAngleItem ; + rPoolDefaults[SDRATTR_CAPTIONGAP -SDRATTR_START]=new SdrCaptionGapItem ; + rPoolDefaults[SDRATTR_CAPTIONESCDIR -SDRATTR_START]=new SdrCaptionEscDirItem ; + rPoolDefaults[SDRATTR_CAPTIONESCISREL -SDRATTR_START]=new SdrCaptionEscIsRelItem ; + rPoolDefaults[SDRATTR_CAPTIONESCREL -SDRATTR_START]=new SdrCaptionEscRelItem ; + rPoolDefaults[SDRATTR_CAPTIONESCABS -SDRATTR_START]=new SdrCaptionEscAbsItem ; + rPoolDefaults[SDRATTR_CAPTIONLINELEN -SDRATTR_START]=new SdrCaptionLineLenItem ; + rPoolDefaults[SDRATTR_CAPTIONFITLINELEN-SDRATTR_START]=new SdrCaptionFitLineLenItem; + rPoolDefaults[SDRATTR_CORNER_RADIUS -SDRATTR_START]=new SdrMetricItem(SDRATTR_CORNER_RADIUS, 0); + rPoolDefaults[SDRATTR_TEXT_MINFRAMEHEIGHT -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_MINFRAMEHEIGHT, 0); + rPoolDefaults[SDRATTR_TEXT_AUTOGROWHEIGHT -SDRATTR_START]=new SdrOnOffItem(SDRATTR_TEXT_AUTOGROWHEIGHT, true); + rPoolDefaults[SDRATTR_TEXT_FITTOSIZE -SDRATTR_START]=new SdrTextFitToSizeTypeItem; + rPoolDefaults[SDRATTR_TEXT_LEFTDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_LEFTDIST, 0); + rPoolDefaults[SDRATTR_TEXT_RIGHTDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_RIGHTDIST, 0); + rPoolDefaults[SDRATTR_TEXT_UPPERDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_UPPERDIST, 0); + rPoolDefaults[SDRATTR_TEXT_LOWERDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_LOWERDIST, 0); + rPoolDefaults[SDRATTR_TEXT_VERTADJUST -SDRATTR_START]=new SdrTextVertAdjustItem; + rPoolDefaults[SDRATTR_TEXT_MAXFRAMEHEIGHT -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_MAXFRAMEHEIGHT, 0); + rPoolDefaults[SDRATTR_TEXT_MINFRAMEWIDTH -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_MINFRAMEWIDTH, 0); + rPoolDefaults[SDRATTR_TEXT_MAXFRAMEWIDTH -SDRATTR_START]=new SdrMetricItem(SDRATTR_TEXT_MAXFRAMEWIDTH, 0); + rPoolDefaults[SDRATTR_TEXT_AUTOGROWWIDTH -SDRATTR_START]=new SdrOnOffItem(SDRATTR_TEXT_AUTOGROWWIDTH, false); + rPoolDefaults[SDRATTR_TEXT_HORZADJUST -SDRATTR_START]=new SdrTextHorzAdjustItem; + rPoolDefaults[SDRATTR_TEXT_ANIKIND -SDRATTR_START]=new SdrTextAniKindItem; + rPoolDefaults[SDRATTR_TEXT_ANIDIRECTION -SDRATTR_START]=new SdrTextAniDirectionItem; + rPoolDefaults[SDRATTR_TEXT_ANISTARTINSIDE -SDRATTR_START]=new SdrTextAniStartInsideItem; + rPoolDefaults[SDRATTR_TEXT_ANISTOPINSIDE -SDRATTR_START]=new SdrTextAniStopInsideItem; + rPoolDefaults[SDRATTR_TEXT_ANICOUNT -SDRATTR_START]=new SdrTextAniCountItem; + rPoolDefaults[SDRATTR_TEXT_ANIDELAY -SDRATTR_START]=new SdrTextAniDelayItem; + rPoolDefaults[SDRATTR_TEXT_ANIAMOUNT -SDRATTR_START]=new SdrTextAniAmountItem; + rPoolDefaults[SDRATTR_TEXT_CONTOURFRAME -SDRATTR_START]=new SdrOnOffItem(SDRATTR_TEXT_CONTOURFRAME, false); + rPoolDefaults[SDRATTR_XMLATTRIBUTES -SDRATTR_START]=new SvXMLAttrContainerItem( SDRATTR_XMLATTRIBUTES ); + rPoolDefaults[SDRATTR_TEXT_CHAINNEXTNAME -SDRATTR_START]=new SfxStringItem(SDRATTR_TEXT_CHAINNEXTNAME, ""); + rPoolDefaults[SDRATTR_TEXT_USEFIXEDCELLHEIGHT -SDRATTR_START]=new SdrTextFixedCellHeightItem; + rPoolDefaults[SDRATTR_TEXT_WORDWRAP -SDRATTR_START]=new SdrOnOffItem(SDRATTR_TEXT_WORDWRAP, true); + rPoolDefaults[SDRATTR_TEXT_CLIPVERTOVERFLOW-SDRATTR_START]=new SdrOnOffItem(SDRATTR_TEXT_CLIPVERTOVERFLOW, false); + rPoolDefaults[SDRATTR_EDGEKIND -SDRATTR_START]=new SdrEdgeKindItem; + rPoolDefaults[SDRATTR_EDGENODE1HORZDIST-SDRATTR_START]=new SdrEdgeNode1HorzDistItem(nDefEdgeDist); + rPoolDefaults[SDRATTR_EDGENODE1VERTDIST-SDRATTR_START]=new SdrEdgeNode1VertDistItem(nDefEdgeDist); + rPoolDefaults[SDRATTR_EDGENODE2HORZDIST-SDRATTR_START]=new SdrEdgeNode2HorzDistItem(nDefEdgeDist); + rPoolDefaults[SDRATTR_EDGENODE2VERTDIST-SDRATTR_START]=new SdrEdgeNode2VertDistItem(nDefEdgeDist); + rPoolDefaults[SDRATTR_EDGENODE1GLUEDIST-SDRATTR_START]=new SdrEdgeNode1GlueDistItem; + rPoolDefaults[SDRATTR_EDGENODE2GLUEDIST-SDRATTR_START]=new SdrEdgeNode2GlueDistItem; + rPoolDefaults[SDRATTR_EDGELINEDELTACOUNT-SDRATTR_START]=new SdrEdgeLineDeltaCountItem; + rPoolDefaults[SDRATTR_EDGELINE1DELTA -SDRATTR_START]=new SdrMetricItem(SDRATTR_EDGELINE1DELTA, 0); + rPoolDefaults[SDRATTR_EDGELINE2DELTA -SDRATTR_START]=new SdrMetricItem(SDRATTR_EDGELINE2DELTA, 0); + rPoolDefaults[SDRATTR_EDGELINE3DELTA -SDRATTR_START]=new SdrMetricItem(SDRATTR_EDGELINE3DELTA, 0); + rPoolDefaults[SDRATTR_EDGEOOXMLCURVE -SDRATTR_START]=new SfxBoolItem(SDRATTR_EDGEOOXMLCURVE, false); + rPoolDefaults[SDRATTR_MEASUREKIND -SDRATTR_START]=new SdrMeasureKindItem; + rPoolDefaults[SDRATTR_MEASURETEXTHPOS -SDRATTR_START]=new SdrMeasureTextHPosItem; + rPoolDefaults[SDRATTR_MEASURETEXTVPOS -SDRATTR_START]=new SdrMeasureTextVPosItem; + rPoolDefaults[SDRATTR_MEASURELINEDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_MEASURELINEDIST, 800); + rPoolDefaults[SDRATTR_MEASUREHELPLINEOVERHANG -SDRATTR_START]=new SdrMetricItem(SDRATTR_MEASUREHELPLINEOVERHANG, 200); + rPoolDefaults[SDRATTR_MEASUREHELPLINEDIST -SDRATTR_START]=new SdrMetricItem(SDRATTR_MEASUREHELPLINEDIST, 100); + rPoolDefaults[SDRATTR_MEASUREHELPLINE1LEN -SDRATTR_START]=new SdrMetricItem(SDRATTR_MEASUREHELPLINE1LEN, 0); + rPoolDefaults[SDRATTR_MEASUREHELPLINE2LEN -SDRATTR_START]=new SdrMetricItem(SDRATTR_MEASUREHELPLINE2LEN, 0); + rPoolDefaults[SDRATTR_MEASUREBELOWREFEDGE -SDRATTR_START]=new SdrMeasureBelowRefEdgeItem; + rPoolDefaults[SDRATTR_MEASURETEXTROTA90 -SDRATTR_START]=new SdrMeasureTextRota90Item; + rPoolDefaults[SDRATTR_MEASURETEXTUPSIDEDOWN -SDRATTR_START]=new SdrMeasureTextUpsideDownItem; + rPoolDefaults[SDRATTR_MEASUREOVERHANG -SDRATTR_START]=new SdrMeasureOverhangItem(600); + rPoolDefaults[SDRATTR_MEASUREUNIT -SDRATTR_START]=new SdrMeasureUnitItem; + rPoolDefaults[SDRATTR_MEASURESCALE -SDRATTR_START]=new SdrMeasureScaleItem; + rPoolDefaults[SDRATTR_MEASURESHOWUNIT -SDRATTR_START]=new SdrYesNoItem(SDRATTR_MEASURESHOWUNIT, false); + rPoolDefaults[SDRATTR_MEASUREFORMATSTRING -SDRATTR_START]=new SdrMeasureFormatStringItem(); + rPoolDefaults[SDRATTR_MEASURETEXTAUTOANGLE -SDRATTR_START]=new SdrMeasureTextAutoAngleItem(); + rPoolDefaults[SDRATTR_MEASURETEXTAUTOANGLEVIEW-SDRATTR_START]=new SdrMeasureTextAutoAngleViewItem(); + rPoolDefaults[SDRATTR_MEASURETEXTISFIXEDANGLE -SDRATTR_START]=new SdrMeasureTextIsFixedAngleItem(); + rPoolDefaults[SDRATTR_MEASURETEXTFIXEDANGLE -SDRATTR_START]=new SdrMeasureTextFixedAngleItem(); + rPoolDefaults[SDRATTR_MEASUREDECIMALPLACES -SDRATTR_START]=new SdrMeasureDecimalPlacesItem(); + rPoolDefaults[SDRATTR_CIRCKIND -SDRATTR_START]=new SdrCircKindItem; + rPoolDefaults[SDRATTR_CIRCSTARTANGLE-SDRATTR_START]=new SdrAngleItem(SDRATTR_CIRCSTARTANGLE, 0_deg100); + rPoolDefaults[SDRATTR_CIRCENDANGLE -SDRATTR_START]=new SdrAngleItem(SDRATTR_CIRCENDANGLE, 36000_deg100); + rPoolDefaults[SDRATTR_OBJMOVEPROTECT -SDRATTR_START]=new SdrYesNoItem(SDRATTR_OBJMOVEPROTECT, false); + rPoolDefaults[SDRATTR_OBJSIZEPROTECT -SDRATTR_START]=new SdrYesNoItem(SDRATTR_OBJSIZEPROTECT, false); + rPoolDefaults[SDRATTR_OBJPRINTABLE -SDRATTR_START]=new SdrObjPrintableItem; + rPoolDefaults[SDRATTR_OBJVISIBLE -SDRATTR_START]=new SdrObjVisibleItem; + rPoolDefaults[SDRATTR_LAYERID -SDRATTR_START]=new SdrLayerIdItem(SdrLayerID(0)); + rPoolDefaults[SDRATTR_LAYERNAME -SDRATTR_START]=new SdrLayerNameItem; + rPoolDefaults[SDRATTR_OBJECTNAME -SDRATTR_START]=new SfxStringItem(SDRATTR_OBJECTNAME); + rPoolDefaults[SDRATTR_ALLPOSITIONX -SDRATTR_START]=new SdrAllPositionXItem; + rPoolDefaults[SDRATTR_ALLPOSITIONY -SDRATTR_START]=new SdrAllPositionYItem; + rPoolDefaults[SDRATTR_ALLSIZEWIDTH -SDRATTR_START]=new SdrAllSizeWidthItem; + rPoolDefaults[SDRATTR_ALLSIZEHEIGHT -SDRATTR_START]=new SdrAllSizeHeightItem; + rPoolDefaults[SDRATTR_ONEPOSITIONX -SDRATTR_START]=new SdrOnePositionXItem; + rPoolDefaults[SDRATTR_ONEPOSITIONY -SDRATTR_START]=new SdrOnePositionYItem; + rPoolDefaults[SDRATTR_ONESIZEWIDTH -SDRATTR_START]=new SdrOneSizeWidthItem; + rPoolDefaults[SDRATTR_ONESIZEHEIGHT -SDRATTR_START]=new SdrOneSizeHeightItem; + rPoolDefaults[SDRATTR_LOGICSIZEWIDTH -SDRATTR_START]=new SdrLogicSizeWidthItem; + rPoolDefaults[SDRATTR_LOGICSIZEHEIGHT-SDRATTR_START]=new SdrLogicSizeHeightItem; + rPoolDefaults[SDRATTR_ROTATEANGLE -SDRATTR_START]=new SdrAngleItem(SDRATTR_ROTATEANGLE, 0_deg100); + rPoolDefaults[SDRATTR_SHEARANGLE -SDRATTR_START]=new SdrShearAngleItem; + rPoolDefaults[SDRATTR_MOVEX -SDRATTR_START]=new SdrMoveXItem; + rPoolDefaults[SDRATTR_MOVEY -SDRATTR_START]=new SdrMoveYItem; + rPoolDefaults[SDRATTR_RESIZEXONE -SDRATTR_START]=new SdrResizeXOneItem; + rPoolDefaults[SDRATTR_RESIZEYONE -SDRATTR_START]=new SdrResizeYOneItem; + rPoolDefaults[SDRATTR_ROTATEONE -SDRATTR_START]=new SdrRotateOneItem; + rPoolDefaults[SDRATTR_HORZSHEARONE -SDRATTR_START]=new SdrHorzShearOneItem; + rPoolDefaults[SDRATTR_VERTSHEARONE -SDRATTR_START]=new SdrVertShearOneItem; + rPoolDefaults[SDRATTR_RESIZEXALL -SDRATTR_START]=new SdrResizeXAllItem; + rPoolDefaults[SDRATTR_RESIZEYALL -SDRATTR_START]=new SdrResizeYAllItem; + rPoolDefaults[SDRATTR_ROTATEALL -SDRATTR_START]=new SdrRotateAllItem; + rPoolDefaults[SDRATTR_HORZSHEARALL -SDRATTR_START]=new SdrHorzShearAllItem; + rPoolDefaults[SDRATTR_VERTSHEARALL -SDRATTR_START]=new SdrVertShearAllItem; + rPoolDefaults[SDRATTR_TRANSFORMREF1X -SDRATTR_START]=new SdrTransformRef1XItem; + rPoolDefaults[SDRATTR_TRANSFORMREF1Y -SDRATTR_START]=new SdrTransformRef1YItem; + rPoolDefaults[SDRATTR_TRANSFORMREF2X -SDRATTR_START]=new SdrTransformRef2XItem; + rPoolDefaults[SDRATTR_TRANSFORMREF2Y -SDRATTR_START]=new SdrTransformRef2YItem; + rPoolDefaults[SDRATTR_TEXTDIRECTION -SDRATTR_START]=new SvxWritingModeItem(css::text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION); + rPoolDefaults[ SDRATTR_GRAFRED - SDRATTR_START] = new SdrGrafRedItem; + rPoolDefaults[ SDRATTR_GRAFGREEN - SDRATTR_START] = new SdrGrafGreenItem; + rPoolDefaults[ SDRATTR_GRAFBLUE - SDRATTR_START] = new SdrGrafBlueItem; + rPoolDefaults[ SDRATTR_GRAFLUMINANCE - SDRATTR_START] = new SdrGrafLuminanceItem; + rPoolDefaults[ SDRATTR_GRAFCONTRAST - SDRATTR_START] = new SdrGrafContrastItem; + rPoolDefaults[ SDRATTR_GRAFGAMMA - SDRATTR_START] = new SdrGrafGamma100Item; + rPoolDefaults[ SDRATTR_GRAFTRANSPARENCE - SDRATTR_START] = new SdrGrafTransparenceItem; + rPoolDefaults[ SDRATTR_GRAFINVERT - SDRATTR_START] = new SdrGrafInvertItem; + rPoolDefaults[ SDRATTR_GRAFMODE - SDRATTR_START] = new SdrGrafModeItem; + rPoolDefaults[ SDRATTR_GRAFCROP - SDRATTR_START] = new SdrGrafCropItem; + rPoolDefaults[ SDRATTR_3DOBJ_PERCENT_DIAGONAL - SDRATTR_START ] = new SfxUInt16Item(SDRATTR_3DOBJ_PERCENT_DIAGONAL, 10); + rPoolDefaults[ SDRATTR_3DOBJ_BACKSCALE - SDRATTR_START ] = new SfxUInt16Item(SDRATTR_3DOBJ_BACKSCALE, 100); + rPoolDefaults[ SDRATTR_3DOBJ_DEPTH - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DOBJ_DEPTH, 1000); + rPoolDefaults[ SDRATTR_3DOBJ_HORZ_SEGS - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DOBJ_HORZ_SEGS, 24); + rPoolDefaults[ SDRATTR_3DOBJ_VERT_SEGS - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DOBJ_VERT_SEGS, 24); + rPoolDefaults[ SDRATTR_3DOBJ_END_ANGLE - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DOBJ_END_ANGLE, 3600); + rPoolDefaults[ SDRATTR_3DOBJ_DOUBLE_SIDED - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DOBJ_DOUBLE_SIDED, false); + rPoolDefaults[ SDRATTR_3DOBJ_NORMALS_KIND - SDRATTR_START ] = new Svx3DNormalsKindItem; + rPoolDefaults[ SDRATTR_3DOBJ_NORMALS_INVERT - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DOBJ_NORMALS_INVERT, false); + rPoolDefaults[ SDRATTR_3DOBJ_TEXTURE_PROJ_X - SDRATTR_START ] = new Svx3DTextureProjectionXItem; + rPoolDefaults[ SDRATTR_3DOBJ_TEXTURE_PROJ_Y - SDRATTR_START ] = new Svx3DTextureProjectionYItem; + rPoolDefaults[ SDRATTR_3DOBJ_SHADOW_3D - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DOBJ_SHADOW_3D, false); + rPoolDefaults[ SDRATTR_3DOBJ_MAT_COLOR - SDRATTR_START ] = new SvxColorItem(Color(0x0000b8ff), SDRATTR_3DOBJ_MAT_COLOR); + rPoolDefaults[ SDRATTR_3DOBJ_MAT_EMISSION - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DOBJ_MAT_EMISSION); + rPoolDefaults[ SDRATTR_3DOBJ_MAT_SPECULAR - SDRATTR_START ] = new SvxColorItem(Color(0x00ffffff), SDRATTR_3DOBJ_MAT_SPECULAR); + rPoolDefaults[ SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY - SDRATTR_START ] = new SfxUInt16Item(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY, 15); + rPoolDefaults[ SDRATTR_3DOBJ_TEXTURE_KIND - SDRATTR_START ] = new Svx3DTextureKindItem; + rPoolDefaults[ SDRATTR_3DOBJ_TEXTURE_MODE - SDRATTR_START ] = new Svx3DTextureModeItem; + rPoolDefaults[ SDRATTR_3DOBJ_TEXTURE_FILTER - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DOBJ_TEXTURE_FILTER, false); + rPoolDefaults[ SDRATTR_3DOBJ_SMOOTH_NORMALS - SDRATTR_START ] = new Svx3DSmoothNormalsItem; + rPoolDefaults[ SDRATTR_3DOBJ_SMOOTH_LIDS - SDRATTR_START ] = new Svx3DSmoothLidsItem; + rPoolDefaults[ SDRATTR_3DOBJ_CHARACTER_MODE - SDRATTR_START ] = new Svx3DCharacterModeItem; + rPoolDefaults[ SDRATTR_3DOBJ_CLOSE_FRONT - SDRATTR_START ] = new Svx3DCloseFrontItem; + rPoolDefaults[ SDRATTR_3DOBJ_CLOSE_BACK - SDRATTR_START ] = new Svx3DCloseBackItem; + rPoolDefaults[ SDRATTR_3DOBJ_REDUCED_LINE_GEOMETRY - SDRATTR_START ] = new Svx3DReducedLineGeometryItem; + rPoolDefaults[ SDRATTR_3DSCENE_PERSPECTIVE - SDRATTR_START ] = new Svx3DPerspectiveItem; + rPoolDefaults[ SDRATTR_3DSCENE_DISTANCE - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DSCENE_DISTANCE, 100); + rPoolDefaults[ SDRATTR_3DSCENE_FOCAL_LENGTH - SDRATTR_START ] = new SfxUInt32Item(SDRATTR_3DSCENE_FOCAL_LENGTH, 100); + rPoolDefaults[ SDRATTR_3DSCENE_TWO_SIDED_LIGHTING - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_1 - SDRATTR_START ] = new SvxColorItem(Color(ColorTransparency, 0xffcccccc), SDRATTR_3DSCENE_LIGHTCOLOR_1); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_2 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_2); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_3 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_3); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_4 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_4); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_5 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_5); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_6 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_6); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_7 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_7); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTCOLOR_8 - SDRATTR_START ] = new SvxColorItem(Color(0x00000000), SDRATTR_3DSCENE_LIGHTCOLOR_8); + rPoolDefaults[ SDRATTR_3DSCENE_AMBIENTCOLOR - SDRATTR_START ] = new SvxColorItem(Color(0x00666666), SDRATTR_3DSCENE_AMBIENTCOLOR); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_1 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_1, true); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_2 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_2, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_3 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_3, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_4 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_4, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_5 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_5, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_6 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_6, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_7 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_7, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTON_8 - SDRATTR_START ] = new SfxBoolItem(SDRATTR_3DSCENE_LIGHTON_8, false); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_1 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_1, basegfx::B3DVector(0.57735026918963, 0.57735026918963, 0.57735026918963)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_2 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_2, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_3 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_3, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_4 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_4, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_5 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_5, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_6 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_6, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_7 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_7, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_LIGHTDIRECTION_8 - SDRATTR_START ] = new SvxB3DVectorItem(SDRATTR_3DSCENE_LIGHTDIRECTION_8, basegfx::B3DVector(0.0,0.0,1.0)); + rPoolDefaults[ SDRATTR_3DSCENE_SHADOW_SLANT - SDRATTR_START ] = new SfxUInt16Item(SDRATTR_3DSCENE_SHADOW_SLANT, 0); + rPoolDefaults[ SDRATTR_3DSCENE_SHADE_MODE - SDRATTR_START ] = new Svx3DShadeModeItem; + rPoolDefaults[ SDRATTR_CUSTOMSHAPE_ENGINE - SDRATTR_START ] = new SfxStringItem(SDRATTR_CUSTOMSHAPE_ENGINE, ""); + rPoolDefaults[ SDRATTR_CUSTOMSHAPE_DATA - SDRATTR_START ] = new SfxStringItem(SDRATTR_CUSTOMSHAPE_DATA, ""); + rPoolDefaults[ SDRATTR_CUSTOMSHAPE_GEOMETRY - SDRATTR_START ] = new SdrCustomShapeGeometryItem; + + SvxBoxItem* pboxItem = new SvxBoxItem( SDRATTR_TABLE_BORDER ); + pboxItem->SetAllDistances( 100 ); + rPoolDefaults[ SDRATTR_TABLE_BORDER - SDRATTR_START ] = pboxItem; + + SvxBoxInfoItem* pBoxInfoItem = new SvxBoxInfoItem( SDRATTR_TABLE_BORDER_INNER ); + + pBoxInfoItem->SetTable( true ); + pBoxInfoItem->SetDist( true); // always show margin field + pBoxInfoItem->SetValid( SvxBoxInfoItemValidFlags::DISABLE ); // some lines may have DontCare state only in tables + + rPoolDefaults[ SDRATTR_TABLE_BORDER_INNER - SDRATTR_START ] = pBoxInfoItem; + rPoolDefaults[ SDRATTR_TABLE_BORDER_TLBR - SDRATTR_START ] = new SvxLineItem( SDRATTR_TABLE_BORDER_TLBR ); + rPoolDefaults[ SDRATTR_TABLE_BORDER_BLTR - SDRATTR_START ] = new SvxLineItem( SDRATTR_TABLE_BORDER_BLTR ); + rPoolDefaults[ SDRATTR_TABLE_TEXT_ROTATION - SDRATTR_START ] = new SvxTextRotateItem(0_deg10, SDRATTR_TABLE_TEXT_ROTATION); + rPoolDefaults[ SDRATTR_TABLE_CELL_GRABBAG - SDRATTR_START ] = new SfxGrabBagItem(SDRATTR_TABLE_CELL_GRABBAG); + + rPoolDefaults[ SDRATTR_GLOW_RADIUS - SDRATTR_START ] = new SdrMetricItem(SDRATTR_GLOW_RADIUS, 0); + rPoolDefaults[ SDRATTR_GLOW_COLOR - SDRATTR_START ] = new XColorItem(SDRATTR_GLOW_COLOR, aNullCol); + rPoolDefaults[ SDRATTR_GLOW_TRANSPARENCY - SDRATTR_START ] = new SdrPercentItem(SDRATTR_GLOW_TRANSPARENCY, 0); + + rPoolDefaults[SDRATTR_SOFTEDGE_RADIUS - SDRATTR_START] = new SdrMetricItem(SDRATTR_SOFTEDGE_RADIUS, 0); + + rPoolDefaults[SDRATTR_TEXTCOLUMNS_NUMBER - SDRATTR_START] = new SfxInt16Item(SDRATTR_TEXTCOLUMNS_NUMBER, 1); + rPoolDefaults[SDRATTR_TEXTCOLUMNS_SPACING - SDRATTR_START] = new SdrMetricItem(SDRATTR_TEXTCOLUMNS_SPACING, 0); + + rPoolDefaults[SDRATTR_WRITINGMODE2 - SDRATTR_START] = new SvxFrameDirectionItem(SvxFrameDirection::Horizontal_LR_TB, SDRATTR_WRITINGMODE2); + + // set own ItemInfos + mpLocalItemInfos[SDRATTR_SHADOW-SDRATTR_START]._nSID=SID_ATTR_FILL_SHADOW; + mpLocalItemInfos[SDRATTR_SHADOWCOLOR-SDRATTR_START]._nSID=SID_ATTR_SHADOW_COLOR; + mpLocalItemInfos[SDRATTR_SHADOWTRANSPARENCE-SDRATTR_START]._nSID=SID_ATTR_SHADOW_TRANSPARENCE; + mpLocalItemInfos[SDRATTR_SHADOWBLUR-SDRATTR_START]._nSID=SID_ATTR_SHADOW_BLUR; + mpLocalItemInfos[SDRATTR_SHADOWXDIST-SDRATTR_START]._nSID=SID_ATTR_SHADOW_XDISTANCE; + mpLocalItemInfos[SDRATTR_SHADOWYDIST-SDRATTR_START]._nSID=SID_ATTR_SHADOW_YDISTANCE; + mpLocalItemInfos[SDRATTR_TEXT_FITTOSIZE-SDRATTR_START]._nSID=SID_ATTR_TEXT_FITTOSIZE; + mpLocalItemInfos[SDRATTR_GRAFCROP-SDRATTR_START]._nSID=SID_ATTR_GRAF_CROP; + + mpLocalItemInfos[SDRATTR_TABLE_BORDER - SDRATTR_START ]._nSID = SID_ATTR_BORDER_OUTER; + mpLocalItemInfos[SDRATTR_TABLE_BORDER_INNER - SDRATTR_START ]._nSID = SID_ATTR_BORDER_INNER; + mpLocalItemInfos[SDRATTR_TABLE_BORDER_TLBR - SDRATTR_START ]._nSID = SID_ATTR_BORDER_DIAG_TLBR; + mpLocalItemInfos[SDRATTR_TABLE_BORDER_BLTR - SDRATTR_START ]._nSID = SID_ATTR_BORDER_DIAG_BLTR; + + mpLocalItemInfos[SDRATTR_GLOW_RADIUS - SDRATTR_START]._nSID = SID_ATTR_GLOW_RADIUS; + mpLocalItemInfos[SDRATTR_GLOW_COLOR - SDRATTR_START]._nSID = SID_ATTR_GLOW_COLOR; + mpLocalItemInfos[SDRATTR_GLOW_TRANSPARENCY - SDRATTR_START]._nSID = SID_ATTR_GLOW_TRANSPARENCY; + + mpLocalItemInfos[SDRATTR_SOFTEDGE_RADIUS - SDRATTR_START]._nSID = SID_ATTR_SOFTEDGE_RADIUS; + + mpLocalItemInfos[SDRATTR_TEXTCOLUMNS_NUMBER - SDRATTR_START]._nSID = 0 /*TODO*/; + mpLocalItemInfos[SDRATTR_TEXTCOLUMNS_SPACING - SDRATTR_START]._nSID = 0 /*TODO*/; + + mpLocalItemInfos[SDRATTR_WRITINGMODE2 - SDRATTR_START]._nSID = 0 /*TODO*/; + + // it's my own creation level, set Defaults and ItemInfos + SetDefaults(mpLocalPoolDefaults); + SetItemInfos(mpLocalItemInfos.get()); +} + +// copy ctor, so that static defaults are cloned +// (Parameter 2 = sal_True) +SdrItemPool::SdrItemPool(const SdrItemPool& rPool) +: XOutdevItemPool(rPool) +{ +} + +rtl::Reference SdrItemPool::Clone() const +{ + return new SdrItemPool(*this); +} + +SdrItemPool::~SdrItemPool() +{ + // split pools before destroying + SetSecondaryPool(nullptr); +} + +bool SdrItemPool::GetPresentation( + const SfxPoolItem& rItem, + MapUnit ePresentationMetric, OUString& rText, + const IntlWrapper& rIntlWrapper) const +{ + if (!IsInvalidItem(&rItem)) { + sal_uInt16 nWhich=rItem.Which(); + if (nWhich>=SDRATTR_SHADOW_FIRST && nWhich<=SDRATTR_END) { + rItem.GetPresentation(SfxItemPresentation::Nameless, + GetMetric(nWhich),ePresentationMetric,rText, + rIntlWrapper); + rText = GetItemName(nWhich) + " " + rText; + + return true; + } + } + return XOutdevItemPool::GetPresentation(rItem,ePresentationMetric,rText,rIntlWrapper); +} + +OUString SdrItemPool::GetItemName(sal_uInt16 nWhich) +{ + TranslateId pResId = SIP_UNKNOWN_ATTR; + + switch (nWhich) + { + case XATTR_LINESTYLE : pResId = SIP_XA_LINESTYLE;break; + case XATTR_LINEDASH : pResId = SIP_XA_LINEDASH;break; + case XATTR_LINEWIDTH : pResId = SIP_XA_LINEWIDTH;break; + case XATTR_LINECOLOR : pResId = SIP_XA_LINECOLOR;break; + case XATTR_LINESTART : pResId = SIP_XA_LINESTART;break; + case XATTR_LINEEND : pResId = SIP_XA_LINEEND;break; + case XATTR_LINESTARTWIDTH : pResId = SIP_XA_LINESTARTWIDTH;break; + case XATTR_LINEENDWIDTH : pResId = SIP_XA_LINEENDWIDTH;break; + case XATTR_LINESTARTCENTER : pResId = SIP_XA_LINESTARTCENTER;break; + case XATTR_LINEENDCENTER : pResId = SIP_XA_LINEENDCENTER;break; + case XATTR_LINETRANSPARENCE : pResId = SIP_XA_LINETRANSPARENCE;break; + case XATTR_LINEJOINT : pResId = SIP_XA_LINEJOINT;break; + case XATTRSET_LINE : pResId = SIP_XATTRSET_LINE;break; + + case XATTR_FILLSTYLE : pResId = SIP_XA_FILLSTYLE;break; + case XATTR_FILLCOLOR : pResId = SIP_XA_FILLCOLOR;break; + case XATTR_FILLGRADIENT : pResId = SIP_XA_FILLGRADIENT;break; + case XATTR_FILLHATCH : pResId = SIP_XA_FILLHATCH;break; + case XATTR_FILLBITMAP : pResId = SIP_XA_FILLBITMAP;break; + case XATTR_FILLTRANSPARENCE : pResId = SIP_XA_FILLTRANSPARENCE;break; + case XATTR_GRADIENTSTEPCOUNT : pResId = SIP_XA_GRADIENTSTEPCOUNT;break; + case XATTR_FILLBMP_TILE : pResId = SIP_XA_FILLBMP_TILE;break; + case XATTR_FILLBMP_POS : pResId = SIP_XA_FILLBMP_POS;break; + case XATTR_FILLBMP_SIZEX : pResId = SIP_XA_FILLBMP_SIZEX;break; + case XATTR_FILLBMP_SIZEY : pResId = SIP_XA_FILLBMP_SIZEY;break; + case XATTR_FILLFLOATTRANSPARENCE: pResId = SIP_XA_FILLFLOATTRANSPARENCE;break; + case XATTR_SECONDARYFILLCOLOR : pResId = SIP_XA_SECONDARYFILLCOLOR;break; + case XATTR_FILLBMP_SIZELOG : pResId = SIP_XA_FILLBMP_SIZELOG;break; + case XATTR_FILLBMP_TILEOFFSETX : pResId = SIP_XA_FILLBMP_TILEOFFSETX;break; + case XATTR_FILLBMP_TILEOFFSETY : pResId = SIP_XA_FILLBMP_TILEOFFSETY;break; + case XATTR_FILLBMP_STRETCH : pResId = SIP_XA_FILLBMP_STRETCH;break; + case XATTR_FILLBMP_POSOFFSETX : pResId = SIP_XA_FILLBMP_POSOFFSETX;break; + case XATTR_FILLBMP_POSOFFSETY : pResId = SIP_XA_FILLBMP_POSOFFSETY;break; + case XATTR_FILLBACKGROUND : pResId = SIP_XA_FILLBACKGROUND;break; + case XATTR_FILLUSESLIDEBACKGROUND: pResId = SIP_XA_FILLUSESLIDEBACKGROUND;break; + + case XATTRSET_FILL : pResId = SIP_XATTRSET_FILL;break; + + case XATTR_FORMTXTSTYLE : pResId = SIP_XA_FORMTXTSTYLE;break; + case XATTR_FORMTXTADJUST : pResId = SIP_XA_FORMTXTADJUST;break; + case XATTR_FORMTXTDISTANCE : pResId = SIP_XA_FORMTXTDISTANCE;break; + case XATTR_FORMTXTSTART : pResId = SIP_XA_FORMTXTSTART;break; + case XATTR_FORMTXTMIRROR : pResId = SIP_XA_FORMTXTMIRROR;break; + case XATTR_FORMTXTOUTLINE : pResId = SIP_XA_FORMTXTOUTLINE;break; + case XATTR_FORMTXTSHADOW : pResId = SIP_XA_FORMTXTSHADOW;break; + case XATTR_FORMTXTSHDWCOLOR : pResId = SIP_XA_FORMTXTSHDWCOLOR;break; + case XATTR_FORMTXTSHDWXVAL : pResId = SIP_XA_FORMTXTSHDWXVAL;break; + case XATTR_FORMTXTSHDWYVAL : pResId = SIP_XA_FORMTXTSHDWYVAL;break; + case XATTR_FORMTXTHIDEFORM : pResId = SIP_XA_FORMTXTHIDEFORM;break; + case XATTR_FORMTXTSHDWTRANSP: pResId = SIP_XA_FORMTXTSHDWTRANSP;break; + + case SDRATTR_SHADOW : pResId = SIP_SA_SHADOW;break; + case SDRATTR_SHADOWCOLOR : pResId = SIP_SA_SHADOWCOLOR;break; + case SDRATTR_SHADOWXDIST : pResId = SIP_SA_SHADOWXDIST;break; + case SDRATTR_SHADOWYDIST : pResId = SIP_SA_SHADOWYDIST;break; + case SDRATTR_SHADOWTRANSPARENCE: pResId = SIP_SA_SHADOWTRANSPARENCE;break; + case SDRATTR_SHADOWBLUR : pResId = SIP_SA_SHADOWBLUR;break; + case SDRATTR_SHADOW3D : pResId = SIP_SA_SHADOW3D;break; + case SDRATTR_SHADOWPERSP : pResId = SIP_SA_SHADOWPERSP;break; + + case SDRATTR_GLOW_RADIUS : pResId = SIP_SA_GLOW_RADIUS;break; + case SDRATTR_GLOW_COLOR : pResId = SIP_SA_GLOW_COLOR;break; + case SDRATTR_GLOW_TRANSPARENCY : pResId = SIP_SA_GLOW_TRANSPARENCY;break; + + case SDRATTR_SOFTEDGE_RADIUS : pResId = SIP_SA_SOFTEDGE_RADIUS; break; + + case SDRATTR_CAPTIONTYPE : pResId = SIP_SA_CAPTIONTYPE;break; + case SDRATTR_CAPTIONFIXEDANGLE: pResId = SIP_SA_CAPTIONFIXEDANGLE;break; + case SDRATTR_CAPTIONANGLE : pResId = SIP_SA_CAPTIONANGLE;break; + case SDRATTR_CAPTIONGAP : pResId = SIP_SA_CAPTIONGAP;break; + case SDRATTR_CAPTIONESCDIR : pResId = SIP_SA_CAPTIONESCDIR;break; + case SDRATTR_CAPTIONESCISREL : pResId = SIP_SA_CAPTIONESCISREL;break; + case SDRATTR_CAPTIONESCREL : pResId = SIP_SA_CAPTIONESCREL;break; + case SDRATTR_CAPTIONESCABS : pResId = SIP_SA_CAPTIONESCABS;break; + case SDRATTR_CAPTIONLINELEN : pResId = SIP_SA_CAPTIONLINELEN;break; + case SDRATTR_CAPTIONFITLINELEN: pResId = SIP_SA_CAPTIONFITLINELEN;break; + + case SDRATTR_CORNER_RADIUS : pResId = SIP_SA_CORNER_RADIUS;break; + case SDRATTR_TEXT_MINFRAMEHEIGHT : pResId = SIP_SA_TEXT_MINFRAMEHEIGHT;break; + case SDRATTR_TEXT_AUTOGROWHEIGHT : pResId = SIP_SA_TEXT_AUTOGROWHEIGHT;break; + case SDRATTR_TEXT_FITTOSIZE : pResId = SIP_SA_TEXT_FITTOSIZE;break; + case SDRATTR_TEXT_LEFTDIST : pResId = SIP_SA_TEXT_LEFTDIST;break; + case SDRATTR_TEXT_RIGHTDIST : pResId = SIP_SA_TEXT_RIGHTDIST;break; + case SDRATTR_TEXT_UPPERDIST : pResId = SIP_SA_TEXT_UPPERDIST;break; + case SDRATTR_TEXT_LOWERDIST : pResId = SIP_SA_TEXT_LOWERDIST;break; + case SDRATTR_TEXT_VERTADJUST : pResId = SIP_SA_TEXT_VERTADJUST;break; + case SDRATTR_TEXT_MAXFRAMEHEIGHT : pResId = SIP_SA_TEXT_MAXFRAMEHEIGHT;break; + case SDRATTR_TEXT_MINFRAMEWIDTH : pResId = SIP_SA_TEXT_MINFRAMEWIDTH;break; + case SDRATTR_TEXT_MAXFRAMEWIDTH : pResId = SIP_SA_TEXT_MAXFRAMEWIDTH;break; + case SDRATTR_TEXT_AUTOGROWWIDTH : pResId = SIP_SA_TEXT_AUTOGROWWIDTH;break; + case SDRATTR_TEXT_HORZADJUST : pResId = SIP_SA_TEXT_HORZADJUST;break; + case SDRATTR_TEXT_ANIKIND : pResId = SIP_SA_TEXT_ANIKIND;break; + case SDRATTR_TEXT_ANIDIRECTION : pResId = SIP_SA_TEXT_ANIDIRECTION;break; + case SDRATTR_TEXT_ANISTARTINSIDE : pResId = SIP_SA_TEXT_ANISTARTINSIDE;break; + case SDRATTR_TEXT_ANISTOPINSIDE : pResId = SIP_SA_TEXT_ANISTOPINSIDE;break; + case SDRATTR_TEXT_ANICOUNT : pResId = SIP_SA_TEXT_ANICOUNT;break; + case SDRATTR_TEXT_ANIDELAY : pResId = SIP_SA_TEXT_ANIDELAY;break; + case SDRATTR_TEXT_ANIAMOUNT : pResId = SIP_SA_TEXT_ANIAMOUNT;break; + case SDRATTR_TEXT_CONTOURFRAME : pResId = SIP_SA_TEXT_CONTOURFRAME;break; + case SDRATTR_XMLATTRIBUTES : pResId = SIP_SA_XMLATTRIBUTES;break; + case SDRATTR_TEXT_USEFIXEDCELLHEIGHT: pResId = SIP_SA_TEXT_USEFIXEDCELLHEIGHT;break; + case SDRATTR_TEXT_WORDWRAP : pResId = SIP_SA_WORDWRAP;break; + case SDRATTR_TEXT_CHAINNEXTNAME : pResId = SIP_SA_CHAINNEXTNAME;break; + + case SDRATTR_EDGEKIND : pResId = SIP_SA_EDGEKIND;break; + case SDRATTR_EDGENODE1HORZDIST : pResId = SIP_SA_EDGENODE1HORZDIST;break; + case SDRATTR_EDGENODE1VERTDIST : pResId = SIP_SA_EDGENODE1VERTDIST;break; + case SDRATTR_EDGENODE2HORZDIST : pResId = SIP_SA_EDGENODE2HORZDIST;break; + case SDRATTR_EDGENODE2VERTDIST : pResId = SIP_SA_EDGENODE2VERTDIST;break; + case SDRATTR_EDGENODE1GLUEDIST : pResId = SIP_SA_EDGENODE1GLUEDIST;break; + case SDRATTR_EDGENODE2GLUEDIST : pResId = SIP_SA_EDGENODE2GLUEDIST;break; + case SDRATTR_EDGELINEDELTACOUNT : pResId = SIP_SA_EDGELINEDELTACOUNT;break; + case SDRATTR_EDGELINE1DELTA : pResId = SIP_SA_EDGELINE1DELTA;break; + case SDRATTR_EDGELINE2DELTA : pResId = SIP_SA_EDGELINE2DELTA;break; + case SDRATTR_EDGELINE3DELTA : pResId = SIP_SA_EDGELINE3DELTA;break; + + case SDRATTR_MEASUREKIND : pResId = SIP_SA_MEASUREKIND;break; + case SDRATTR_MEASURETEXTHPOS : pResId = SIP_SA_MEASURETEXTHPOS;break; + case SDRATTR_MEASURETEXTVPOS : pResId = SIP_SA_MEASURETEXTVPOS;break; + case SDRATTR_MEASURELINEDIST : pResId = SIP_SA_MEASURELINEDIST;break; + case SDRATTR_MEASUREHELPLINEOVERHANG : pResId = SIP_SA_MEASUREHELPLINEOVERHANG;break; + case SDRATTR_MEASUREHELPLINEDIST : pResId = SIP_SA_MEASUREHELPLINEDIST;break; + case SDRATTR_MEASUREHELPLINE1LEN : pResId = SIP_SA_MEASUREHELPLINE1LEN;break; + case SDRATTR_MEASUREHELPLINE2LEN : pResId = SIP_SA_MEASUREHELPLINE2LEN;break; + case SDRATTR_MEASUREBELOWREFEDGE : pResId = SIP_SA_MEASUREBELOWREFEDGE;break; + case SDRATTR_MEASURETEXTROTA90 : pResId = SIP_SA_MEASURETEXTROTA90;break; + case SDRATTR_MEASURETEXTUPSIDEDOWN : pResId = SIP_SA_MEASURETEXTUPSIDEDOWN;break; + case SDRATTR_MEASUREOVERHANG : pResId = SIP_SA_MEASUREOVERHANG;break; + case SDRATTR_MEASUREUNIT : pResId = SIP_SA_MEASUREUNIT;break; + case SDRATTR_MEASURESCALE : pResId = SIP_SA_MEASURESCALE;break; + case SDRATTR_MEASURESHOWUNIT : pResId = SIP_SA_MEASURESHOWUNIT;break; + case SDRATTR_MEASUREFORMATSTRING : pResId = SIP_SA_MEASUREFORMATSTRING;break; + case SDRATTR_MEASURETEXTAUTOANGLE : pResId = SIP_SA_MEASURETEXTAUTOANGLE;break; + case SDRATTR_MEASURETEXTAUTOANGLEVIEW: pResId = SIP_SA_MEASURETEXTAUTOANGLEVIEW;break; + case SDRATTR_MEASURETEXTISFIXEDANGLE : pResId = SIP_SA_MEASURETEXTISFIXEDANGLE;break; + case SDRATTR_MEASURETEXTFIXEDANGLE : pResId = SIP_SA_MEASURETEXTFIXEDANGLE;break; + case SDRATTR_MEASUREDECIMALPLACES : pResId = SIP_SA_MEASUREDECIMALPLACES;break; + + case SDRATTR_CIRCKIND : pResId = SIP_SA_CIRCKIND;break; + case SDRATTR_CIRCSTARTANGLE: pResId = SIP_SA_CIRCSTARTANGLE;break; + case SDRATTR_CIRCENDANGLE : pResId = SIP_SA_CIRCENDANGLE;break; + + case SDRATTR_OBJMOVEPROTECT : pResId = SIP_SA_OBJMOVEPROTECT;break; + case SDRATTR_OBJSIZEPROTECT : pResId = SIP_SA_OBJSIZEPROTECT;break; + case SDRATTR_OBJPRINTABLE : pResId = SIP_SA_OBJPRINTABLE;break; + case SDRATTR_OBJVISIBLE : pResId = SIP_SA_OBJVISIBLE;break; + case SDRATTR_LAYERID : pResId = SIP_SA_LAYERID;break; + case SDRATTR_LAYERNAME : pResId = SIP_SA_LAYERNAME;break; + case SDRATTR_OBJECTNAME : pResId = SIP_SA_OBJECTNAME;break; + case SDRATTR_ALLPOSITIONX : pResId = SIP_SA_ALLPOSITIONX;break; + case SDRATTR_ALLPOSITIONY : pResId = SIP_SA_ALLPOSITIONY;break; + case SDRATTR_ALLSIZEWIDTH : pResId = SIP_SA_ALLSIZEWIDTH;break; + case SDRATTR_ALLSIZEHEIGHT : pResId = SIP_SA_ALLSIZEHEIGHT;break; + case SDRATTR_ONEPOSITIONX : pResId = SIP_SA_ONEPOSITIONX;break; + case SDRATTR_ONEPOSITIONY : pResId = SIP_SA_ONEPOSITIONY;break; + case SDRATTR_ONESIZEWIDTH : pResId = SIP_SA_ONESIZEWIDTH;break; + case SDRATTR_ONESIZEHEIGHT : pResId = SIP_SA_ONESIZEHEIGHT;break; + case SDRATTR_LOGICSIZEWIDTH : pResId = SIP_SA_LOGICSIZEWIDTH;break; + case SDRATTR_LOGICSIZEHEIGHT: pResId = SIP_SA_LOGICSIZEHEIGHT;break; + case SDRATTR_ROTATEANGLE : pResId = SIP_SA_ROTATEANGLE;break; + case SDRATTR_SHEARANGLE : pResId = SIP_SA_SHEARANGLE;break; + case SDRATTR_MOVEX : pResId = SIP_SA_MOVEX;break; + case SDRATTR_MOVEY : pResId = SIP_SA_MOVEY;break; + case SDRATTR_RESIZEXONE : pResId = SIP_SA_RESIZEXONE;break; + case SDRATTR_RESIZEYONE : pResId = SIP_SA_RESIZEYONE;break; + case SDRATTR_ROTATEONE : pResId = SIP_SA_ROTATEONE;break; + case SDRATTR_HORZSHEARONE : pResId = SIP_SA_HORZSHEARONE;break; + case SDRATTR_VERTSHEARONE : pResId = SIP_SA_VERTSHEARONE;break; + case SDRATTR_RESIZEXALL : pResId = SIP_SA_RESIZEXALL;break; + case SDRATTR_RESIZEYALL : pResId = SIP_SA_RESIZEYALL;break; + case SDRATTR_ROTATEALL : pResId = SIP_SA_ROTATEALL;break; + case SDRATTR_HORZSHEARALL : pResId = SIP_SA_HORZSHEARALL;break; + case SDRATTR_VERTSHEARALL : pResId = SIP_SA_VERTSHEARALL;break; + case SDRATTR_TRANSFORMREF1X : pResId = SIP_SA_TRANSFORMREF1X;break; + case SDRATTR_TRANSFORMREF1Y : pResId = SIP_SA_TRANSFORMREF1Y;break; + case SDRATTR_TRANSFORMREF2X : pResId = SIP_SA_TRANSFORMREF2X;break; + case SDRATTR_TRANSFORMREF2Y : pResId = SIP_SA_TRANSFORMREF2Y;break; + + case SDRATTR_GRAFRED : pResId = SIP_SA_GRAFRED;break; + case SDRATTR_GRAFGREEN : pResId = SIP_SA_GRAFGREEN;break; + case SDRATTR_GRAFBLUE : pResId = SIP_SA_GRAFBLUE;break; + case SDRATTR_GRAFLUMINANCE : pResId = SIP_SA_GRAFLUMINANCE;break; + case SDRATTR_GRAFCONTRAST : pResId = SIP_SA_GRAFCONTRAST;break; + case SDRATTR_GRAFGAMMA : pResId = SIP_SA_GRAFGAMMA;break; + case SDRATTR_GRAFTRANSPARENCE : pResId = SIP_SA_GRAFTRANSPARENCE;break; + case SDRATTR_GRAFINVERT : pResId = SIP_SA_GRAFINVERT;break; + case SDRATTR_GRAFMODE : pResId = SIP_SA_GRAFMODE;break; + case SDRATTR_GRAFCROP : pResId = SIP_SA_GRAFCROP;break; + + case EE_PARA_HYPHENATE : pResId = SIP_EE_PARA_HYPHENATE;break; + case EE_PARA_BULLETSTATE: pResId = SIP_EE_PARA_BULLETSTATE;break; + case EE_PARA_OUTLLRSPACE: pResId = SIP_EE_PARA_OUTLLRSPACE;break; + case EE_PARA_OUTLLEVEL : pResId = SIP_EE_PARA_OUTLLEVEL;break; + case EE_PARA_BULLET : pResId = SIP_EE_PARA_BULLET;break; + case EE_PARA_LRSPACE : pResId = SIP_EE_PARA_LRSPACE;break; + case EE_PARA_ULSPACE : pResId = SIP_EE_PARA_ULSPACE;break; + case EE_PARA_SBL : pResId = SIP_EE_PARA_SBL;break; + case EE_PARA_JUST : pResId = SIP_EE_PARA_JUST;break; + case EE_PARA_TABS : pResId = SIP_EE_PARA_TABS;break; + + case EE_CHAR_COLOR : pResId = SIP_EE_CHAR_COLOR;break; + case EE_CHAR_FONTINFO : pResId = SIP_EE_CHAR_FONTINFO;break; + case EE_CHAR_FONTHEIGHT : pResId = SIP_EE_CHAR_FONTHEIGHT;break; + case EE_CHAR_FONTWIDTH : pResId = SIP_EE_CHAR_FONTWIDTH;break; + case EE_CHAR_WEIGHT : pResId = SIP_EE_CHAR_WEIGHT;break; + case EE_CHAR_UNDERLINE : pResId = SIP_EE_CHAR_UNDERLINE;break; + case EE_CHAR_OVERLINE : pResId = SIP_EE_CHAR_OVERLINE;break; + case EE_CHAR_STRIKEOUT : pResId = SIP_EE_CHAR_STRIKEOUT;break; + case EE_CHAR_ITALIC : pResId = SIP_EE_CHAR_ITALIC;break; + case EE_CHAR_OUTLINE : pResId = SIP_EE_CHAR_OUTLINE;break; + case EE_CHAR_SHADOW : pResId = SIP_EE_CHAR_SHADOW;break; + case EE_CHAR_ESCAPEMENT : pResId = SIP_EE_CHAR_ESCAPEMENT;break; + case EE_CHAR_PAIRKERNING: pResId = SIP_EE_CHAR_PAIRKERNING;break; + case EE_CHAR_KERNING : pResId = SIP_EE_CHAR_KERNING;break; + case EE_CHAR_WLM : pResId = SIP_EE_CHAR_WLM;break; + case EE_FEATURE_TAB : pResId = SIP_EE_FEATURE_TAB;break; + case EE_FEATURE_LINEBR : pResId = SIP_EE_FEATURE_LINEBR;break; + case EE_FEATURE_NOTCONV : pResId = SIP_EE_FEATURE_NOTCONV;break; + case EE_FEATURE_FIELD : pResId = SIP_EE_FEATURE_FIELD;break; + + case SDRATTR_TEXTCOLUMNS_NUMBER: pResId = SIP_SA_TEXTCOLUMNS_NUMBER; break; + case SDRATTR_TEXTCOLUMNS_SPACING: pResId = SIP_SA_TEXTCOLUMNS_SPACING; break; + } // switch + + return SvxResId(pResId); +} + + +// FractionItem + + +bool SdrFractionItem::operator==(const SfxPoolItem& rCmp) const +{ + return SfxPoolItem::operator==(rCmp) && + static_cast(rCmp).GetValue()==nValue; +} + +bool SdrFractionItem::GetPresentation( + SfxItemPresentation ePresentation, MapUnit /*eCoreMetric*/, + MapUnit /*ePresentationMetric*/, OUString &rText, const IntlWrapper&) const +{ + if(nValue.IsValid()) + { + sal_Int32 nDiv = nValue.GetDenominator(); + rText = OUString::number(nValue.GetNumerator()); + + if(nDiv != 1) + { + rText += "/" + OUString::number(nDiv); + } + } + else + { + rText = "?"; + } + + if(ePresentation == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + return true; + } + else if(ePresentation == SfxItemPresentation::Nameless) + return true; + + return false; +} + +SdrFractionItem* SdrFractionItem::Clone(SfxItemPool * /*pPool*/) const +{ + return new SdrFractionItem(Which(),GetValue()); +} + + +// ScaleItem + + +bool SdrScaleItem::GetPresentation( + SfxItemPresentation ePresentation, MapUnit /*eCoreMetric*/, + MapUnit /*ePresentationMetric*/, OUString &rText, const IntlWrapper&) const +{ + if(GetValue().IsValid()) + { + sal_Int32 nDiv = GetValue().GetDenominator(); + + rText = OUString::number(GetValue().GetNumerator()) + ":" + OUString::number(nDiv); + } + else + { + rText = "?"; + } + + if(ePresentation == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + + return true; +} + +SdrScaleItem* SdrScaleItem::Clone(SfxItemPool * /*pPool*/) const +{ + return new SdrScaleItem(Which(),GetValue()); +} + + +// OnOffItem + + +SdrOnOffItem* SdrOnOffItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrOnOffItem(TypedWhichId(Which()),GetValue()); +} + +OUString SdrOnOffItem::GetValueTextByVal(bool bVal) const +{ + if (bVal) + return SvxResId(STR_ItemValON); + return SvxResId(STR_ItemValOFF); +} + +bool SdrOnOffItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByVal(GetValue()); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +void SdrOnOffItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrOnOffItem")); + if (Which() == SDRATTR_SHADOW) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOW")); + } + + SfxBoolItem::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +SdrYesNoItem* SdrYesNoItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrYesNoItem(TypedWhichId(Which()),GetValue()); +} + +OUString SdrYesNoItem::GetValueTextByVal(bool bVal) const +{ + if (bVal) + return SvxResId(STR_ItemValYES); + return SvxResId(STR_ItemValNO); +} + +bool SdrYesNoItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByVal(GetValue()); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +SdrPercentItem* SdrPercentItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrPercentItem(TypedWhichId(Which()),GetValue()); +} + +bool SdrPercentItem::GetPresentation( + SfxItemPresentation ePres, MapUnit /*eCoreMetric*/, + MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText = unicode::formatPercent(GetValue(), + Application::GetSettings().GetUILanguageTag()); + + if(ePres == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + + return true; +} + +void SdrPercentItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPercentItem")); + if (Which() == SDRATTR_SHADOWTRANSPARENCE) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), + BAD_CAST("SDRATTR_SHADOWTRANSPARENCE")); + } + + SfxUInt16Item::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +SdrAngleItem* SdrAngleItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrAngleItem(TypedWhichId(Which()),GetValue()); +} + +bool SdrAngleItem::GetPresentation( + SfxItemPresentation ePres, MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, + OUString& rText, const IntlWrapper& rIntlWrapper) const +{ + sal_Int32 nValue(GetValue()); + bool bNeg(nValue < 0); + + if(bNeg) + nValue = -nValue; + + OUStringBuffer aText = OUString::number(nValue); + + if(nValue) + { + sal_Unicode aUnicodeNull('0'); + sal_Int32 nCount(2); + + if(LocaleDataWrapper::isNumLeadingZero()) + nCount++; + + while(aText.getLength() < nCount) + aText.insert(0, aUnicodeNull); + + sal_Int32 nLen = aText.getLength(); + bool bNull1(aText[nLen-1] == aUnicodeNull); + bool bNull2(bNull1 && aText[nLen-2] == aUnicodeNull); + + if(bNull2) + { + // no decimal place(s) + sal_Int32 idx = nLen-2; + aText.remove(idx, aText.getLength()-idx); + } + else + { + sal_Unicode cDec = + rIntlWrapper.getLocaleData()->getNumDecimalSep()[0]; + aText.insert(nLen-2, cDec); + + if(bNull1) + aText.remove(nLen, aText.getLength()-nLen); + } + + if(bNeg) + aText.insert(0, '-'); + } + + aText.append(sal_Unicode(DEGREE_CHAR)); + + if(ePres == SfxItemPresentation::Complete) + { + OUString aStr = SdrItemPool::GetItemName(Which()); + aText.insert(0, aStr + " "); + } + + rText = aText.makeStringAndClear(); + return true; +} + +SdrMetricItem* SdrMetricItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrMetricItem(TypedWhichId(Which()),GetValue()); +} + +bool SdrMetricItem::HasMetrics() const +{ + return true; +} + +void SdrMetricItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv) +{ + if (GetValue()!=0) { + SetValue(BigInt::Scale(GetValue(), nMul, nDiv)); + } +} + +bool SdrMetricItem::GetPresentation(SfxItemPresentation ePres, + MapUnit eCoreMetric, MapUnit ePresMetric, OUString& rText, const IntlWrapper&) const +{ + tools::Long nValue=GetValue(); + SdrFormatter aFmt(eCoreMetric,ePresMetric); + rText = aFmt.GetStr(nValue); + rText += " " + SdrFormatter::GetUnitStr(ePresMetric); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +void SdrMetricItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrMetricItem")); + if (Which() == SDRATTR_SHADOWXDIST) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWXDIST")); + } + else if (Which() == SDRATTR_SHADOWYDIST) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWYDIST")); + } + else if (Which() == SDRATTR_SHADOWSIZEX) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEX")); + } + else if (Which() == SDRATTR_SHADOWSIZEY) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWSIZEY")); + } + else if (Which() == SDRATTR_SHADOWBLUR) + { + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWBLUR")); + } + + SfxInt32Item::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +// items of the legend object + + +SdrCaptionTypeItem* SdrCaptionTypeItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrCaptionTypeItem(*this); } + +sal_uInt16 SdrCaptionTypeItem::GetValueCount() const { return 4; } + +OUString SdrCaptionTypeItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALCAPTIONTYPES[] = + { + STR_ItemValCAPTIONTYPE1, + STR_ItemValCAPTIONTYPE2, + STR_ItemValCAPTIONTYPE3, + STR_ItemValCAPTIONTYPE4 + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALCAPTIONTYPES) && "wrong pos!"); + return SvxResId(ITEMVALCAPTIONTYPES[nPos]); +} + +bool SdrCaptionTypeItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + + +SdrCaptionEscDirItem* SdrCaptionEscDirItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrCaptionEscDirItem(*this); } + +sal_uInt16 SdrCaptionEscDirItem::GetValueCount() const { return 3; } + +OUString SdrCaptionEscDirItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALCAPTIONTYPES[] = + { + STR_ItemValCAPTIONESCHORI, + STR_ItemValCAPTIONESCVERT, + STR_ItemValCAPTIONESCBESTFIT + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALCAPTIONTYPES) && "wrong pos!"); + return SvxResId(ITEMVALCAPTIONTYPES[nPos]); +} + +bool SdrCaptionEscDirItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + + +// MiscItems + + +// FitToSize + +SfxPoolItem* SdrTextFitToSizeTypeItem::CreateDefault() { return new SdrTextFitToSizeTypeItem; } + +SdrTextFitToSizeTypeItem* SdrTextFitToSizeTypeItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextFitToSizeTypeItem(*this); } + +bool SdrTextFitToSizeTypeItem::operator==(const SfxPoolItem& rItem) const +{ + if (!SfxEnumItem::operator==(rItem)) + { + return false; + } + + return m_nMaxScale == static_cast(rItem).m_nMaxScale; +} + +sal_uInt16 SdrTextFitToSizeTypeItem::GetValueCount() const { return 4; } + +OUString SdrTextFitToSizeTypeItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALFITTISIZETYPES[] = + { + STR_ItemValFITTOSIZENONE, + STR_ItemValFITTOSIZEPROP, + STR_ItemValFITTOSIZEALLLINES, + STR_ItemValFITTOSIZERESIZEAT + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALFITTISIZETYPES) && "wrong pos!"); + return SvxResId(ITEMVALFITTISIZETYPES[nPos]); +} + +bool SdrTextFitToSizeTypeItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrTextFitToSizeTypeItem::HasBoolValue() const { return true; } + +bool SdrTextFitToSizeTypeItem::GetBoolValue() const { return GetValue() != drawing::TextFitToSizeType_NONE; } + +void SdrTextFitToSizeTypeItem::SetBoolValue(bool bVal) +{ + SetValue(bVal ? drawing::TextFitToSizeType_PROPORTIONAL : drawing::TextFitToSizeType_NONE); +} + +bool SdrTextFitToSizeTypeItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + drawing::TextFitToSizeType eFS = GetValue(); + rVal <<= eFS; + + return true; +} + +bool SdrTextFitToSizeTypeItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::TextFitToSizeType eFS; + if(!(rVal >>= eFS)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eFS = static_cast(nEnum); + } + + SetValue(eFS); + + return true; +} + + +SdrTextVertAdjustItem* SdrTextVertAdjustItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextVertAdjustItem(*this); } + +sal_uInt16 SdrTextVertAdjustItem::GetValueCount() const { return 5; } + +OUString SdrTextVertAdjustItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALTEXTVADJTYPES[] = + { + STR_ItemValTEXTVADJTOP, + STR_ItemValTEXTVADJCENTER, + STR_ItemValTEXTVADJBOTTOM, + STR_ItemValTEXTVADJBLOCK, + STR_ItemValTEXTVADJSTRETCH + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALTEXTVADJTYPES) && "wrong pos!"); + return SvxResId(ITEMVALTEXTVADJTYPES[nPos]); +} + +bool SdrTextVertAdjustItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrTextVertAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrTextVertAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::TextVerticalAdjust eAdj; + if(!(rVal >>= eAdj)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eAdj = static_cast(nEnum); + } + + SetValue( static_cast(eAdj) ); + + return true; +} + +void SdrTextVertAdjustItem::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrTextVertAdjustItem")); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr())); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr())); + (void)xmlTextWriterEndElement(pWriter); +} + +SdrTextHorzAdjustItem* SdrTextHorzAdjustItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextHorzAdjustItem(*this); } + +sal_uInt16 SdrTextHorzAdjustItem::GetValueCount() const { return 5; } + +OUString SdrTextHorzAdjustItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALTEXTHADJTYPES[] = + { + STR_ItemValTEXTHADJLEFT, + STR_ItemValTEXTHADJCENTER, + STR_ItemValTEXTHADJRIGHT, + STR_ItemValTEXTHADJBLOCK, + STR_ItemValTEXTHADJSTRETCH + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALTEXTHADJTYPES) && "wrong pos!"); + return SvxResId(ITEMVALTEXTHADJTYPES[nPos]); +} + +bool SdrTextHorzAdjustItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrTextHorzAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrTextHorzAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::TextHorizontalAdjust eAdj; + if(!(rVal >>= eAdj)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eAdj = static_cast(nEnum); + } + + SetValue( static_cast(eAdj) ); + + return true; +} + + +SdrTextAniKindItem* SdrTextAniKindItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextAniKindItem(*this); } + +sal_uInt16 SdrTextAniKindItem::GetValueCount() const { return 5; } + +OUString SdrTextAniKindItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALTEXTANITYPES[] = + { + STR_ItemValTEXTANI_NONE, + STR_ItemValTEXTANI_BLINK, + STR_ItemValTEXTANI_SCROLL, + STR_ItemValTEXTANI_ALTERNATE, + STR_ItemValTEXTANI_SLIDE + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALTEXTANITYPES) && "wrong pos!"); + return SvxResId(ITEMVALTEXTANITYPES[nPos]); +} + +bool SdrTextAniKindItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrTextAniKindItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrTextAniKindItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::TextAnimationKind eKind; + if(!(rVal >>= eKind)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + eKind = static_cast(nEnum); + } + + SetValue( static_cast(eKind) ); + + return true; +} + + +SdrTextAniDirectionItem* SdrTextAniDirectionItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextAniDirectionItem(*this); } + +sal_uInt16 SdrTextAniDirectionItem::GetValueCount() const { return 4; } + +OUString SdrTextAniDirectionItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALTEXTANITYPES[] = + { + STR_ItemValTEXTANI_LEFT, + STR_ItemValTEXTANI_UP, + STR_ItemValTEXTANI_RIGHT, + STR_ItemValTEXTANI_DOWN + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALTEXTANITYPES) && "wrong pos!"); + return SvxResId(ITEMVALTEXTANITYPES[nPos]); +} + +bool SdrTextAniDirectionItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrTextAniDirectionItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrTextAniDirectionItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::TextAnimationDirection eDir; + if(!(rVal >>= eDir)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eDir = static_cast(nEnum); + } + + SetValue( static_cast(eDir) ); + + return true; +} + + +SdrTextAniDelayItem* SdrTextAniDelayItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextAniDelayItem(*this); } + +bool SdrTextAniDelayItem::GetPresentation( + SfxItemPresentation ePres, MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, + OUString& rText, const IntlWrapper&) const +{ + rText = OUString::number(GetValue()) + "ms"; + + if(ePres == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + + return true; +} + + +SdrTextAniAmountItem* SdrTextAniAmountItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrTextAniAmountItem(*this); } + +bool SdrTextAniAmountItem::HasMetrics() const +{ + return GetValue()>0; +} + +void SdrTextAniAmountItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv) +{ + if (GetValue()>0) { + BigInt aVal(GetValue()); + aVal*=nMul; + aVal+=nDiv/2; // to round accurately + aVal/=nDiv; + SetValue(short(aVal)); + } +} + +bool SdrTextAniAmountItem::GetPresentation( + SfxItemPresentation ePres, MapUnit eCoreMetric, MapUnit ePresMetric, + OUString& rText, const IntlWrapper&) const +{ + sal_Int32 nValue(GetValue()); + + if(!nValue) + nValue = -1; + + if(nValue < 0) + { + rText = OUString::number(-nValue) + "pixel"; + } + else + { + SdrFormatter aFmt(eCoreMetric, ePresMetric); + rText = aFmt.GetStr(nValue) + + SdrFormatter::GetUnitStr(ePresMetric); + } + + if(ePres == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + + return true; +} + + +SdrTextFixedCellHeightItem::SdrTextFixedCellHeightItem( bool bUseFixedCellHeight ) + : SfxBoolItem( SDRATTR_TEXT_USEFIXEDCELLHEIGHT, bUseFixedCellHeight ) +{ +} +bool SdrTextFixedCellHeightItem::GetPresentation( SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresentationMetric*/, + OUString &rText, const IntlWrapper& ) const +{ + rText = GetValueTextByVal( GetValue() ); + if (ePres==SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +SdrTextFixedCellHeightItem* SdrTextFixedCellHeightItem::Clone( SfxItemPool * /*pPool*/) const +{ + return new SdrTextFixedCellHeightItem( GetValue() ); +} + +bool SdrTextFixedCellHeightItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + bool bValue = GetValue(); + rVal <<= bValue; + return true; +} +bool SdrTextFixedCellHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + bool bValue; + if( !( rVal >>= bValue ) ) + return false; + SetValue( bValue ); + return true; +} + +// EdgeKind + +SdrEdgeKindItem* SdrEdgeKindItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrEdgeKindItem(*this); } + +sal_uInt16 SdrEdgeKindItem::GetValueCount() const { return 4; } + +OUString SdrEdgeKindItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALEDGES[] = + { + STR_ItemValEDGE_ORTHOLINES, + STR_ItemValEDGE_THREELINES, + STR_ItemValEDGE_ONELINE, + STR_ItemValEDGE_BEZIER + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALEDGES) && "wrong pos!"); + return SvxResId(ITEMVALEDGES[nPos]); +} + +bool SdrEdgeKindItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrEdgeKindItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + drawing::ConnectorType eCT = drawing::ConnectorType_STANDARD; + + switch( GetValue() ) + { + case SdrEdgeKind::OrthoLines : eCT = drawing::ConnectorType_STANDARD; break; + case SdrEdgeKind::ThreeLines : eCT = drawing::ConnectorType_LINES; break; + case SdrEdgeKind::OneLine : eCT = drawing::ConnectorType_LINE; break; + case SdrEdgeKind::Bezier : eCT = drawing::ConnectorType_CURVE; break; + case SdrEdgeKind::Arc : eCT = drawing::ConnectorType_CURVE; break; + default: + OSL_FAIL( "SdrEdgeKindItem::QueryValue : unknown enum" ); + } + + rVal <<= eCT; + + return true; +} + +bool SdrEdgeKindItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::ConnectorType eCT; + if(!(rVal >>= eCT)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eCT = static_cast(nEnum); + } + + SdrEdgeKind eEK = SdrEdgeKind::OrthoLines; + switch( eCT ) + { + case drawing::ConnectorType_STANDARD : eEK = SdrEdgeKind::OrthoLines; break; + case drawing::ConnectorType_CURVE : eEK = SdrEdgeKind::Bezier; break; + case drawing::ConnectorType_LINE : eEK = SdrEdgeKind::OneLine; break; + case drawing::ConnectorType_LINES : eEK = SdrEdgeKind::ThreeLines; break; + default: + OSL_FAIL( "SdrEdgeKindItem::PuValue : unknown enum" ); + } + SetValue( eEK ); + + return true; +} + +bool SdrEdgeNode1HorzDistItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrEdgeNode1HorzDistItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + if(!(rVal >>= nValue)) + return false; + + SetValue( nValue ); + return true; +} + +SdrEdgeNode1HorzDistItem* SdrEdgeNode1HorzDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode1HorzDistItem(*this); +} + +bool SdrEdgeNode1VertDistItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrEdgeNode1VertDistItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + if(!(rVal >>= nValue)) + return false; + + SetValue( nValue ); + return true; +} + +SdrEdgeNode1VertDistItem* SdrEdgeNode1VertDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode1VertDistItem(*this); +} + +bool SdrEdgeNode2HorzDistItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrEdgeNode2HorzDistItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + if(!(rVal >>= nValue)) + return false; + + SetValue( nValue ); + return true; +} + +SdrEdgeNode2HorzDistItem* SdrEdgeNode2HorzDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode2HorzDistItem(*this); +} + +bool SdrEdgeNode2VertDistItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrEdgeNode2VertDistItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nValue = 0; + if(!(rVal >>= nValue)) + return false; + + SetValue( nValue ); + return true; +} + +SdrEdgeNode2VertDistItem* SdrEdgeNode2VertDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode2VertDistItem(*this); +} + +SdrEdgeNode1GlueDistItem* SdrEdgeNode1GlueDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode1GlueDistItem(*this); +} + +SdrEdgeNode2GlueDistItem* SdrEdgeNode2GlueDistItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrEdgeNode2GlueDistItem(*this); +} + +SdrMeasureKindItem* SdrMeasureKindItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrMeasureKindItem(*this); } + +sal_uInt16 SdrMeasureKindItem::GetValueCount() const { return 2; } + +OUString SdrMeasureKindItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALMEASURETYPES[] = + { + STR_ItemValMEASURE_STD, + STR_ItemValMEASURE_RADIUS + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALMEASURETYPES) && "wrong pos!"); + return SvxResId(ITEMVALMEASURETYPES[nPos]); +} + +bool SdrMeasureKindItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrMeasureKindItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrMeasureKindItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::MeasureKind eKind; + if(!(rVal >>= eKind)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eKind = static_cast(nEnum); + } + + SetValue( static_cast(eKind) ); + return true; +} + + +SdrMeasureTextHPosItem* SdrMeasureTextHPosItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrMeasureTextHPosItem(*this); } + +sal_uInt16 SdrMeasureTextHPosItem::GetValueCount() const { return 4; } + +const OUString & SdrMeasureTextHPosItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static std::array aMeasureTextHPosItem + { + "automatic", + "left outside", + "inside (centered)", + "right outside" + }; + assert(nPos < aMeasureTextHPosItem.size() && "wrong pos!"); + return aMeasureTextHPosItem[nPos]; +} + +bool SdrMeasureTextHPosItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrMeasureTextHPosItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrMeasureTextHPosItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::MeasureTextHorzPos ePos; + if(!(rVal >>= ePos)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + ePos = static_cast(nEnum); + } + + SetValue(ePos); + return true; +} + +SdrMeasureTextVPosItem* SdrMeasureTextVPosItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrMeasureTextVPosItem(*this); } + +sal_uInt16 SdrMeasureTextVPosItem::GetValueCount() const { return 5; } + +OUString SdrMeasureTextVPosItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALMEASURETEXTTYPES[] = + { + STR_ItemValMEASURE_TEXTVAUTO, + STR_ItemValMEASURE_ABOVE, + STR_ItemValMEASURETEXT_BREAKEDLINE, + STR_ItemValMEASURE_BELOW, + STR_ItemValMEASURETEXT_VERTICALCEN + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALMEASURETEXTTYPES) && "wrong pos!"); + return SvxResId(ITEMVALMEASURETEXTTYPES[nPos]); +} + +bool SdrMeasureTextVPosItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrMeasureTextVPosItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= GetValue(); + return true; +} + +bool SdrMeasureTextVPosItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::MeasureTextVertPos ePos; + if(!(rVal >>= ePos)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + ePos = static_cast(nEnum); + } + + SetValue(ePos); + return true; +} + +SdrMeasureUnitItem* SdrMeasureUnitItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrMeasureUnitItem(*this); } + +sal_uInt16 SdrMeasureUnitItem::GetValueCount() const { return 14; } + +OUString SdrMeasureUnitItem::GetValueTextByPos(sal_uInt16 nPos) +{ + if(static_cast(nPos) == FieldUnit::NONE) + return "default"; + else + return SdrFormatter::GetUnitStr(static_cast(nPos)); +} + +bool SdrMeasureUnitItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrMeasureUnitItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrMeasureUnitItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + sal_Int32 nMeasure = 0; + if(!(rVal >>= nMeasure)) + return false; + + SetValue( static_cast(nMeasure) ); + return true; +} + + +SdrCircKindItem* SdrCircKindItem::Clone(SfxItemPool* /*pPool*/) const { return new SdrCircKindItem(*this); } + +sal_uInt16 SdrCircKindItem::GetValueCount() const { return 4; } + +OUString SdrCircKindItem::GetValueTextByPos(sal_uInt16 nPos) +{ + static TranslateId ITEMVALCIRCTYPES[] = + { + STR_ItemValCIRC_FULL, + STR_ItemValCIRC_SECT, + STR_ItemValCIRC_CUT, + STR_ItemValCIRC_ARC + }; + assert(nPos < SAL_N_ELEMENTS(ITEMVALCIRCTYPES) && "wrong pos!"); + return SvxResId(ITEMVALCIRCTYPES[nPos]); +} + +bool SdrCircKindItem::GetPresentation(SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, OUString& rText, const IntlWrapper&) const +{ + rText=GetValueTextByPos(sal::static_int_cast< sal_uInt16 >(GetValue())); + if (ePres==SfxItemPresentation::Complete) { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + return true; +} + +bool SdrCircKindItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()); + return true; +} + +bool SdrCircKindItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + drawing::CircleKind eKind; + if(!(rVal >>= eKind)) + { + sal_Int32 nEnum = 0; + if(!(rVal >>= nEnum)) + return false; + + eKind = static_cast(nEnum); + } + + SetValue( static_cast(eKind) ); + return true; +} + +SdrSignedPercentItem* SdrSignedPercentItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrSignedPercentItem( Which(), GetValue() ); +} + +bool SdrSignedPercentItem::GetPresentation( + SfxItemPresentation ePres, MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, + OUString& rText, const IntlWrapper&) const +{ + rText = unicode::formatPercent(GetValue(), + Application::GetSettings().GetUILanguageTag()); + + if(ePres == SfxItemPresentation::Complete) + { + rText = SdrItemPool::GetItemName(Which()) + " " + rText; + } + + return true; +} + +SdrGrafRedItem* SdrGrafRedItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafRedItem( *this ); +} + +SdrGrafGreenItem* SdrGrafGreenItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafGreenItem( *this ); +} + +SdrGrafBlueItem* SdrGrafBlueItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafBlueItem( *this ); +} + +SdrGrafLuminanceItem* SdrGrafLuminanceItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafLuminanceItem( *this ); +} + +SdrGrafContrastItem* SdrGrafContrastItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafContrastItem( *this ); +} + +SdrGrafGamma100Item* SdrGrafGamma100Item::Clone( SfxItemPool* /*pPool */) const +{ + return new SdrGrafGamma100Item( *this ); +} + +bool SdrGrafGamma100Item::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const +{ + rVal <<= static_cast(GetValue()) / 100.0; + return true; +} + +bool SdrGrafGamma100Item::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/) +{ + double nGamma = 0; + if(!(rVal >>= nGamma)) + return false; + + SetValue( static_cast(nGamma * 100.0 ) ); + return true; +} + +SdrGrafInvertItem* SdrGrafInvertItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafInvertItem( *this ); +} + +SdrGrafTransparenceItem* SdrGrafTransparenceItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafTransparenceItem( *this ); +} + +SdrGrafModeItem* SdrGrafModeItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrGrafModeItem( *this ); +} + +sal_uInt16 SdrGrafModeItem::GetValueCount() const +{ + return 4; +} + +OUString SdrGrafModeItem::GetValueTextByPos(sal_uInt16 nPos) +{ + OUString aStr; + + switch(nPos) + { + case 1: + { + aStr = "Greys"; + break; + } + case 2: + { + aStr = "Black/White"; + break; + } + case 3: + { + aStr = "Watermark"; + break; + } + default: + { + aStr = "Standard"; + break; + } + } + + return aStr; +} + +bool SdrGrafModeItem::GetPresentation( SfxItemPresentation ePres, + MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/, + OUString& rText, const IntlWrapper&) const +{ + rText = GetValueTextByPos( sal::static_int_cast< sal_uInt16 >( GetValue() ) ); + + if( ePres == SfxItemPresentation::Complete ) + { + rText = SdrItemPool::GetItemName( Which() ) + " " + rText; + } + + return true; +} + +SdrGrafCropItem* SdrGrafCropItem::Clone( SfxItemPool* /*pPool*/) const +{ + return new SdrGrafCropItem( *this ); +} + +SdrTextAniStartInsideItem::~SdrTextAniStartInsideItem() +{ +} + +SdrTextAniStartInsideItem* SdrTextAniStartInsideItem::Clone(SfxItemPool* ) const +{ + return new SdrTextAniStartInsideItem(*this); +} + +SdrTextAniStopInsideItem::~SdrTextAniStopInsideItem() +{ +} + +SdrTextAniStopInsideItem* SdrTextAniStopInsideItem::Clone(SfxItemPool* ) const +{ + return new SdrTextAniStopInsideItem(*this); +} + +SdrCaptionEscIsRelItem::~SdrCaptionEscIsRelItem() +{ +} + +SdrCaptionEscIsRelItem* SdrCaptionEscIsRelItem::Clone(SfxItemPool* ) const +{ + return new SdrCaptionEscIsRelItem(*this); +} + +SdrCaptionEscRelItem::~SdrCaptionEscRelItem() +{ +} + +SdrCaptionEscRelItem* SdrCaptionEscRelItem::Clone(SfxItemPool*) const +{ + return new SdrCaptionEscRelItem(*this); +} + +SdrCaptionFitLineLenItem::~SdrCaptionFitLineLenItem() +{ +} + +SdrCaptionFitLineLenItem* SdrCaptionFitLineLenItem::Clone(SfxItemPool* ) const +{ + return new SdrCaptionFitLineLenItem(*this); +} + +SdrCaptionLineLenItem::~SdrCaptionLineLenItem() +{ +} + +SdrCaptionLineLenItem* SdrCaptionLineLenItem::Clone(SfxItemPool*) const +{ + return new SdrCaptionLineLenItem(*this); +} + +SdrMeasureBelowRefEdgeItem::~SdrMeasureBelowRefEdgeItem() +{ +} + +SdrMeasureBelowRefEdgeItem* SdrMeasureBelowRefEdgeItem::Clone(SfxItemPool* ) const +{ + return new SdrMeasureBelowRefEdgeItem(*this); +} + +SdrMeasureTextIsFixedAngleItem::~SdrMeasureTextIsFixedAngleItem() +{ +} + +SdrMeasureTextIsFixedAngleItem* SdrMeasureTextIsFixedAngleItem::Clone(SfxItemPool* ) const +{ + return new SdrMeasureTextIsFixedAngleItem(*this); +} + +SdrMeasureTextFixedAngleItem::~SdrMeasureTextFixedAngleItem() +{ +} + +SdrMeasureTextFixedAngleItem* SdrMeasureTextFixedAngleItem::Clone(SfxItemPool* ) const +{ + return new SdrMeasureTextFixedAngleItem(*this); +} + +SdrMeasureDecimalPlacesItem::~SdrMeasureDecimalPlacesItem() +{ +} + +SdrMeasureDecimalPlacesItem* SdrMeasureDecimalPlacesItem::Clone(SfxItemPool* ) const +{ + return new SdrMeasureDecimalPlacesItem(*this); +} + +SdrMeasureTextRota90Item::~SdrMeasureTextRota90Item() +{ +} + +SdrMeasureTextRota90Item* SdrMeasureTextRota90Item::Clone(SfxItemPool* ) const +{ + return new SdrMeasureTextRota90Item(*this); +} + +SdrMeasureTextUpsideDownItem::~SdrMeasureTextUpsideDownItem() +{ +} + +SdrMeasureTextUpsideDownItem* SdrMeasureTextUpsideDownItem::Clone(SfxItemPool* ) const +{ + return new SdrMeasureTextUpsideDownItem(*this); +} + +SdrLayerIdItem* SdrLayerIdItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrLayerIdItem(*this); +} + +SdrLayerNameItem* SdrLayerNameItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SdrLayerNameItem(*this); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdcrtv.cxx b/svx/source/svdraw/svdcrtv.cxx new file mode 100644 index 0000000000..7bff18563b --- /dev/null +++ b/svx/source/svdraw/svdcrtv.cxx @@ -0,0 +1,904 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +class ImplConnectMarkerOverlay +{ + // The OverlayObjects + sdr::overlay::OverlayObjectList maObjects; + + // The remembered target object + const SdrObject& mrObject; + +public: + ImplConnectMarkerOverlay(const SdrCreateView& rView, SdrObject const & rObject); + + // 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. + + const SdrObject& GetTargetObject() const { return mrObject; } +}; + +ImplConnectMarkerOverlay::ImplConnectMarkerOverlay(const SdrCreateView& rView, SdrObject const & rObject) +: mrObject(rObject) +{ + basegfx::B2DPolyPolygon aB2DPolyPolygon(rObject.TakeXorPoly()); + + 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()) + { + float fScalingFactor = xTargetOverlay->getOutputDevice().GetDPIScaleFactor(); + Size aHalfLogicSize(xTargetOverlay->getOutputDevice().PixelToLogic(Size(4 * fScalingFactor, 4 * fScalingFactor))); + + // object + std::unique_ptr pNew(new sdr::overlay::OverlayPolyPolygonStripedAndFilled( + aB2DPolyPolygon)); + xTargetOverlay->add(*pNew); + maObjects.append(std::move(pNew)); + + // gluepoints + for(sal_uInt16 i(0); i < 4; i++) + { + SdrGluePoint aGluePoint(rObject.GetVertexGluePoint(i)); + const Point& rPosition = aGluePoint.GetAbsolutePos(rObject); + + basegfx::B2DPoint aTopLeft(rPosition.X() - aHalfLogicSize.Width(), rPosition.Y() - aHalfLogicSize.Height()); + basegfx::B2DPoint aBottomRight(rPosition.X() + aHalfLogicSize.Width(), rPosition.Y() + aHalfLogicSize.Height()); + + basegfx::B2DPolygon aTempPoly; + aTempPoly.append(aTopLeft); + aTempPoly.append(basegfx::B2DPoint(aBottomRight.getX(), aTopLeft.getY())); + aTempPoly.append(aBottomRight); + aTempPoly.append(basegfx::B2DPoint(aTopLeft.getX(), aBottomRight.getY())); + aTempPoly.setClosed(true); + + basegfx::B2DPolyPolygon aTempPolyPoly; + aTempPolyPoly.append(aTempPoly); + + std::unique_ptr pNew2(new sdr::overlay::OverlayPolyPolygonStripedAndFilled( + std::move(aTempPolyPoly))); + xTargetOverlay->add(*pNew2); + maObjects.append(std::move(pNew2)); + } + } + } +} + +class ImpSdrCreateViewExtraData +{ + // The OverlayObjects for XOR replacement + sdr::overlay::OverlayObjectList maObjects; + +public: + ImpSdrCreateViewExtraData(); + ~ImpSdrCreateViewExtraData(); + + void CreateAndShowOverlay(const SdrCreateView& rView, const SdrObject* pObject, const basegfx::B2DPolyPolygon& rPolyPoly); + void HideOverlay(); +}; + +ImpSdrCreateViewExtraData::ImpSdrCreateViewExtraData() +{ +} + +ImpSdrCreateViewExtraData::~ImpSdrCreateViewExtraData() +{ + HideOverlay(); +} + +void ImpSdrCreateViewExtraData::CreateAndShowOverlay(const SdrCreateView& rView, const SdrObject* pObject, const basegfx::B2DPolyPolygon& rPolyPoly) +{ + for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++) + { + SdrPaintWindow* pCandidate = rView.GetPaintWindow(a); + const rtl::Reference& xOverlayManager = pCandidate->GetOverlayManager(); + + if (xOverlayManager.is()) + { + if(pObject) + { + const sdr::contact::ViewContact& rVC = pObject->GetViewContact(); + drawinglayer::primitive2d::Primitive2DContainer aSequence; + rVC.getViewIndependentPrimitive2DContainer(aSequence); + std::unique_ptr pNew(new sdr::overlay::OverlayPrimitive2DSequenceObject(std::move(aSequence))); + + xOverlayManager->add(*pNew); + maObjects.append(std::move(pNew)); + } + + if(rPolyPoly.count()) + { + std::unique_ptr pNew(new sdr::overlay::OverlayPolyPolygonStripedAndFilled( + rPolyPoly)); + xOverlayManager->add(*pNew); + maObjects.append(std::move(pNew)); + } + } + } +} + +void ImpSdrCreateViewExtraData::HideOverlay() +{ + // the clear() call of the list removes all objects from the + // OverlayManager and deletes them. + maObjects.clear(); +} + + +// CreateView + + +void SdrCreateView::ImpClearConnectMarker() +{ + mpCoMaOverlay.reset(); +} + +SdrCreateView::SdrCreateView(SdrModel& rSdrModel, OutputDevice* pOut) + : SdrDragView(rSdrModel, pOut) + , mpCreatePV(nullptr) + , mpCreateViewExtraData(new ImpSdrCreateViewExtraData()) + , maCurrentCreatePointer(PointerStyle::Cross) + , mnAutoCloseDistPix(5) + , mnFreeHandMinDistPix(10) + , mnCurrentInvent(SdrInventor::Default) + , mnCurrentIdent(SdrObjKind::NONE) + , mb1stPointAsCenter(false) + , mbUseIncompatiblePathCreateInterface(false) +{ +} + +SdrCreateView::~SdrCreateView() +{ + ImpClearConnectMarker(); + mpCreateViewExtraData.reset(); +} + +bool SdrCreateView::IsAction() const +{ + return SdrDragView::IsAction() || mpCurrentCreate!=nullptr; +} + +void SdrCreateView::MovAction(const Point& rPnt) +{ + SdrDragView::MovAction(rPnt); + if (mpCurrentCreate != nullptr) { + MovCreateObj(rPnt); + } +} + +void SdrCreateView::EndAction() +{ + if (mpCurrentCreate != nullptr) EndCreateObj(SdrCreateCmd::ForceEnd); + SdrDragView::EndAction(); +} + +void SdrCreateView::BckAction() +{ + if (mpCurrentCreate != nullptr) BckCreateObj(); + SdrDragView::BckAction(); +} + +void SdrCreateView::BrkAction() +{ + SdrDragView::BrkAction(); + BrkCreateObj(); +} + +void SdrCreateView::TakeActionRect(tools::Rectangle& rRect) const +{ + if (mpCurrentCreate != nullptr) + { + rRect=maDragStat.GetActionRect(); + if (rRect.IsEmpty()) + { + rRect=tools::Rectangle(maDragStat.GetPrev(),maDragStat.GetNow()); + } + } + else + { + SdrDragView::TakeActionRect(rRect); + } +} + +bool SdrCreateView::CheckEdgeMode() +{ + if (mpCurrentCreate != nullptr) + { + // is managed by EdgeObj + if (mnCurrentInvent==SdrInventor::Default && mnCurrentIdent==SdrObjKind::Edge) return false; + } + + if (!IsCreateMode() || mnCurrentInvent!=SdrInventor::Default || mnCurrentIdent!=SdrObjKind::Edge) + { + ImpClearConnectMarker(); + return false; + } + else + { + // sal_True, if MouseMove should check Connect + return !IsAction(); + } +} + +void SdrCreateView::SetConnectMarker(const SdrObjConnection& rCon) +{ + SdrObject* pTargetObject = rCon.m_pSdrObj; + + if(pTargetObject) + { + // if target object changes, throw away overlay object to make room for changes + if(mpCoMaOverlay && pTargetObject != &mpCoMaOverlay->GetTargetObject()) + { + ImpClearConnectMarker(); + } + + if(!mpCoMaOverlay) + { + mpCoMaOverlay.reset(new ImplConnectMarkerOverlay(*this, *pTargetObject)); + } + } + else + { + ImpClearConnectMarker(); + } +} + +void SdrCreateView::HideConnectMarker() +{ + ImpClearConnectMarker(); +} + +bool SdrCreateView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + if(CheckEdgeMode() && pWin) + { + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + // TODO: Change default hit tolerance at IsMarkedHit() some time! + Point aPos(pWin->PixelToLogic(rMEvt.GetPosPixel())); + bool bMarkHit=PickHandle(aPos)!=nullptr || IsMarkedObjHit(aPos); + SdrObjConnection aCon; + if (!bMarkHit) SdrEdgeObj::ImpFindConnector(aPos,*pPV,aCon,nullptr,pWin); + SetConnectMarker(aCon); + } + } + return SdrDragView::MouseMove(rMEvt,pWin); +} + +bool SdrCreateView::IsTextTool() const +{ + return meEditMode==SdrViewEditMode::Create + && mnCurrentInvent==SdrInventor::Default + && (mnCurrentIdent==SdrObjKind::Text + || mnCurrentIdent==SdrObjKind::TitleText + || mnCurrentIdent==SdrObjKind::OutlineText); +} + +bool SdrCreateView::IsEdgeTool() const +{ + return meEditMode==SdrViewEditMode::Create && mnCurrentInvent==SdrInventor::Default && (mnCurrentIdent==SdrObjKind::Edge); +} + +bool SdrCreateView::IsMeasureTool() const +{ + return meEditMode==SdrViewEditMode::Create && mnCurrentInvent==SdrInventor::Default && (mnCurrentIdent==SdrObjKind::Measure); +} + +void SdrCreateView::SetCurrentObj(SdrObjKind nIdent, SdrInventor nInvent) +{ + if (mnCurrentInvent!=nInvent || mnCurrentIdent!=nIdent) + { + mnCurrentInvent=nInvent; + mnCurrentIdent=nIdent; + rtl::Reference pObj = (nIdent == SdrObjKind::NONE) ? nullptr : + SdrObjFactory::MakeNewObject( + GetModel(), + nInvent, + nIdent); + + if(pObj) + { + // Using text tool, mouse cursor is usually I-Beam, + // crosshairs with tiny I-Beam appears only on MouseButtonDown. + if(IsTextTool()) + { + // Here the correct pointer needs to be used + // if the default is set to vertical writing + maCurrentCreatePointer = PointerStyle::Text; + } + else + maCurrentCreatePointer = pObj->GetCreatePointer(); + } + else + { + maCurrentCreatePointer = PointerStyle::Cross; + } + } + + CheckEdgeMode(); + ImpSetGlueVisible3(IsEdgeTool()); +} + +bool SdrCreateView::ImpBegCreateObj(SdrInventor nInvent, SdrObjKind nIdent, const Point& rPnt, OutputDevice* pOut, + sal_Int16 nMinMov, const tools::Rectangle& rLogRect, SdrObject* pPreparedFactoryObject) +{ + bool bRet=false; + UnmarkAllObj(); + BrkAction(); + + ImpClearConnectMarker(); + + mpCreatePV = GetSdrPageView(); + + if (mpCreatePV != nullptr) + { // otherwise no side registered! + OUString aLay(maActualLayer); + + if(nInvent == SdrInventor::Default && nIdent == SdrObjKind::Measure && !maMeasureLayer.isEmpty()) + { + aLay = maMeasureLayer; + } + + SdrLayerID nLayer = mpCreatePV->GetPage()->GetLayerAdmin().GetLayerID(aLay); + if (nLayer==SDRLAYER_NOTFOUND) nLayer = SdrLayerID(0); + if (!mpCreatePV->GetLockedLayers().IsSet(nLayer) && mpCreatePV->GetVisibleLayers().IsSet(nLayer)) + { + if(pPreparedFactoryObject) + { + mpCurrentCreate = pPreparedFactoryObject; + } + else + { + mpCurrentCreate = SdrObjFactory::MakeNewObject( + GetModel(), nInvent, nIdent); + } + + Point aPnt(rPnt); + if (mnCurrentInvent != SdrInventor::Default || (mnCurrentIdent != SdrObjKind::Edge && + mnCurrentIdent != SdrObjKind::FreehandLine && + mnCurrentIdent != SdrObjKind::FreehandFill )) { // no snapping for Edge and Freehand + aPnt=GetSnapPos(aPnt, mpCreatePV); + } + if (mpCurrentCreate!=nullptr) + { + if (mpDefaultStyleSheet!=nullptr) mpCurrentCreate->NbcSetStyleSheet(mpDefaultStyleSheet, false); + + // SW uses a naked SdrObject for frame construction. Normally, such an + // object should not be created. Since it is possible to use it as a helper + // object (e.g. in letting the user define an area with the interactive + // construction) at least no items should be set at that object. + if(nInvent != SdrInventor::Default || nIdent != SdrObjKind::NewFrame) + { + mpCurrentCreate->SetMergedItemSet(maDefaultAttr); + } + + if (dynamic_cast(mpCurrentCreate.get()) != nullptr) + { + SfxItemSet aSet(GetModel().GetItemPool()); + aSet.Put(XFillColorItem(OUString(),COL_WHITE)); // in case someone turns on Solid + aSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + + mpCurrentCreate->SetMergedItemSet(aSet); + } + if (nInvent == SdrInventor::Default && (nIdent==SdrObjKind::Text || nIdent==SdrObjKind::TitleText || nIdent==SdrObjKind::OutlineText)) + { + // default for all text frames: no background, no border + SfxItemSet aSet(GetModel().GetItemPool()); + aSet.Put(XFillColorItem(OUString(),COL_WHITE)); // in case someone turns on Solid + aSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + aSet.Put(XLineColorItem(OUString(),COL_BLACK)); // in case someone turns on Solid + aSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + + mpCurrentCreate->SetMergedItemSet(aSet); + } + if (!rLogRect.IsEmpty()) mpCurrentCreate->NbcSetLogicRect(rLogRect); + + // make sure drag start point is inside WorkArea + const tools::Rectangle& rWorkArea = GetWorkArea(); + + if(!rWorkArea.IsEmpty()) + { + if(aPnt.X() < rWorkArea.Left()) + { + aPnt.setX( rWorkArea.Left() ); + } + + if(aPnt.X() > rWorkArea.Right()) + { + aPnt.setX( rWorkArea.Right() ); + } + + if(aPnt.Y() < rWorkArea.Top()) + { + aPnt.setY( rWorkArea.Top() ); + } + + if(aPnt.Y() > rWorkArea.Bottom()) + { + aPnt.setY( rWorkArea.Bottom() ); + } + } + + maDragStat.Reset(aPnt); + maDragStat.SetView(static_cast(this)); + maDragStat.SetPageView(mpCreatePV); + maDragStat.SetMinMove(ImpGetMinMovLogic(nMinMov,pOut)); + mpDragWin=pOut; + if (mpCurrentCreate->BegCreate(maDragStat)) + { + ShowCreateObj(/*pOut,sal_True*/); + bRet=true; + } + else + { + mpCurrentCreate = nullptr; + mpCreatePV = nullptr; + } + } + } + } + return bRet; +} + +bool SdrCreateView::BegCreateObj(const Point& rPnt, OutputDevice* pOut, short nMinMov) +{ + return ImpBegCreateObj(mnCurrentInvent,mnCurrentIdent,rPnt,pOut,nMinMov,tools::Rectangle(), nullptr); +} + +bool SdrCreateView::BegCreatePreparedObject(const Point& rPnt, sal_Int16 nMinMov, SdrObject* pPreparedFactoryObject) +{ + SdrInventor nInvent(mnCurrentInvent); + SdrObjKind nIdent(mnCurrentIdent); + + if(pPreparedFactoryObject) + { + nInvent = pPreparedFactoryObject->GetObjInventor(); + nIdent = pPreparedFactoryObject->GetObjIdentifier(); + } + + return ImpBegCreateObj(nInvent, nIdent, rPnt, nullptr, nMinMov, tools::Rectangle(), pPreparedFactoryObject); +} + +bool SdrCreateView::BegCreateCaptionObj(const Point& rPnt, const Size& rObjSiz, + OutputDevice* pOut, short nMinMov) +{ + return ImpBegCreateObj(SdrInventor::Default,SdrObjKind::Caption,rPnt,pOut,nMinMov, + tools::Rectangle(rPnt,Size(rObjSiz.Width()+1,rObjSiz.Height()+1)), nullptr); +} + +void SdrCreateView::MovCreateObj(const Point& rPnt) +{ + if (mpCurrentCreate==nullptr) + return; + + Point aPnt(rPnt); + if (!maDragStat.IsNoSnap()) + { + aPnt=GetSnapPos(aPnt, mpCreatePV); + } + if (IsOrtho()) + { + if (maDragStat.IsOrtho8Possible()) OrthoDistance8(maDragStat.GetPrev(),aPnt,IsBigOrtho()); + else if (maDragStat.IsOrtho4Possible()) OrthoDistance4(maDragStat.GetPrev(),aPnt,IsBigOrtho()); + } + + // If the drag point was limited and Ortho is active, do + // the small ortho correction (reduction) -> last parameter to FALSE. + bool bDidLimit(ImpLimitToWorkArea(aPnt)); + if(bDidLimit && IsOrtho()) + { + if(maDragStat.IsOrtho8Possible()) + OrthoDistance8(maDragStat.GetPrev(), aPnt, false); + else if(maDragStat.IsOrtho4Possible()) + OrthoDistance4(maDragStat.GetPrev(), aPnt, false); + } + + if (aPnt==maDragStat.GetNow()) return; + bool bIsMinMoved(maDragStat.IsMinMoved()); + if (!maDragStat.CheckMinMoved(aPnt)) + return; + + if (!bIsMinMoved) maDragStat.NextPoint(); + maDragStat.NextMove(aPnt); + mpCurrentCreate->MovCreate(maDragStat); + + // MovCreate changes the object, so use ActionChanged() on it + mpCurrentCreate->ActionChanged(); + + // replace for DrawCreateObjDiff + HideCreateObj(); + ShowCreateObj(); +} + +void SdrCreateView::SetupObjLayer(const SdrPageView* pPageView, const OUString& aActiveLayer, SdrObject* pObj) +{ + const SdrLayerAdmin& rAd = pPageView->GetPage()->GetLayerAdmin(); + SdrLayerID nLayer(0); + + // #i72535# + if(dynamic_cast( pObj) != nullptr) + { + // for FormControls, force to form layer + nLayer = rAd.GetLayerID(rAd.GetControlLayerName()); + } + else + { + nLayer = rAd.GetLayerID(aActiveLayer); + } + + if(SDRLAYER_NOTFOUND == nLayer) + { + nLayer = SdrLayerID(0); + } + + pObj->SetLayer(nLayer); +} + +bool SdrCreateView::EndCreateObj(SdrCreateCmd eCmd) +{ + bool bRet=false; + SdrObject* pObjCreated=mpCurrentCreate.get(); + + if (mpCurrentCreate!=nullptr) + { + sal_uInt32 nCount=maDragStat.GetPointCount(); + + if (nCount<=1 && eCmd==SdrCreateCmd::ForceEnd) + { + BrkCreateObj(); // objects with only a single point don't exist (at least today) + return false; // sal_False = event not interpreted + } + + bool bPntsEq=nCount>1; + sal_uInt32 i=1; + Point aP0=maDragStat.GetPoint(0); + while (bPntsEq && iEndCreate(maDragStat,eCmd)) + { + HideCreateObj(); + + if (!bPntsEq) + { + // otherwise Brk, because all points are equal + rtl::Reference pObj = std::move(mpCurrentCreate); + + SetupObjLayer(mpCreatePV, maActualLayer, pObj.get()); + + // recognize creation of a new 3D object inside a 3D scene + bool bSceneIntoScene(false); + + E3dScene* pObjScene = DynCastE3dScene(pObjCreated); + E3dScene* pCurrentScene = pObjScene ? DynCastE3dScene(mpCreatePV->GetCurrentGroup()) : nullptr; + if (pCurrentScene) + { + bool bDidInsert = static_cast(this)->ImpCloneAll3DObjectsToDestScene( + pObjScene, pCurrentScene, Point(0, 0)); + + if(bDidInsert) + { + pObjCreated = nullptr; + bSceneIntoScene = true; + } + } + + if(!bSceneIntoScene) + { + // Here an interactively created SdrObject gets added, so + // take into account that interaction created an object in + // model coordinates. If we have e.g. a GirdOffset, this is a + // little bit tricky - we have an object in model coordinates, + // so the fetched offset is at the wrong point in principle + // since we need to 'substract' the offset here to get to + // 'real' model coordinates. But we have nothing better here, + // so go for it. + // The 2nd a little tricky thing is that this will early-create + // a ViewObjectContact for the new SdrObject, but these VOCs + // are anyways layouted for being create-on-demand. This will + // be adapted/replaced correctly later on. + // This *should* be the right place for getting all interactively + // created objects, see InsertObjectAtView below that calls + // CreateUndoNewObject. + basegfx::B2DVector aGridOffset(0.0, 0.0); + if(getPossibleGridOffsetForSdrObject(aGridOffset, pObj.get(), mpCreatePV)) + { + const Size aOffset( + basegfx::fround(-aGridOffset.getX()), + basegfx::fround(-aGridOffset.getY())); + + pObj->NbcMove(aOffset); + } + + // do the same as before + InsertObjectAtView(pObj.get(), *mpCreatePV); + } + + mpCreatePV = nullptr; + bRet=true; // sal_True = event interpreted + } + else + { + BrkCreateObj(); + } + } + else + { // more points + if (eCmd==SdrCreateCmd::ForceEnd || // nothing there -- force ending + nCount==0 || // no existing points (should never happen) + (nCount<=1 && !maDragStat.IsMinMoved())) { // MinMove not met + BrkCreateObj(); + } + else + { + // replace for DrawCreateObjDiff + HideCreateObj(); + ShowCreateObj(); + maDragStat.ResetMinMoved(); // NextPoint is at MovCreateObj() + bRet=true; + } + } + } + return bRet; +} + +void SdrCreateView::BckCreateObj() +{ + if (mpCurrentCreate==nullptr) + return; + + if (maDragStat.GetPointCount()<=2 ) + { + BrkCreateObj(); + } + else + { + HideCreateObj(); + maDragStat.PrevPoint(); + if (mpCurrentCreate->BckCreate(maDragStat)) + { + ShowCreateObj(); + } + else + { + BrkCreateObj(); + } + } +} + +void SdrCreateView::BrkCreateObj() +{ + if (mpCurrentCreate!=nullptr) + { + HideCreateObj(); + mpCurrentCreate->BrkCreate(maDragStat); + mpCurrentCreate = nullptr; + mpCreatePV = nullptr; + } +} + +void SdrCreateView::ShowCreateObj(/*OutputDevice* pOut, sal_Bool bFull*/) +{ + if(!IsCreateObj() || maDragStat.IsShown()) + return; + + if (mpCurrentCreate) + { + // for migration from XOR, replace DrawDragObj here to create + // overlay objects instead. + bool bUseSolidDragging(IsSolidDragging()); + + // #i101648# check if dragged object is a SdrObjKind::NewFrame. + // This is e.g. used in SW Frame construction as placeholder. + // Do not use SolidDragging for SdrObjKind::NewFrame kind of objects, + // they cannot have a valid optical representation. + if (bUseSolidDragging && SdrObjKind::NewFrame == mpCurrentCreate->GetObjIdentifier()) + { + bUseSolidDragging = false; + } + + // check for objects with no fill and no line + if(bUseSolidDragging) + { + const SfxItemSet& rSet = mpCurrentCreate->GetMergedItemSet(); + const drawing::FillStyle eFill(rSet.Get(XATTR_FILLSTYLE).GetValue()); + const drawing::LineStyle eLine(rSet.Get(XATTR_LINESTYLE).GetValue()); + + if(drawing::LineStyle_NONE == eLine && drawing::FillStyle_NONE == eFill) + { + bUseSolidDragging = false; + } + } + + // check for form controls + if(bUseSolidDragging) + { + if (dynamic_cast(mpCurrentCreate.get()) != nullptr) + { + bUseSolidDragging = false; + } + } + + // #i101781# force to non-solid dragging when not creating a full circle + if(bUseSolidDragging) + { + SdrCircObj* pCircObj = dynamic_cast(mpCurrentCreate.get()); + + if(pCircObj && SdrObjKind::CircleOrEllipse != pCircObj->GetObjIdentifier()) + { + // #i103058# Allow SolidDragging with four points + if(maDragStat.GetPointCount() < 4) + { + bUseSolidDragging = false; + } + } + } + + if(bUseSolidDragging) + { + basegfx::B2DPolyPolygon aDragPolyPolygon; + + if (dynamic_cast(mpCurrentCreate.get()) != nullptr) + { + // ensure object has some size, necessary for SdrTextObj because + // there are still untested divisions by that sizes + tools::Rectangle aCurrentSnapRect(mpCurrentCreate->GetSnapRect()); + + if(aCurrentSnapRect.GetWidth() <= 1 || aCurrentSnapRect.GetHeight() <= 1) + { + tools::Rectangle aNewRect(maDragStat.GetStart(), maDragStat.GetStart() + Point(2, 2)); + mpCurrentCreate->NbcSetSnapRect(aNewRect); + } + } + + if (auto pPathObj = dynamic_cast(mpCurrentCreate.get())) + { + // The up-to-now created path needs to be set at the object to have something + // that can be visualized + const basegfx::B2DPolyPolygon aCurrentPolyPolygon(pPathObj->getObjectPolyPolygon(maDragStat)); + + if(aCurrentPolyPolygon.count()) + { + pPathObj->NbcSetPathPoly(aCurrentPolyPolygon); + } + + aDragPolyPolygon = pPathObj->getDragPolyPolygon(maDragStat); + } + + // use the SdrObject directly for overlay + mpCreateViewExtraData->CreateAndShowOverlay(*this, mpCurrentCreate.get(), aDragPolyPolygon); + } + else + { + const ::basegfx::B2DPolyPolygon aPoly(mpCurrentCreate->TakeCreatePoly(maDragStat)); + + mpCreateViewExtraData->CreateAndShowOverlay(*this, nullptr, aPoly); + } + + // #i101679# Force changed overlay to be shown + for(sal_uInt32 a(0); a < PaintWindowCount(); a++) + { + SdrPaintWindow* pCandidate = GetPaintWindow(a); + const rtl::Reference& xOverlayManager = pCandidate->GetOverlayManager(); + + if (xOverlayManager.is()) + { + xOverlayManager->flush(); + } + } + } + + maDragStat.SetShown(true); +} + +void SdrCreateView::HideCreateObj() +{ + if(IsCreateObj() && maDragStat.IsShown()) + { + // for migration from XOR, replace DrawDragObj here to create + // overlay objects instead. + mpCreateViewExtraData->HideOverlay(); + + //DrawCreateObj(pOut,bFull); + maDragStat.SetShown(false); + } +} + + +void SdrCreateView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const +{ + if (mpCurrentCreate) + { + rTargetSet.Put(mpCurrentCreate->GetMergedItemSet()); + } + else + { + SdrDragView::GetAttributes(rTargetSet, bOnlyHardAttr); + } +} + +bool SdrCreateView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll) +{ + if (mpCurrentCreate) + { + mpCurrentCreate->SetMergedItemSetAndBroadcast(rSet, bReplaceAll); + + return true; + } + else + { + return SdrDragView::SetAttributes(rSet,bReplaceAll); + } +} + +SfxStyleSheet* SdrCreateView::GetStyleSheet() const +{ + if (mpCurrentCreate != nullptr) + { + return mpCurrentCreate->GetStyleSheet(); + } + else + { + return SdrDragView::GetStyleSheet(); + } +} + +void SdrCreateView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + if (mpCurrentCreate != nullptr) + { + mpCurrentCreate->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); + } + else + { + SdrDragView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svddrag.cxx b/svx/source/svdraw/svddrag.cxx new file mode 100644 index 0000000000..0c785dc674 --- /dev/null +++ b/svx/source/svdraw/svddrag.cxx @@ -0,0 +1,129 @@ +/* -*- 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 +#include + +SdrDragStatUserData::~SdrDragStatUserData() = default; + +SdrDragStat::~SdrDragStat() +{ +} + +void SdrDragStat::Clear() +{ + mpUserData.reset(); + mvPnts.clear(); + mvPnts.emplace_back(); +} + +void SdrDragStat::Reset() +{ + pView=nullptr; + pPageView=nullptr; + bShown=false; + nMinMov=1; + bMinMoved=false; + bHorFixed=false; + bVerFixed=false; + bWantNoSnap=false; + pHdl=nullptr; + bOrtho4=false; + bOrtho8=false; + pDragMethod=nullptr; + bEndDragChangesAttributes=false; + bEndDragChangesGeoAndAttributes=false; + mbEndDragChangesLayout=false; + bMouseIsUp=false; + Clear(); + aActionRect=tools::Rectangle(); +} + +void SdrDragStat::Reset(const Point& rPnt) +{ + Reset(); + mvPnts[0]=rPnt; + aPos0=rPnt; + aRealNow=rPnt; +} + +void SdrDragStat::NextMove(const Point& rPnt) +{ + aPos0=mvPnts.back(); + aRealNow=rPnt; + mvPnts.back()=rPnt; +} + +void SdrDragStat::NextPoint() +{ + mvPnts.emplace_back(aRealNow); +} + +void SdrDragStat::PrevPoint() +{ + if (mvPnts.size()>1) { // one has to remain at all times + mvPnts.erase(mvPnts.begin()+mvPnts.size()-2); + mvPnts.back() = aRealNow; + } +} + +bool SdrDragStat::CheckMinMoved(const Point& rPnt) +{ + if (!bMinMoved) { + tools::Long dx=rPnt.X()-GetPrev().X(); if (dx<0) dx=-dx; + tools::Long dy=rPnt.Y()-GetPrev().Y(); if (dy<0) dy=-dy; + if (dx>=tools::Long(nMinMov) || dy>=tools::Long(nMinMov)) + bMinMoved=true; + } + return bMinMoved; +} + +Fraction SdrDragStat::GetXFact() const +{ + tools::Long nMul=mvPnts.back().X()-aRef1.X(); + tools::Long nDiv=GetPrev().X()-aRef1.X(); + if (nDiv==0) nDiv=1; + if (bHorFixed) { nMul=1; nDiv=1; } + return Fraction(nMul,nDiv); +} + +Fraction SdrDragStat::GetYFact() const +{ + tools::Long nMul=mvPnts.back().Y()-aRef1.Y(); + tools::Long nDiv=GetPrev().Y()-aRef1.Y(); + if (nDiv==0) nDiv=1; + if (bVerFixed) { nMul=1; nDiv=1; } + return Fraction(nMul,nDiv); +} + +void SdrDragStat::TakeCreateRect(tools::Rectangle& rRect) const +{ + rRect=tools::Rectangle(mvPnts[0], mvPnts.back()); + if (mvPnts.size()>1) { + Point aBtmRgt(mvPnts[1]); + rRect.SetRight(aBtmRgt.X() ); + rRect.SetBottom(aBtmRgt.Y() ); + } + if (pView!=nullptr && pView->IsCreate1stPointAsCenter()) { + rRect.AdjustTop(rRect.Top()-rRect.Bottom() ); + rRect.AdjustLeft(rRect.Left()-rRect.Right() ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svddrgm1.hxx b/svx/source/svdraw/svddrgm1.hxx new file mode 100644 index 0000000000..54214b9563 --- /dev/null +++ b/svx/source/svdraw/svddrgm1.hxx @@ -0,0 +1,232 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_SVDRAW_SVDDRGM1_HXX +#define INCLUDED_SVX_SOURCE_SVDRAW_SVDDRGM1_HXX + +#include +#include +#include +#include + +class SdrDragView; + +class SdrDragMovHdl : public SdrDragMethod +{ +protected: + // define nothing, override to do so + virtual void createSdrDragEntries() override; + +public: + explicit SdrDragMovHdl(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual void CancelSdrDrag() override; + virtual PointerStyle GetSdrDragPointer() const override; +}; + +class SdrDragRotate : public SdrDragMethod +{ +private: + double nSin; + double nCos; + Degree100 nAngle0; + Degree100 nAngle; + bool bRight; + +public: + explicit SdrDragRotate(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + + virtual basegfx::B2DHomMatrix getCurrentTransformation() const override; + virtual void applyCurrentTransformationToSdrObject(SdrObject& rTarget) override; +}; + +class SdrDragShear : public SdrDragMethod +{ +private: + Fraction aFact; + Degree100 nAngle0; + Degree100 nAngle; + double nTan; + bool bVertical; // contort vertically + bool bResize; // shear and resize + bool bUpSideDown; // mirror and shear/slant + bool bSlant; + +public: + SdrDragShear(SdrDragView& rNewView,bool bSlant1); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + + virtual basegfx::B2DHomMatrix getCurrentTransformation() const override; + virtual void applyCurrentTransformationToSdrObject(SdrObject& rTarget) override; +}; + +class SdrDragMirror : public SdrDragMethod +{ +private: + Point aDif; + Degree100 nAngle; + bool bMirrored; + bool bSide0; + + bool ImpCheckSide(const Point& rPnt) const; + +public: + explicit SdrDragMirror(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + + virtual basegfx::B2DHomMatrix getCurrentTransformation() const override; + virtual void applyCurrentTransformationToSdrObject(SdrObject& rTarget) override; +}; + +class SdrDragGradient : public SdrDragMethod +{ +private: + // Handles to work on + SdrHdlGradient* pIAOHandle; + + // is this for gradient (or for transparency)? + bool bIsGradient : 1; + +public: + SdrDragGradient(SdrDragView& rNewView, bool bGrad = true); + + bool IsGradient() const { return bIsGradient; } + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + virtual void CancelSdrDrag() override; +}; + +class SdrDragCrook : public SdrDragMethod +{ +private: + tools::Rectangle aMarkRect; + Point aMarkCenter; + Point aCenter; + Point aStart; + Fraction aFact; + Point aRad; + bool bContortionAllowed; + bool bNoContortionAllowed; + bool bContortion; + bool bResizeAllowed; + bool bResize; + bool bRotateAllowed; + bool bRotate; + bool bVertical; + bool bValid; + bool bLft; + bool bRgt; + bool bUpr; + bool bLwr; + bool bAtCenter; + Degree100 nAngle; + tools::Long nMarkSize; + SdrCrookMode eMode; + + // helpers for applyCurrentTransformationToPolyPolygon + void MovAllPoints(basegfx::B2DPolyPolygon& rTarget); + void MovCrookPoint(Point& rPnt, Point* pC1, Point* pC2); + +protected: + // needs to add drag geometry to the default + virtual void createSdrDragEntries() override; + +public: + explicit SdrDragCrook(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + + virtual void applyCurrentTransformationToSdrObject(SdrObject& rTarget) override; + virtual void applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget) override; +}; + +class SdrDragDistort : public SdrDragMethod +{ +private: + tools::Rectangle aMarkRect; + XPolygon aDistortedRect; + sal_uInt16 nPolyPt; + bool bContortionAllowed; + bool bNoContortionAllowed; + bool bContortion; + + // helper for applyCurrentTransformationToPolyPolygon + void MovAllPoints(basegfx::B2DPolyPolygon& rTarget); + +protected: + // needs to add drag geometry to the default + virtual void createSdrDragEntries() override; + +public: + explicit SdrDragDistort(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual void MoveSdrDrag(const Point& rPnt) override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; + + virtual void applyCurrentTransformationToSdrObject(SdrObject& rTarget) override; + virtual void applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget) override; +}; + +// derive from SdrDragObjOwn to have handles aligned to object when it +// is sheared or rotated +class SdrDragCrop : public SdrDragObjOwn +{ +public: + explicit SdrDragCrop(SdrDragView& rNewView); + + virtual OUString GetSdrDragComment() const override; + virtual bool BeginSdrDrag() override; + virtual bool EndSdrDrag(bool bCopy) override; + virtual PointerStyle GetSdrDragPointer() const override; +}; + +#endif // INCLUDED_SVX_SOURCE_SVDRAW_SVDDRGM1_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svddrgmt.cxx b/svx/source/svdraw/svddrgmt.cxx new file mode 100644 index 0000000000..166b174c89 --- /dev/null +++ b/svx/source/svdraw/svddrgmt.cxx @@ -0,0 +1,3861 @@ +/* -*- 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 "svddrgm1.hxx" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +SdrDragEntry::SdrDragEntry() +: mbAddToTransparent(false) +{ +} + +SdrDragEntry::~SdrDragEntry() +{ +} + + +SdrDragEntryPolyPolygon::SdrDragEntryPolyPolygon(basegfx::B2DPolyPolygon aOriginalPolyPolygon) +: maOriginalPolyPolygon(std::move(aOriginalPolyPolygon)) +{ +} + +SdrDragEntryPolyPolygon::~SdrDragEntryPolyPolygon() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer SdrDragEntryPolyPolygon::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod) +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(maOriginalPolyPolygon.count()) + { + basegfx::B2DPolyPolygon aCopy(maOriginalPolyPolygon); + + rDragMethod.applyCurrentTransformationToPolyPolygon(aCopy); + basegfx::BColor aColA(SvtOptionsDrawinglayer::GetStripeColorA().getBColor()); + basegfx::BColor aColB(SvtOptionsDrawinglayer::GetStripeColorB().getBColor()); + const double fStripeLength(SvtOptionsDrawinglayer::GetStripeLength()); + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + aColA = aColB = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor(); + aColB.invert(); + } + + aRetval.resize(2); + aRetval[0] = new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D( + aCopy, + aColA, + aColB, + fStripeLength); + + const basegfx::BColor aHilightColor(SvtOptionsDrawinglayer::getHilightColor().getBColor()); + const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01); + + aRetval[1] = new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D( + std::move(aCopy), + aHilightColor, + fTransparence, + 3.0, + false); + } + + return aRetval; +} + + +SdrDragEntrySdrObject::SdrDragEntrySdrObject( + const SdrObject& rOriginal, + bool bModify) +: maOriginal(rOriginal), + mbModify(bModify) +{ + // add SdrObject parts to transparent overlay stuff + setAddToTransparent(true); +} + +SdrDragEntrySdrObject::~SdrDragEntrySdrObject() +{ +} + +void SdrDragEntrySdrObject::prepareCurrentState(SdrDragMethod& rDragMethod) +{ + // for the moment, i need to re-create the clone in all cases. I need to figure + // out when clone and original have the same class, so that i can use operator= + // in those cases + + mxClone.clear(); + + if(mbModify) + { + mxClone = maOriginal.getFullDragClone(); + + // apply original transformation, implemented at the DragMethods + rDragMethod.applyCurrentTransformationToSdrObject(*mxClone); + } +} + +drawinglayer::primitive2d::Primitive2DContainer SdrDragEntrySdrObject::createPrimitive2DSequenceInCurrentState(SdrDragMethod&) +{ + const SdrObject* pSource = &maOriginal; + + if(mbModify && mxClone) + { + // choose source for geometry data + pSource = mxClone.get(); + } + + // use the view-independent primitive representation (without + // evtl. GridOffset, that may be applied to the DragEntry individually) + drawinglayer::primitive2d::Primitive2DContainer xRetval; + pSource->GetViewContact().getViewIndependentPrimitive2DContainer(xRetval); + return xRetval; +} + + +SdrDragEntryPrimitive2DSequence::SdrDragEntryPrimitive2DSequence( + drawinglayer::primitive2d::Primitive2DContainer&& rSequence) +: maPrimitive2DSequence(std::move(rSequence)) +{ + // add parts to transparent overlay stuff if necessary + setAddToTransparent(true); +} + +SdrDragEntryPrimitive2DSequence::~SdrDragEntryPrimitive2DSequence() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer SdrDragEntryPrimitive2DSequence::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod) +{ + drawinglayer::primitive2d::Primitive2DReference aTransformPrimitive2D( + new drawinglayer::primitive2d::TransformPrimitive2D( + rDragMethod.getCurrentTransformation(), + drawinglayer::primitive2d::Primitive2DContainer(maPrimitive2DSequence))); + + return drawinglayer::primitive2d::Primitive2DContainer { aTransformPrimitive2D }; +} + + +SdrDragEntryPointGlueDrag::SdrDragEntryPointGlueDrag(std::vector< basegfx::B2DPoint >&& rPositions, bool bIsPointDrag) +: maPositions(std::move(rPositions)), + mbIsPointDrag(bIsPointDrag) +{ + // add SdrObject parts to transparent overlay stuff + setAddToTransparent(true); +} + +SdrDragEntryPointGlueDrag::~SdrDragEntryPointGlueDrag() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer SdrDragEntryPointGlueDrag::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod) +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(!maPositions.empty()) + { + basegfx::B2DPolygon aPolygon; + + for(auto const & a: maPositions) + { + aPolygon.append(a); + } + + basegfx::B2DPolyPolygon aPolyPolygon(aPolygon); + + rDragMethod.applyCurrentTransformationToPolyPolygon(aPolyPolygon); + + const basegfx::B2DPolygon aTransformed(aPolyPolygon.getB2DPolygon(0)); + std::vector< basegfx::B2DPoint > aTransformedPositions; + + aTransformedPositions.reserve(aTransformed.count()); + + for(sal_uInt32 a = 0; a < aTransformed.count(); a++) + { + aTransformedPositions.push_back(aTransformed.getB2DPoint(a)); + } + + if(mbIsPointDrag) + { + basegfx::BColor aColor(SvtOptionsDrawinglayer::GetStripeColorA().getBColor()); + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + aColor = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor(); + } + + drawinglayer::primitive2d::Primitive2DReference aMarkerArrayPrimitive2D( + new drawinglayer::primitive2d::MarkerArrayPrimitive2D(std::move(aTransformedPositions), + drawinglayer::primitive2d::createDefaultCross_3x3(aColor))); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aMarkerArrayPrimitive2D }; + } + else + { + drawinglayer::primitive2d::Primitive2DReference aMarkerArrayPrimitive2D( + new drawinglayer::primitive2d::MarkerArrayPrimitive2D(std::move(aTransformedPositions), + SdrHdl::createGluePointBitmap())); + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aMarkerArrayPrimitive2D }; + } + } + + return aRetval; +} + + +void SdrDragMethod::resetSdrDragEntries() +{ + // clear entries; creation is on demand + clearSdrDragEntries(); +} + +basegfx::B2DRange SdrDragMethod::getCurrentRange() const +{ + return maOverlayObjectList.getBaseRange(); +} + +void SdrDragMethod::clearSdrDragEntries() +{ + maSdrDragEntries.clear(); +} + +void SdrDragMethod::addSdrDragEntry(std::unique_ptr pNew) +{ + assert(pNew); + maSdrDragEntries.push_back(std::move(pNew)); +} + +void SdrDragMethod::createSdrDragEntries() +{ + if(!(getSdrDragView().GetSdrPageView() && getSdrDragView().GetSdrPageView()->HasMarkedObjPageView())) + return; + + if(getSdrDragView().IsDraggingPoints()) + { + createSdrDragEntries_PointDrag(); + } + else if(getSdrDragView().IsDraggingGluePoints()) + { + createSdrDragEntries_GlueDrag(); + } + else + { + if(getSolidDraggingActive()) + { + createSdrDragEntries_SolidDrag(); + } + else + { + createSdrDragEntries_PolygonDrag(); + } + } +} + +void SdrDragMethod::createSdrDragEntryForSdrObject(const SdrObject& rOriginal) +{ + // add full object drag; Clone() at the object has to work + // for this + addSdrDragEntry(std::unique_ptr(new SdrDragEntrySdrObject(rOriginal, true/*bModify*/))); +} + +void SdrDragMethod::insertNewlyCreatedOverlayObjectForSdrDragMethod( + std::unique_ptr pOverlayObject, + const sdr::contact::ObjectContact& rObjectContact, + sdr::overlay::OverlayManager& rOverlayManager) +{ + // check if we have an OverlayObject + if(!pOverlayObject) + { + return; + } + + // add to OverlayManager + rOverlayManager.add(*pOverlayObject); + + // Add GridOffset for non-linear ViewToDevice transformation (calc) + if(rObjectContact.supportsGridOffsets()) + { + const basegfx::B2DRange& rNewRange(pOverlayObject->getBaseRange()); + + if(!rNewRange.isEmpty()) + { + basegfx::B2DVector aOffset(0.0, 0.0); + rObjectContact.calculateGridOffsetForB2DRange(aOffset, rNewRange); + + if(!aOffset.equalZero()) + { + pOverlayObject->setOffset(aOffset); + } + } + } + + // add to local OverlayObjectList - ownership change (!) + maOverlayObjectList.append(std::move(pOverlayObject)); +} + +void SdrDragMethod::createSdrDragEntries_SolidDrag() +{ + const size_t nMarkCount(getSdrDragView().GetMarkedObjectCount()); + SdrPageView* pPV = getSdrDragView().GetSdrPageView(); + + if(!pPV) + return; + + for(size_t a = 0; a < nMarkCount; ++a) + { + SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(a); + + if(pM->GetPageView() == pPV) + { + const SdrObject* pObject = pM->GetMarkedSdrObj(); + + if(pObject) + { + if(pPV->PageWindowCount()) + { + SdrObjListIter aIter(*pObject); + + while(aIter.IsMore()) + { + SdrObject* pCandidate = aIter.Next(); + + if(pCandidate) + { + const bool bSuppressFullDrag(!pCandidate->supportsFullDrag()); + bool bAddWireframe(bSuppressFullDrag); + + if(!bAddWireframe && !pCandidate->HasLineStyle()) + { + // add wireframe for objects without outline + bAddWireframe = true; + } + + if(!bSuppressFullDrag) + { + // add full object drag; Clone() at the object has to work + // for this + createSdrDragEntryForSdrObject(*pCandidate); + } + + if(bAddWireframe) + { + // when dragging a 50% transparent copy of a filled or not filled object without + // outline, this is normally hard to see. Add extra wireframe in that case. This + // works nice e.g. with text frames etc. + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPolyPolygon(pCandidate->TakeXorPoly()))); + } + } + } + } + } + } + } +} + +void SdrDragMethod::createSdrDragEntries_PolygonDrag() +{ + const size_t nMarkCount(getSdrDragView().GetMarkedObjectCount()); + bool bNoPolygons(getSdrDragView().IsNoDragXorPolys() || nMarkCount > SdrDragView::GetDragXorPolyLimit()); + basegfx::B2DPolyPolygon aResult; + sal_uInt32 nPointCount(0); + + for(size_t a = 0; !bNoPolygons && a < nMarkCount; ++a) + { + SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(a); + + if(pM->GetPageView() == getSdrDragView().GetSdrPageView()) + { + const basegfx::B2DPolyPolygon aNewPolyPolygon(pM->GetMarkedSdrObj()->TakeXorPoly()); + + for(auto const& rPolygon : aNewPolyPolygon) + { + nPointCount += rPolygon.count(); + } + + if(nPointCount > SdrDragView::GetDragXorPointLimit()) + { + bNoPolygons = true; + } + + if(!bNoPolygons) + { + aResult.append(aNewPolyPolygon); + } + } + } + + if(bNoPolygons) + { + const tools::Rectangle aR(getSdrDragView().GetSdrPageView()->MarkSnap()); + const basegfx::B2DRange aNewRectangle = vcl::unotools::b2DRectangleFromRectangle(aR); + basegfx::B2DPolygon aNewPolygon(basegfx::utils::createPolygonFromRect(aNewRectangle)); + + aResult = basegfx::B2DPolyPolygon(basegfx::utils::expandToCurve(aNewPolygon)); + } + + if(aResult.count()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPolyPolygon(std::move(aResult)))); + } +} + +void SdrDragMethod::createSdrDragEntries_PointDrag() +{ + const size_t nMarkCount(getSdrDragView().GetMarkedObjectCount()); + std::vector< basegfx::B2DPoint > aPositions; + + for(size_t nm = 0; nm < nMarkCount; ++nm) + { + SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(nm); + + if(pM->GetPageView() == getSdrDragView().GetSdrPageView()) + { + const SdrUShortCont& rPts = pM->GetMarkedPoints(); + + if (!rPts.empty()) + { + const SdrObject* pObj = pM->GetMarkedSdrObj(); + const SdrPathObj* pPath = dynamic_cast< const SdrPathObj* >(pObj); + + if(pPath) + { + const basegfx::B2DPolyPolygon& aPathXPP = pPath->GetPathPoly(); + + if(aPathXPP.count()) + { + for(const sal_uInt16 nObjPt : rPts) + { + sal_uInt32 nPolyNum, nPointNum; + + if(sdr::PolyPolygonEditor::GetRelativePolyPoint(aPathXPP, nObjPt, nPolyNum, nPointNum)) + { + aPositions.push_back(aPathXPP.getB2DPolygon(nPolyNum).getB2DPoint(nPointNum)); + } + } + } + } + } + } + } + + if(!aPositions.empty()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPointGlueDrag(std::move(aPositions), true))); + } +} + +void SdrDragMethod::createSdrDragEntries_GlueDrag() +{ + const size_t nMarkCount(getSdrDragView().GetMarkedObjectCount()); + std::vector< basegfx::B2DPoint > aPositions; + + for(size_t nm = 0; nm < nMarkCount; ++nm) + { + SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(nm); + + if(pM->GetPageView() == getSdrDragView().GetSdrPageView()) + { + const SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + + if (!rPts.empty()) + { + const SdrObject* pObj = pM->GetMarkedSdrObj(); + const SdrGluePointList* pGPL = pObj->GetGluePointList(); + + if (pGPL) + { + for(const sal_uInt16 nObjPt : rPts) + { + const sal_uInt16 nGlueNum(pGPL->FindGluePoint(nObjPt)); + + if(SDRGLUEPOINT_NOTFOUND != nGlueNum) + { + const Point aPoint((*pGPL)[nGlueNum].GetAbsolutePos(*pObj)); + aPositions.emplace_back(aPoint.X(), aPoint.Y()); + } + } + } + } + } + } + + if(!aPositions.empty()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPointGlueDrag(std::move(aPositions), false))); + } +} + +OUString SdrDragMethod::ImpGetDescriptionStr(TranslateId pStrCacheID) const +{ + ImpGetDescriptionOptions nOpt=ImpGetDescriptionOptions::NONE; + if (IsDraggingPoints()) { + nOpt=ImpGetDescriptionOptions::POINTS; + } else if (IsDraggingGluePoints()) { + nOpt=ImpGetDescriptionOptions::GLUEPOINTS; + } + return getSdrDragView().ImpGetDescriptionString(pStrCacheID, nOpt); +} + +SdrObject* SdrDragMethod::GetDragObj() const +{ + SdrObject* pObj=nullptr; + if (getSdrDragView().mpDragHdl!=nullptr) pObj=getSdrDragView().mpDragHdl->GetObj(); + if (pObj==nullptr) pObj=getSdrDragView().mpMarkedObj; + return pObj; +} + +SdrPageView* SdrDragMethod::GetDragPV() const +{ + SdrPageView* pPV=nullptr; + if (getSdrDragView().mpDragHdl!=nullptr) pPV=getSdrDragView().mpDragHdl->GetPageView(); + if (pPV==nullptr) pPV=getSdrDragView().mpMarkedPV; + return pPV; +} + +void SdrDragMethod::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + // the original applies the transformation using TRGetBaseGeometry/TRSetBaseGeometry. + // Later this should be the only needed one for linear transforms (not for SdrDragCrook and + // SdrDragDistort, those are NOT linear). Currently, this can not yet be used since the + // special handling of rotate/mirror due to the not-being-able to handle it in the old + // drawinglayer stuff. Text would currently not correctly be mirrored in the preview. + basegfx::B2DHomMatrix aObjectTransform; + basegfx::B2DPolyPolygon aObjectPolyPolygon; + bool bPolyUsed(rTarget.TRGetBaseGeometry(aObjectTransform, aObjectPolyPolygon)); + + // apply transform to object transform + aObjectTransform *= getCurrentTransformation(); + + if(bPolyUsed) + { + // do something special since the object size is in the polygon + // break up matrix to get the scale + const basegfx::utils::B2DHomMatrixBufferedDecompose aTmpDecomp(aObjectTransform); + + // get polygon's position and size + const basegfx::B2DRange aPolyRange(aObjectPolyPolygon.getB2DRange()); + + // get the scaling factors (do not mirror, this is in the object transformation) + const double fScaleX(fabs(aTmpDecomp.getScale().getX()) / (basegfx::fTools::equalZero(aPolyRange.getWidth()) ? 1.0 : aPolyRange.getWidth())); + const double fScaleY(fabs(aTmpDecomp.getScale().getY()) / (basegfx::fTools::equalZero(aPolyRange.getHeight()) ? 1.0 : aPolyRange.getHeight())); + + // prepare transform matrix for polygon + basegfx::B2DHomMatrix aPolyTransform( + basegfx::utils::createTranslateB2DHomMatrix( + -aPolyRange.getMinX(), + -aPolyRange.getMinY())); + aPolyTransform.scale(fScaleX, fScaleY); + + // transform the polygon + aObjectPolyPolygon.transform(aPolyTransform); + } + + rTarget.TRSetBaseGeometry(getCurrentTransformation() * aObjectTransform, aObjectPolyPolygon); +} + +void SdrDragMethod::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget) +{ + // original uses CurrentTransformation + rTarget.transform(getCurrentTransformation()); +} + +SdrDragMethod::SdrDragMethod(SdrDragView& rNewView) +: mrSdrDragView(rNewView), + mbMoveOnly(false), + mbSolidDraggingActive(getSdrDragView().IsSolidDragging()), + mbShiftPressed(false) +{ + if(mbSolidDraggingActive && Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + // fallback to wireframe when high contrast is used + mbSolidDraggingActive = false; + } +} + +SdrDragMethod::~SdrDragMethod() +{ + clearSdrDragEntries(); +} + +void SdrDragMethod::Show() +{ + getSdrDragView().ShowDragObj(); +} + +void SdrDragMethod::Hide() +{ + getSdrDragView().HideDragObj(); +} + +basegfx::B2DHomMatrix SdrDragMethod::getCurrentTransformation() const +{ + return basegfx::B2DHomMatrix(); +} + +void SdrDragMethod::CancelSdrDrag() +{ + Hide(); +} + +typedef std::map< const SdrObject*, SdrObject* > SdrObjectAndCloneMap; + +void SdrDragMethod::CreateOverlayGeometry( + sdr::overlay::OverlayManager& rOverlayManager, + const sdr::contact::ObjectContact& rObjectContact) +{ + // We do client-side object manipulation with the Kit API + if (comphelper::LibreOfficeKit::isActive()) + return; + + // create SdrDragEntries on demand + if(maSdrDragEntries.empty()) + { + createSdrDragEntries(); + } + + // if there are entries, derive OverlayObjects from the entries, including + // modification from current interactive state + if(!maSdrDragEntries.empty()) + { + // #i54102# SdrDragEntrySdrObject creates clones of SdrObjects as base for creating the needed + // primitives, holding the original and the clone. If connectors (Edges) are involved, + // the cloned connectors need to be connected to the cloned SdrObjects (after cloning + // they are connected to the original SdrObjects). To do so, trigger the preparation + // steps for SdrDragEntrySdrObject, save an association of (orig, clone) in a helper + // and evtl. remember if it was an edge + SdrObjectAndCloneMap aOriginalAndClones; + std::vector< SdrEdgeObj* > aEdges; + + // #i54102# execute prepareCurrentState for all SdrDragEntrySdrObject, register pair of original and + // clone, remember edges + for(auto const & a: maSdrDragEntries) + { + SdrDragEntrySdrObject* pSdrDragEntrySdrObject = dynamic_cast< SdrDragEntrySdrObject*>(a.get()); + + if(pSdrDragEntrySdrObject) + { + pSdrDragEntrySdrObject->prepareCurrentState(*this); + + SdrEdgeObj* pSdrEdgeObj = dynamic_cast< SdrEdgeObj* >(pSdrDragEntrySdrObject->getClone()); + + if(pSdrEdgeObj) + { + aEdges.push_back(pSdrEdgeObj); + } + + if(pSdrDragEntrySdrObject->getClone()) + { + aOriginalAndClones[&pSdrDragEntrySdrObject->getOriginal()] = pSdrDragEntrySdrObject->getClone(); + } + } + } + + // #i54102# if there are edges, reconnect their ends to the corresponding clones (if found) + for(SdrEdgeObj* pSdrEdgeObj: aEdges) + { + SdrObject* pConnectedTo = pSdrEdgeObj->GetConnectedNode(true); + + if(pConnectedTo) + { + SdrObjectAndCloneMap::iterator aEntry = aOriginalAndClones.find(pConnectedTo); + + if(aEntry != aOriginalAndClones.end()) + { + pSdrEdgeObj->ConnectToNode(true, aEntry->second); + } + } + + pConnectedTo = pSdrEdgeObj->GetConnectedNode(false); + + if(pConnectedTo) + { + SdrObjectAndCloneMap::iterator aEntry = aOriginalAndClones.find(pConnectedTo); + + if(aEntry != aOriginalAndClones.end()) + { + pSdrEdgeObj->ConnectToNode(false, aEntry->second); + } + } + } + + // collect primitives for visualisation + drawinglayer::primitive2d::Primitive2DContainer aResult; + drawinglayer::primitive2d::Primitive2DContainer aResultTransparent; + + for(auto & pCandidate: maSdrDragEntries) + { + const drawinglayer::primitive2d::Primitive2DContainer aCandidateResult(pCandidate->createPrimitive2DSequenceInCurrentState(*this)); + + if(!aCandidateResult.empty()) + { + if(pCandidate->getAddToTransparent()) + { + aResultTransparent.append(aCandidateResult); + } + else + { + aResult.append(aCandidateResult); + } + } + } + + if(DoAddConnectorOverlays()) + { + const drawinglayer::primitive2d::Primitive2DContainer aConnectorOverlays(AddConnectorOverlays()); + + if(!aConnectorOverlays.empty()) + { + // add connector overlays to transparent part + aResultTransparent.append(aConnectorOverlays); + } + } + + if(!aResult.empty()) + { + std::unique_ptr pNewOverlayObject( + new sdr::overlay::OverlayPrimitive2DSequenceObject( + std::move(aResult))); + + insertNewlyCreatedOverlayObjectForSdrDragMethod( + std::move(pNewOverlayObject), + rObjectContact, + rOverlayManager); + } + + if(!aResultTransparent.empty()) + { + drawinglayer::primitive2d::Primitive2DReference aUnifiedTransparencePrimitive2D(new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(std::move(aResultTransparent), 0.5)); + aResultTransparent = drawinglayer::primitive2d::Primitive2DContainer { aUnifiedTransparencePrimitive2D }; + + std::unique_ptr pNewOverlayObject( + new sdr::overlay::OverlayPrimitive2DSequenceObject( + std::move(aResultTransparent))); + + insertNewlyCreatedOverlayObjectForSdrDragMethod( + std::move(pNewOverlayObject), + rObjectContact, + rOverlayManager); + } + } + + // add DragStripes if necessary (help lines cross the page when dragging) + if(!getSdrDragView().IsDragStripes()) + return; + + tools::Rectangle aActionRectangle; + getSdrDragView().TakeActionRect(aActionRectangle); + + const basegfx::B2DPoint aTopLeft(aActionRectangle.Left(), aActionRectangle.Top()); + const basegfx::B2DPoint aBottomRight(aActionRectangle.Right(), aActionRectangle.Bottom()); + std::unique_ptr pNew( + new sdr::overlay::OverlayRollingRectangleStriped( + aTopLeft, + aBottomRight, + true, + false)); + + insertNewlyCreatedOverlayObjectForSdrDragMethod( + std::move(pNew), + rObjectContact, + rOverlayManager); +} + +void SdrDragMethod::destroyOverlayGeometry() +{ + maOverlayObjectList.clear(); +} + +bool SdrDragMethod::DoAddConnectorOverlays() +{ + // these conditions are translated from SdrDragView::ImpDrawEdgeXor + const SdrMarkList& rMarkedNodes = getSdrDragView().GetEdgesOfMarkedNodes(); + + if(!rMarkedNodes.GetMarkCount()) + { + return false; + } + + if(getSdrDragView().IsDraggingPoints() || getSdrDragView().IsDraggingGluePoints()) + { + return false; + } + + if(!getMoveOnly() && !( + dynamic_cast(this) != nullptr || dynamic_cast(this) != nullptr || + dynamic_cast(this) != nullptr || dynamic_cast(this) != nullptr )) + { + return false; + } + + // one more migrated from SdrEdgeObj::NspToggleEdgeXor + if( dynamic_cast< const SdrDragObjOwn* >(this) != nullptr || dynamic_cast< const SdrDragMovHdl* >(this) != nullptr ) + { + return false; + } + + return true; +} + +drawinglayer::primitive2d::Primitive2DContainer SdrDragMethod::AddConnectorOverlays() +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + const bool bDetail(getMoveOnly()); + const SdrMarkList& rMarkedNodes = getSdrDragView().GetEdgesOfMarkedNodes(); + + for(size_t a = 0; a < rMarkedNodes.GetMarkCount(); ++a) + { + SdrMark* pEM = rMarkedNodes.GetMark(a); + + if(pEM && pEM->GetMarkedSdrObj()) + { + SdrEdgeObj* pEdge = dynamic_cast< SdrEdgeObj* >(pEM->GetMarkedSdrObj()); + + if(pEdge) + { + basegfx::B2DPolygon aEdgePolygon(pEdge->ImplAddConnectorOverlay(*this, pEM->IsCon1(), pEM->IsCon2(), bDetail)); + + if(aEdgePolygon.count()) + { + // this polygon is a temporary calculated connector path, so it is not possible to fetch + // the needed primitives directly from the pEdge object which does not get changed. If full + // drag is on, use the SdrObjects ItemSet to create an adequate representation + bool bUseSolidDragging(getSolidDraggingActive()); + + if(bUseSolidDragging) + { + // switch off solid dragging if connector is not visible + if(!pEdge->HasLineStyle()) + { + bUseSolidDragging = false; + } + } + + if(bUseSolidDragging) + { + const SfxItemSet& rItemSet = pEdge->GetMergedItemSet(); + const drawinglayer::attribute::SdrLineAttribute aLine( + drawinglayer::primitive2d::createNewSdrLineAttribute(rItemSet)); + + if(!aLine.isDefault()) + { + const drawinglayer::attribute::SdrLineStartEndAttribute aLineStartEnd( + drawinglayer::primitive2d::createNewSdrLineStartEndAttribute( + rItemSet, + aLine.getWidth())); + + aRetval.push_back(drawinglayer::primitive2d::createPolygonLinePrimitive( + aEdgePolygon, + aLine, + aLineStartEnd)); + } + } + else + { + basegfx::BColor aColA(SvtOptionsDrawinglayer::GetStripeColorA().getBColor()); + basegfx::BColor aColB(SvtOptionsDrawinglayer::GetStripeColorB().getBColor()); + const double fStripeLength(SvtOptionsDrawinglayer::GetStripeLength()); + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + aColA = aColB = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor(); + aColB.invert(); + } + + drawinglayer::primitive2d::Primitive2DReference aPolyPolygonMarkerPrimitive2D( + new drawinglayer::primitive2d::PolygonMarkerPrimitive2D( + std::move(aEdgePolygon), aColA, aColB, fStripeLength)); + aRetval.push_back(aPolyPolygonMarkerPrimitive2D); + } + } + } + } + } + + return aRetval; +} + + +SdrDragMovHdl::SdrDragMovHdl(SdrDragView& rNewView) +: SdrDragMethod(rNewView) +{ +} + +void SdrDragMovHdl::createSdrDragEntries() +{ + // SdrDragMovHdl does not use the default drags, + // but creates nothing +} + +OUString SdrDragMovHdl::GetSdrDragComment() const +{ + OUString aStr=SvxResId(STR_DragMethMovHdl); + if (getSdrDragView().IsDragWithCopy()) aStr+=SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragMovHdl::BeginSdrDrag() +{ + if( !GetDragHdl() ) + return false; + + DragStat().SetRef1(GetDragHdl()->GetPos()); + DragStat().SetShown(!DragStat().IsShown()); + SdrHdlKind eKind=GetDragHdl()->GetKind(); + SdrHdl* pH1=GetHdlList().GetHdl(SdrHdlKind::Ref1); + SdrHdl* pH2=GetHdlList().GetHdl(SdrHdlKind::Ref2); + + if (eKind==SdrHdlKind::MirrorAxis) + { + if (pH1==nullptr || pH2==nullptr) + { + OSL_FAIL("SdrDragMovHdl::BeginSdrDrag(): Moving the axis of reflection: reference handles not found."); + return false; + } + + DragStat().SetActionRect(tools::Rectangle(pH1->GetPos(),pH2->GetPos())); + } + else + { + Point aPt(GetDragHdl()->GetPos()); + DragStat().SetActionRect(tools::Rectangle(aPt,aPt)); + } + + return true; +} + +void SdrDragMovHdl::MoveSdrDrag(const Point& rNoSnapPnt) +{ + Point aPnt(rNoSnapPnt); + + if ( !(GetDragHdl() && DragStat().CheckMinMoved(rNoSnapPnt))) + return; + + if (GetDragHdl()->GetKind()==SdrHdlKind::MirrorAxis) + { + SdrHdl* pH1=GetHdlList().GetHdl(SdrHdlKind::Ref1); + SdrHdl* pH2=GetHdlList().GetHdl(SdrHdlKind::Ref2); + + if (pH1==nullptr || pH2==nullptr) + return; + + if (!DragStat().IsNoSnap()) + { + tools::Long nBestXSnap=0; + tools::Long nBestYSnap=0; + bool bXSnapped=false; + bool bYSnapped=false; + Point aDif(aPnt-DragStat().GetStart()); + getSdrDragView().CheckSnap(Ref1()+aDif,nBestXSnap,nBestYSnap,bXSnapped,bYSnapped); + getSdrDragView().CheckSnap(Ref2()+aDif,nBestXSnap,nBestYSnap,bXSnapped,bYSnapped); + aPnt.AdjustX(nBestXSnap ); + aPnt.AdjustY(nBestYSnap ); + } + + if (aPnt!=DragStat().GetNow()) + { + Hide(); + DragStat().NextMove(aPnt); + Point aDif(DragStat().GetNow()-DragStat().GetStart()); + pH1->SetPos(Ref1()+aDif); + pH2->SetPos(Ref2()+aDif); + + SdrHdl* pHM = GetHdlList().GetHdl(SdrHdlKind::MirrorAxis); + + if(pHM) + pHM->Touch(); + + Show(); + DragStat().SetActionRect(tools::Rectangle(pH1->GetPos(),pH2->GetPos())); + } + } + else + { + if (!DragStat().IsNoSnap()) SnapPos(aPnt); + Degree100 nSA(0); + + if (getSdrDragView().IsAngleSnapEnabled()) + nSA=getSdrDragView().GetSnapAngle(); + + if (getSdrDragView().IsMirrorAllowed(true,true)) + { // limited + if (!getSdrDragView().IsMirrorAllowed()) nSA=4500_deg100; + if (!getSdrDragView().IsMirrorAllowed(true)) nSA=9000_deg100; + } + + if (getSdrDragView().IsOrtho() && nSA!=9000_deg100) + nSA=4500_deg100; + + if (nSA) + { // angle snapping + SdrHdlKind eRef=SdrHdlKind::Ref1; + + if (GetDragHdl()->GetKind()==SdrHdlKind::Ref1) + eRef=SdrHdlKind::Ref2; + + SdrHdl* pH=GetHdlList().GetHdl(eRef); + + if (pH!=nullptr) + { + Point aRef(pH->GetPos()); + Degree100 nAngle=NormAngle36000(GetAngle(aPnt-aRef)); + Degree100 nNewAngle=nAngle; + nNewAngle+=nSA/2_deg100; + nNewAngle/=nSA; + nNewAngle*=nSA; + nNewAngle=NormAngle36000(nNewAngle); + double a=toRadians(nNewAngle-nAngle); + double nSin=sin(a); + double nCos=cos(a); + RotatePoint(aPnt,aRef,nSin,nCos); + + // eliminate rounding errors for certain values + if (nSA==9000_deg100) + { + if (nNewAngle==0_deg100 || nNewAngle==18000_deg100) aPnt.setY(aRef.Y() ); + if (nNewAngle==9000_deg100 || nNewAngle==27000_deg100) aPnt.setX(aRef.X() ); + } + + if (nSA==4500_deg100) + OrthoDistance8(aRef,aPnt,true); + } + } + + if (aPnt!=DragStat().GetNow()) + { + Hide(); + DragStat().NextMove(aPnt); + GetDragHdl()->SetPos(DragStat().GetNow()); + SdrHdl* pHM = GetHdlList().GetHdl(SdrHdlKind::MirrorAxis); + + if(pHM) + pHM->Touch(); + + Show(); + DragStat().SetActionRect(tools::Rectangle(aPnt,aPnt)); + } + } +} + +bool SdrDragMovHdl::EndSdrDrag(bool /*bCopy*/) +{ + if( GetDragHdl() ) + { + switch (GetDragHdl()->GetKind()) + { + case SdrHdlKind::Ref1: + Ref1()=DragStat().GetNow(); + break; + + case SdrHdlKind::Ref2: + Ref2()=DragStat().GetNow(); + break; + + case SdrHdlKind::MirrorAxis: + Ref1()+=DragStat().GetNow()-DragStat().GetStart(); + Ref2()+=DragStat().GetNow()-DragStat().GetStart(); + break; + + default: break; + } + } + + return true; +} + +void SdrDragMovHdl::CancelSdrDrag() +{ + Hide(); + + SdrHdl* pHdl = GetDragHdl(); + if( pHdl ) + pHdl->SetPos(DragStat().GetRef1()); + + SdrHdl* pHM = GetHdlList().GetHdl(SdrHdlKind::MirrorAxis); + + if(pHM) + pHM->Touch(); +} + +PointerStyle SdrDragMovHdl::GetSdrDragPointer() const +{ + const SdrHdl* pHdl = GetDragHdl(); + + if (pHdl!=nullptr) + { + return pHdl->GetPointer(); + } + + return PointerStyle::RefHand; +} + + +SdrDragObjOwn::SdrDragObjOwn(SdrDragView& rNewView) +: SdrDragMethod(rNewView) +{ + const SdrObject* pObj = GetDragObj(); + + if(pObj) + { + // suppress full drag for some object types + setSolidDraggingActive(pObj->supportsFullDrag()); + } +} + +SdrDragObjOwn::~SdrDragObjOwn() +{ +} + +void SdrDragObjOwn::createSdrDragEntries() +{ + if(!mxClone) + return; + + basegfx::B2DPolyPolygon aDragPolyPolygon; + bool bAddWireframe(true); + + if(getSolidDraggingActive()) + { + SdrPageView* pPV = getSdrDragView().GetSdrPageView(); + + if(pPV && pPV->PageWindowCount()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntrySdrObject(*mxClone, false))); + + // potentially no wireframe needed, full drag works + bAddWireframe = false; + } + } + + if(!bAddWireframe) + { + // check for extra conditions for wireframe, e.g. no border at + // objects + if(!mxClone->HasLineStyle()) + { + bAddWireframe = true; + } + } + + if(bAddWireframe) + { + // use wireframe poly when full drag is off or did not work + aDragPolyPolygon = mxClone->TakeXorPoly(); + } + + // add evtl. extra DragPolyPolygon + const basegfx::B2DPolyPolygon aSpecialDragPolyPolygon(mxClone->getSpecialDragPoly(DragStat())); + + if(aSpecialDragPolyPolygon.count()) + { + aDragPolyPolygon.append(aSpecialDragPolyPolygon); + } + + if(aDragPolyPolygon.count()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPolyPolygon(std::move(aDragPolyPolygon)))); + } +} + +OUString SdrDragObjOwn::GetSdrDragComment() const +{ + OUString aStr; + // #i103058# get info string from the clone preferred, the original will + // not be changed. For security, use original as fallback + if(mxClone) + { + aStr = mxClone->getSpecialDragComment(DragStat()); + } + else + { + const SdrObject* pObj = GetDragObj(); + + if(pObj) + { + aStr = pObj->getSpecialDragComment(DragStat()); + } + } + return aStr; +} + +bool SdrDragObjOwn::BeginSdrDrag() +{ + if(!mxClone) + { + const SdrObject* pObj = GetDragObj(); + + if(pObj && !pObj->IsResizeProtect()) + { + if(pObj->beginSpecialDrag(DragStat())) + { + // create initial clone to have a start visualization + mxClone = pObj->getFullDragClone(); + mxClone->applySpecialDrag(DragStat()); + + return true; + } + } + } + + return false; +} + +void SdrDragObjOwn::MoveSdrDrag(const Point& rNoSnapPnt) +{ + const SdrObject* pObj = GetDragObj(); + + if (!pObj) + // No object to drag. Bail out. + return; + + Point aPnt(rNoSnapPnt); + SdrPageView* pPV = GetDragPV(); + + if (!pPV) + // No page view available. Bail out. + return; + + if(!DragStat().IsNoSnap()) + { + SnapPos(aPnt); + } + if(getSdrDragView().IsOrtho()) + { + if (DragStat().IsOrtho8Possible()) + { + OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho()); + } + else if (DragStat().IsOrtho4Possible()) + { + OrthoDistance4(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho()); + } + } + + if (!DragStat().CheckMinMoved(rNoSnapPnt)) + // Not moved by the minimum threshold. Nothing to do. + return; + + Hide(); + DragStat().NextMove(aPnt); + + // since SdrDragObjOwn currently supports no transformation of + // existing SdrDragEntries but only their recreation, a recreation + // after every move is needed in this mode. Delete existing + // SdrDragEntries here to force their recreation in the following Show(). + clearSdrDragEntries(); + + // delete current clone (after the last reference to it is deleted above) + mxClone.clear(); + + // create a new clone and modify to current drag state + mxClone = pObj->getFullDragClone(); + mxClone->applySpecialDrag(DragStat()); + + // AutoGrowWidth may change for SdrTextObj due to the automatism used + // with bDisableAutoWidthOnDragging, so not only geometry changes but + // also this (pretty indirect) property change is possible. If it gets + // changed, it needs to be copied to the original since nothing will + // happen when it only changes in the drag clone + const bool bOldAutoGrowWidth(pObj->GetMergedItem(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue()); + const bool bNewAutoGrowWidth(mxClone->GetMergedItem(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue()); + + if (bOldAutoGrowWidth != bNewAutoGrowWidth) + { + GetDragObj()->SetMergedItem(makeSdrTextAutoGrowWidthItem(bNewAutoGrowWidth)); + } + + Show(); +} + +bool SdrDragObjOwn::EndSdrDrag(bool /*bCopy*/) +{ + Hide(); + std::vector< std::unique_ptr > vConnectorUndoActions; + bool bRet = false; + SdrObject* pObj = GetDragObj(); + + if(pObj) + { + std::unique_ptr pUndo; + std::unique_ptr pUndo2; + const bool bUndo = getSdrDragView().IsUndoEnabled(); + + if( bUndo ) + { + getSdrDragView().EndTextEditCurrentView(); + if(!getSdrDragView().IsInsObjPoint() && pObj->IsInserted() ) + { + if (DragStat().IsEndDragChangesAttributes()) + { + pUndo=getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pObj); + + if (DragStat().IsEndDragChangesGeoAndAttributes()) + { + vConnectorUndoActions = getSdrDragView().CreateConnectorUndo( *pObj ); + pUndo2 = getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj); + } + } + else + { + vConnectorUndoActions = getSdrDragView().CreateConnectorUndo( *pObj ); + pUndo= getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj); + } + } + + if( pUndo ) + { + getSdrDragView().BegUndo( pUndo->GetComment() ); + } + else + { + getSdrDragView().BegUndo(); + } + } + + // Maybe use operator = for setting changed object data (do not change selection in + // view, this will destroy the interactor). This is possible since a clone is now + // directly modified by the modifiers. Only SdrTableObj is adding own UNDOs + // in its SdrTableObj::endSpecialDrag, so currently not possible. OTOH it uses + // a CreateUndoGeoObject(), so maybe setting SetEndDragChangesAttributes is okay. I + // will test this now + tools::Rectangle aBoundRect0; + + if(pObj->GetUserCall()) + { + aBoundRect0 = pObj->GetLastBoundRect(); + } + + bRet = pObj->applySpecialDrag(DragStat()); + if (DragStat().IsEndDragChangesLayout()) + { + auto pGeoUndo = dynamic_cast(pUndo.get()); + if (pGeoUndo) + pGeoUndo->SetSkipChangeLayout(true); + } + + if(bRet) + { + pObj->SetChanged(); + pObj->BroadcastObjectChange(); + pObj->SendUserCall( SdrUserCallType::Resize, aBoundRect0 ); + } + + if(bRet && bUndo ) + { + getSdrDragView().AddUndoActions( std::move(vConnectorUndoActions) ); + + if ( pUndo ) + { + getSdrDragView().AddUndo(std::move(pUndo)); + } + + if ( pUndo2 ) + { + getSdrDragView().AddUndo(std::move(pUndo2)); + } + } + + if( bUndo ) + getSdrDragView().EndUndo(); + } + + return bRet; +} + +PointerStyle SdrDragObjOwn::GetSdrDragPointer() const +{ + const SdrHdl* pHdl=GetDragHdl(); + + if (pHdl) + { + return pHdl->GetPointer(); + } + + return PointerStyle::Move; +} + + +void SdrDragMove::createSdrDragEntryForSdrObject(const SdrObject& rOriginal) +{ + // use the view-independent primitive representation (without + // evtl. GridOffset, that may be applied to the DragEntry individually) + drawinglayer::primitive2d::Primitive2DContainer xRetval; + rOriginal.GetViewContact().getViewIndependentPrimitive2DContainer(xRetval); + addSdrDragEntry( + std::unique_ptr( + new SdrDragEntryPrimitive2DSequence( + std::move(xRetval)))); + +} + +void SdrDragMove::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + rTarget.Move(Size(DragStat().GetDX(), DragStat().GetDY())); +} + +SdrDragMove::SdrDragMove(SdrDragView& rNewView) + : SdrDragMethod(rNewView) + , nBestXSnap(0) + , nBestYSnap(0) + , bXSnapped(false) + , bYSnapped(false) +{ + setMoveOnly(true); +} + +OUString SdrDragMove::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethMove) + + " (x=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDX()) + + " y=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDY()) + + ")"; + + if(getSdrDragView().IsDragWithCopy()) + { + if(!getSdrDragView().IsInsObjPoint() && !getSdrDragView().IsInsGluePoint()) + { + aStr += SvxResId(STR_EditWithCopy); + } + } + return aStr; +} + +bool SdrDragMove::BeginSdrDrag() +{ + DragStat().SetActionRect(GetMarkedRect()); + Show(); + + return true; +} + +basegfx::B2DHomMatrix SdrDragMove::getCurrentTransformation() const +{ + return basegfx::utils::createTranslateB2DHomMatrix(DragStat().GetDX(), DragStat().GetDY()); +} + +void SdrDragMove::ImpCheckSnap(const Point& rPt) +{ + Point aPt(rPt); + SdrSnap nRet=SnapPos(aPt); + aPt-=rPt; + + if (nRet & SdrSnap::XSNAPPED) + { + if (bXSnapped) + { + if (std::abs(aPt.X())aLR.Left() || aSR2.Right()aLR.Right()) + { + aPt1.AdjustX( -(aSR2.Right()-aLR.Right()) ); + } + } + else + aPt1.setX(DragStat().GetStart().X() ); // no space to move to + + if (aSR2.Top()>aLR.Top() || aSR2.Bottom()aLR.Bottom()) + { + aPt1.AdjustY( -(aSR2.Bottom()-aLR.Bottom()) ); + } + } + else + aPt1.setY(DragStat().GetStart().Y() ); // no space to move to + } + + if (getSdrDragView().IsDraggingGluePoints()) + { // restrict gluepoints to the BoundRect of the Obj + aPt1-=DragStat().GetStart(); + const SdrMarkList& rML=GetMarkedObjectList(); + const size_t nMarkCount=rML.GetMarkCount(); + + for (size_t nMarkNum=0; nMarkNumGetMarkedGluePoints(); + + if (!rPts.empty()) + { + const SdrObject* pObj=pM->GetMarkedSdrObj(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + tools::Rectangle aBound(pObj->GetCurrentBoundRect()); + + for (sal_uInt16 nId : rPts) + { + sal_uInt16 nGlueNum=pGPL->FindGluePoint(nId); + + if (nGlueNum!=SDRGLUEPOINT_NOTFOUND) + { + Point aPt((*pGPL)[nGlueNum].GetAbsolutePos(*pObj)); + aPt+=aPt1; // move by this much + if (aPt.X()aBound.Right() ) aPt1.AdjustX( -(aPt.X()-aBound.Right()) ) ; + if (aPt.Y()aBound.Bottom()) aPt1.AdjustY( -(aPt.Y()-aBound.Bottom()) ); + } + } + } + } + + aPt1+=DragStat().GetStart(); + } + + if (bOrtho) + OrthoDistance8(DragStat().GetStart(),aPt1,false); + + if (aPt1!=DragStat().GetNow()) + { + Hide(); + DragStat().NextMove(aPt1); + tools::Rectangle aAction(GetMarkedRect()); + aAction.Move(DragStat().GetDX(),DragStat().GetDY()); + DragStat().SetActionRect(aAction); + Show(); + } +} + +bool SdrDragMove::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (getSdrDragView().IsInsObjPoint() || getSdrDragView().IsInsGluePoint()) + bCopy=false; + + if (IsDraggingPoints()) + { + getSdrDragView().MoveMarkedPoints(Size(DragStat().GetDX(),DragStat().GetDY())); + } + else if (IsDraggingGluePoints()) + { + getSdrDragView().MoveMarkedGluePoints(Size(DragStat().GetDX(),DragStat().GetDY()),bCopy); + } + else + { + getSdrDragView().MoveMarkedObj(Size(DragStat().GetDX(),DragStat().GetDY()),bCopy); + } + + return true; +} + +PointerStyle SdrDragMove::GetSdrDragPointer() const +{ + if (IsDraggingPoints() || IsDraggingGluePoints()) + { + return PointerStyle::MovePoint; + } + else + { + return PointerStyle::Move; + } +} + + +SdrDragResize::SdrDragResize(SdrDragView& rNewView) +: SdrDragMethod(rNewView), + aXFact(1,1), + aYFact(1,1) +{ +} + +OUString SdrDragResize::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethResize); + Fraction aFact1(1,1); + Point aStart(DragStat().GetStart()); + Point aRef(DragStat().GetRef1()); + sal_Int32 nXDiv(aStart.X() - aRef.X()); + + if(!nXDiv) + nXDiv = 1; + + sal_Int32 nYDiv(aStart.Y() - aRef.Y()); + + if(!nYDiv) + nYDiv = 1; + + bool bX(aXFact != aFact1 && std::abs(nXDiv) > 1); + bool bY(aYFact != aFact1 && std::abs(nYDiv) > 1); + + if(bX || bY) + { + aStr += " ("; + + bool bEqual(aXFact == aYFact); + if(bX) + { + if(!bEqual) + aStr += "x="; + + aStr += SdrModel::GetPercentString(aXFact); + } + + if(bY && !bEqual) + { + if(bX) + aStr += " "; + + aStr += "y=" + SdrModel::GetPercentString(aYFact); + } + + aStr += ")"; + } + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragResize::BeginSdrDrag() +{ + SdrHdlKind eRefHdl=SdrHdlKind::Move; + SdrHdl* pRefHdl=nullptr; + + switch (GetDragHdlKind()) + { + case SdrHdlKind::UpperLeft: eRefHdl=SdrHdlKind::LowerRight; break; + case SdrHdlKind::Upper: eRefHdl=SdrHdlKind::Lower; DragStat().SetHorFixed(true); break; + case SdrHdlKind::UpperRight: eRefHdl=SdrHdlKind::LowerLeft; break; + case SdrHdlKind::Left : eRefHdl=SdrHdlKind::Right; DragStat().SetVerFixed(true); break; + case SdrHdlKind::Right: eRefHdl=SdrHdlKind::Left ; DragStat().SetVerFixed(true); break; + case SdrHdlKind::LowerLeft: eRefHdl=SdrHdlKind::UpperRight; break; + case SdrHdlKind::Lower: eRefHdl=SdrHdlKind::Upper; DragStat().SetHorFixed(true); break; + case SdrHdlKind::LowerRight: eRefHdl=SdrHdlKind::UpperLeft; break; + default: break; + } + + if (eRefHdl!=SdrHdlKind::Move) + pRefHdl=GetHdlList().GetHdl(eRefHdl); + + if (pRefHdl!=nullptr && !getSdrDragView().IsResizeAtCenter()) + { + DragStat().SetRef1(pRefHdl->GetPos()); + } + else + { + SdrHdl* pRef1=GetHdlList().GetHdl(SdrHdlKind::UpperLeft); + SdrHdl* pRef2=GetHdlList().GetHdl(SdrHdlKind::LowerRight); + + if (pRef1!=nullptr && pRef2!=nullptr) + { + DragStat().SetRef1(tools::Rectangle(pRef1->GetPos(),pRef2->GetPos()).Center()); + } + else + { + DragStat().SetRef1(GetMarkedRect().Center()); + } + } + + Show(); + + return true; +} + +basegfx::B2DHomMatrix SdrDragResize::getCurrentTransformation() const +{ + basegfx::B2DHomMatrix aRetval(basegfx::utils::createTranslateB2DHomMatrix( + -DragStat().GetRef1().X(), -DragStat().GetRef1().Y())); + aRetval.scale(double(aXFact), double(aYFact)); + aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y()); + + return aRetval; +} + +void SdrDragResize::MoveSdrDrag(const Point& rNoSnapPnt) +{ + Point aPnt(GetSnapPos(rNoSnapPnt)); + Point aStart(DragStat().GetStart()); + Point aRef(DragStat().GetRef1()); + Fraction aMaxFact(0x7FFFFFFF,1); + tools::Rectangle aLR(getSdrDragView().GetWorkArea()); + bool bWorkArea=!aLR.IsEmpty(); + bool bDragLimit=IsDragLimit(); + + if (bDragLimit || bWorkArea) + { + tools::Rectangle aSR(GetMarkedRect()); + + if (bDragLimit) + { + tools::Rectangle aR2(GetDragLimitRect()); + + if (bWorkArea) + aLR.Intersection(aR2); + else + aLR=aR2; + } + + if (aPnt.X()aLR.Right()) + aPnt.setX(aLR.Right() ); + + if (aPnt.Y()aLR.Bottom()) + aPnt.setY(aLR.Bottom() ); + + if (aRef.X()>aSR.Left()) + { + Fraction aMax(aRef.X()-aLR.Left(),aRef.X()-aSR.Left()); + + if (aMaxaSR.Top()) + { + Fraction aMax(aRef.Y()-aLR.Top(),aRef.Y()-aSR.Top()); + + if (aMaxFraction(nYMul,nYDiv)) !=getSdrDragView().IsBigOrtho()) + { + nXMul=nYMul; + nXDiv=nYDiv; + } + else + { + nYMul=nXMul; + nYDiv=nXDiv; + } + } + } + else + { + if (bOrtho) + { + if (DragStat().IsHorFixed()) + { + bXNeg=false; + nXMul=nYMul; + nXDiv=nYDiv; + } + + if (DragStat().IsVerFixed()) + { + bYNeg=false; + nYMul=nXMul; + nYDiv=nXDiv; + } + } + else + { + if (DragStat().IsHorFixed()) + { + bXNeg=false; + nXMul=1; + nXDiv=1; + } + + if (DragStat().IsVerFixed()) + { + bYNeg=false; + nYMul=1; + nYDiv=1; + } + } + } + + Fraction aNewXFact(nXMul,nXDiv); + Fraction aNewYFact(nYMul,nYDiv); + + if (bOrtho) + { + if (aNewXFact>aMaxFact) + { + aNewXFact=aMaxFact; + aNewYFact=aMaxFact; + } + + if (aNewYFact>aMaxFact) + { + aNewXFact=aMaxFact; + aNewYFact=aMaxFact; + } + } + + if (bXNeg) + aNewXFact=Fraction(-aNewXFact.GetNumerator(),aNewXFact.GetDenominator()); + + if (bYNeg) + aNewYFact=Fraction(-aNewYFact.GetNumerator(),aNewYFact.GetDenominator()); + + if (DragStat().CheckMinMoved(aPnt)) + { + if ((!DragStat().IsHorFixed() && aPnt.X()!=DragStat().GetNow().X()) || + (!DragStat().IsVerFixed() && aPnt.Y()!=DragStat().GetNow().Y())) + { + Hide(); + DragStat().NextMove(aPnt); + aXFact=aNewXFact; + aYFact=aNewYFact; + Show(); + } + } +} + +void SdrDragResize::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + rTarget.Resize(DragStat().GetRef1(),aXFact,aYFact); +} + +bool SdrDragResize::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (IsDraggingPoints()) + { + getSdrDragView().ResizeMarkedPoints(DragStat().GetRef1(),aXFact,aYFact); + } + else if (IsDraggingGluePoints()) + { + getSdrDragView().ResizeMarkedGluePoints(DragStat().GetRef1(),aXFact,aYFact,bCopy); + } + else + { + getSdrDragView().ResizeMarkedObj(DragStat().GetRef1(),aXFact,aYFact,bCopy); + } + + return true; +} + +PointerStyle SdrDragResize::GetSdrDragPointer() const +{ + const SdrHdl* pHdl=GetDragHdl(); + + if (pHdl!=nullptr) + { + return pHdl->GetPointer(); + } + + return PointerStyle::Move; +} + + +void SdrDragRotate::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + rTarget.Rotate(DragStat().GetRef1(), nAngle, nSin, nCos); +} + +SdrDragRotate::SdrDragRotate(SdrDragView& rNewView) +: SdrDragMethod(rNewView), + nSin(0.0), + nCos(1.0), + nAngle0(0), + nAngle(0), + bRight(false) +{ +} + +OUString SdrDragRotate::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethRotate) + + " ("; + Degree100 nTmpAngle(NormAngle36000(nAngle)); + + if(bRight && nAngle) + { + nTmpAngle -= 36000_deg100; + } + + aStr += SdrModel::GetAngleString(nTmpAngle) + ")"; + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragRotate::BeginSdrDrag() +{ + SdrHdl* pH=GetHdlList().GetHdl(SdrHdlKind::Ref1); + + if (nullptr != pH) + { + Show(); + DragStat().SetRef1(pH->GetPos()); + nAngle0=GetAngle(DragStat().GetStart()-DragStat().GetRef1()); + return true; + } + + // RotGrfFlyFrame: Support rotation around center *without* Ref1 (normally + // the rotation point) + const tools::Rectangle aLocalMarkRect(getSdrDragView().GetMarkedObjRect()); + + if(!aLocalMarkRect.IsEmpty()) + { + Show(); + DragStat().SetRef1(aLocalMarkRect.Center()); + nAngle0=GetAngle(DragStat().GetStart()-DragStat().GetRef1()); + return true; + } + + OSL_FAIL("SdrDragRotate::BeginSdrDrag(): No reference point handle found."); + return false; +} + +basegfx::B2DHomMatrix SdrDragRotate::getCurrentTransformation() const +{ + return basegfx::utils::createRotateAroundPoint( + DragStat().GetRef1().X(), DragStat().GetRef1().Y(), + -atan2(nSin, nCos)); +} + +void SdrDragRotate::MoveSdrDrag(const Point& rPnt_) +{ + Point aPnt(rPnt_); + if (!DragStat().CheckMinMoved(aPnt)) + return; + + Degree100 nNewAngle=NormAngle36000(GetAngle(aPnt-DragStat().GetRef1())-nAngle0); + Degree100 nSA(0); + + if (getSdrDragView().IsAngleSnapEnabled()) + nSA=getSdrDragView().GetSnapAngle(); + + if (!getSdrDragView().IsRotateAllowed()) + nSA=9000_deg100; + + if (nSA) + { // angle snapping + nNewAngle += nSA / 2_deg100; + nNewAngle /= nSA; + nNewAngle *= nSA; + } + + nNewAngle=NormAngle18000(nNewAngle); + + if (nAngle==nNewAngle) + return; + + sal_uInt16 nSekt0=GetAngleSector(nAngle); + sal_uInt16 nSekt1=GetAngleSector(nNewAngle); + + if (nSekt0==0 && nSekt1==3) + bRight=true; + + if (nSekt0==3 && nSekt1==0) + bRight=false; + + nAngle=nNewAngle; + double a = toRadians(nAngle); + double nSin1=sin(a); // calculate now, so as little time as possible + double nCos1=cos(a); // passes between Hide() and Show() + Hide(); + nSin=nSin1; + nCos=nCos1; + DragStat().NextMove(aPnt); + Show(); +} + +bool SdrDragRotate::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (nAngle!=0_deg100) + { + if (IsDraggingPoints()) + { + getSdrDragView().RotateMarkedPoints(DragStat().GetRef1(),nAngle); + } + else if (IsDraggingGluePoints()) + { + getSdrDragView().RotateMarkedGluePoints(DragStat().GetRef1(),nAngle,bCopy); + } + else + { + getSdrDragView().RotateMarkedObj(DragStat().GetRef1(),nAngle,bCopy); + } + } + return true; +} + +PointerStyle SdrDragRotate::GetSdrDragPointer() const +{ + return PointerStyle::Rotate; +} + + +SdrDragShear::SdrDragShear(SdrDragView& rNewView, bool bSlant1) +: SdrDragMethod(rNewView), + aFact(1,1), + nAngle0(0), + nAngle(0), + nTan(0.0), + bVertical(false), + bResize(false), + bUpSideDown(false), + bSlant(bSlant1) +{ +} + +OUString SdrDragShear::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethShear) + + " ("; + + Degree100 nTmpAngle(nAngle); + + if(bUpSideDown) + nTmpAngle += 18000_deg100; + + nTmpAngle = NormAngle18000(nTmpAngle); + + aStr += SdrModel::GetAngleString(nTmpAngle) + ")"; + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragShear::BeginSdrDrag() +{ + SdrHdlKind eRefHdl=SdrHdlKind::Move; + SdrHdl* pRefHdl=nullptr; + + switch (GetDragHdlKind()) + { + case SdrHdlKind::Upper: eRefHdl=SdrHdlKind::Lower; break; + case SdrHdlKind::Lower: eRefHdl=SdrHdlKind::Upper; break; + case SdrHdlKind::Left : eRefHdl=SdrHdlKind::Right; bVertical=true; break; + case SdrHdlKind::Right: eRefHdl=SdrHdlKind::Left ; bVertical=true; break; + default: break; + } + + if (eRefHdl!=SdrHdlKind::Move) + pRefHdl=GetHdlList().GetHdl(eRefHdl); + + if (pRefHdl!=nullptr) + { + DragStat().SetRef1(pRefHdl->GetPos()); + nAngle0=GetAngle(DragStat().GetStart()-DragStat().GetRef1()); + } + else + { + OSL_FAIL("SdrDragShear::BeginSdrDrag(): No reference point handle for shearing found."); + return false; + } + + Show(); + return true; +} + +basegfx::B2DHomMatrix SdrDragShear::getCurrentTransformation() const +{ + basegfx::B2DHomMatrix aRetval(basegfx::utils::createTranslateB2DHomMatrix( + -DragStat().GetRef1().X(), -DragStat().GetRef1().Y())); + + if (bResize) + { + if (bVertical) + { + aRetval.scale(double(aFact), 1.0); + aRetval.shearY(-nTan); + } + else + { + aRetval.scale(1.0, double(aFact)); + aRetval.shearX(-nTan); + } + } + + aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y()); + + return aRetval; +} + +void SdrDragShear::MoveSdrDrag(const Point& rPnt) +{ + if (!DragStat().CheckMinMoved(rPnt)) + return; + + bResize=!getSdrDragView().IsOrtho(); + Degree100 nSA(0); + + if (getSdrDragView().IsAngleSnapEnabled()) + nSA=getSdrDragView().GetSnapAngle(); + + Point aP0(DragStat().GetStart()); + Point aPnt(rPnt); + Fraction aNewFract(1,1); + + // if angle snapping not activated, snap to raster (except when using slant) + if (nSA==0_deg100 && !bSlant) + aPnt=GetSnapPos(aPnt); + + if (!bSlant && !bResize) + { // shear, but no resize + if (bVertical) + aPnt.setX(aP0.X() ); + else + aPnt.setY(aP0.Y() ); + } + + Point aRef(DragStat().GetRef1()); + Point aDif(aPnt-aRef); + + Degree100 nNewAngle(0); + + if (bSlant) + { + nNewAngle=NormAngle18000(-(GetAngle(aDif)-nAngle0)); + + if (bVertical) + nNewAngle=NormAngle18000(-nNewAngle); + } + else + { + if (bVertical) + nNewAngle=NormAngle18000(GetAngle(aDif)); + else + nNewAngle=NormAngle18000(-(GetAngle(aDif)-9000_deg100)); + + if (nNewAngle9000_deg100) + nNewAngle=NormAngle18000(nNewAngle+18000_deg100); + + if (bResize) + { + Point aPt2(aPnt); + + if (nSA!=0_deg100) + aPt2=GetSnapPos(aPnt); // snap this one in any case + + if (bVertical) + { + aNewFract=Fraction(aPt2.X()-aRef.X(),aP0.X()-aRef.X()); + } + else + { + aNewFract=Fraction(aPt2.Y()-aRef.Y(),aP0.Y()-aRef.Y()); + } + } + } + + bool bNeg=nNewAngle<0_deg100; + + if (bNeg) + nNewAngle=-nNewAngle; + + if (nSA) + { // angle snapping + nNewAngle += nSA / 2_deg100; + nNewAngle /= nSA; + nNewAngle *= nSA; + } + + nNewAngle=NormAngle36000(nNewAngle); + bUpSideDown=nNewAngle>9000_deg100 && nNewAngle<27000_deg100; + + if (bSlant) + { // calculate resize for slant + // when angle snapping is activated, disable 89 degree limit + Degree100 nTmpAngle=nNewAngle; + if (bUpSideDown) nNewAngle -= 18000_deg100; + if (bNeg) nTmpAngle=-nTmpAngle; + bResize=true; + aNewFract = cos(toRadians(nTmpAngle)); + aFact.ReduceInaccurate(10); // three decimals should be enough + } + + if (nNewAngle > 8900_deg100) + nNewAngle = 8900_deg100; + + if (bNeg) + nNewAngle=-nNewAngle; + + if (nAngle!=nNewAngle || aFact!=aNewFract) + { + nAngle=nNewAngle; + aFact=aNewFract; + double a = toRadians(nAngle); + double nTan1=tan(a); // calculate now, so as little time as possible passes between Hide() and Show() + Hide(); + nTan=nTan1; + DragStat().NextMove(rPnt); + Show(); + } +} + +void SdrDragShear::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + if (bResize) + { + if (bVertical) + { + rTarget.Resize(DragStat().GetRef1(),aFact,Fraction(1,1)); + } + else + { + rTarget.Resize(DragStat().GetRef1(),Fraction(1,1),aFact); + } + } + + if (nAngle) + { + rTarget.Shear(DragStat().GetRef1(), nAngle, nTan, bVertical); + } +} + +bool SdrDragShear::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (bResize && aFact==Fraction(1,1)) + bResize=false; + + if (nAngle || bResize) + { + if (nAngle && bResize) + { + OUString aStr = ImpGetDescriptionStr(STR_EditShear); + + if (bCopy) + aStr += SvxResId(STR_EditWithCopy); + + getSdrDragView().BegUndo(aStr); + } + + if (bResize) + { + if (bVertical) + { + getSdrDragView().ResizeMarkedObj(DragStat().GetRef1(),aFact,Fraction(1,1),bCopy); + } + else + { + getSdrDragView().ResizeMarkedObj(DragStat().GetRef1(),Fraction(1,1),aFact,bCopy); + } + + bCopy=false; + } + + if (nAngle) + { + getSdrDragView().ShearMarkedObj(DragStat().GetRef1(),nAngle,bVertical,bCopy); + } + + if (nAngle && bResize) + getSdrDragView().EndUndo(); + + return true; + } + + return false; +} + +PointerStyle SdrDragShear::GetSdrDragPointer() const +{ + if (bVertical) + return PointerStyle::VShear; + else + return PointerStyle::HShear; +} + + +void SdrDragMirror::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + if(bMirrored) + { + rTarget.Mirror(DragStat().GetRef1(), DragStat().GetRef2()); + } +} + +SdrDragMirror::SdrDragMirror(SdrDragView& rNewView) +: SdrDragMethod(rNewView), + nAngle(0), + bMirrored(false), + bSide0(false) +{ +} + +bool SdrDragMirror::ImpCheckSide(const Point& rPnt) const +{ + Degree100 nAngle1=GetAngle(rPnt-DragStat().GetRef1()); + nAngle1-=nAngle; + nAngle1=NormAngle36000(nAngle1); + + return nAngle1<18000_deg100; +} + +OUString SdrDragMirror::GetSdrDragComment() const +{ + OUString aStr; + if (aDif.X()==0) + aStr = ImpGetDescriptionStr(STR_DragMethMirrorHori); + else if (aDif.Y()==0) + aStr = ImpGetDescriptionStr(STR_DragMethMirrorVert); + else if (std::abs(aDif.X()) == std::abs(aDif.Y())) + aStr = ImpGetDescriptionStr(STR_DragMethMirrorDiag); + else + aStr = ImpGetDescriptionStr(STR_DragMethMirrorFree); + + if (getSdrDragView().IsDragWithCopy()) + aStr+=SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragMirror::BeginSdrDrag() +{ + SdrHdl* pH1=GetHdlList().GetHdl(SdrHdlKind::Ref1); + SdrHdl* pH2=GetHdlList().GetHdl(SdrHdlKind::Ref2); + + if (pH1!=nullptr && pH2!=nullptr) + { + DragStat().SetRef1(pH1->GetPos()); + DragStat().SetRef2(pH2->GetPos()); + Ref1()=pH1->GetPos(); + Ref2()=pH2->GetPos(); + aDif=pH2->GetPos()-pH1->GetPos(); + bool b90=(aDif.X()==0) || aDif.Y()==0; + bool b45=b90 || (std::abs(aDif.X()) == std::abs(aDif.Y())); + nAngle=NormAngle36000(GetAngle(aDif)); + + if (!getSdrDragView().IsMirrorAllowed() && !b45) + return false; // free choice of axis angle not allowed + + if (!getSdrDragView().IsMirrorAllowed() && !b90) + return false; // 45 degrees not allowed either + + bSide0=ImpCheckSide(DragStat().GetStart()); + Show(); + return true; + } + else + { + OSL_FAIL("SdrDragMirror::BeginSdrDrag(): Axis of reflection not found."); + return false; + } +} + +basegfx::B2DHomMatrix SdrDragMirror::getCurrentTransformation() const +{ + basegfx::B2DHomMatrix aRetval; + + if (bMirrored) + { + const double fDeltaX(DragStat().GetRef2().X() - DragStat().GetRef1().X()); + const double fDeltaY(DragStat().GetRef2().Y() - DragStat().GetRef1().Y()); + const double fRotation(atan2(fDeltaY, fDeltaX)); + + aRetval = basegfx::utils::createTranslateB2DHomMatrix(-DragStat().GetRef1().X(), -DragStat().GetRef1().Y()); + aRetval.rotate(-fRotation); + aRetval.scale(1.0, -1.0); + aRetval.rotate(fRotation); + aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y()); + } + + return aRetval; +} + +void SdrDragMirror::MoveSdrDrag(const Point& rPnt) +{ + if (!DragStat().CheckMinMoved(rPnt)) + return; + + bool bNewSide=ImpCheckSide(rPnt); + bool bNewMirrored=bSide0!=bNewSide; + + if (bMirrored!=bNewMirrored) + { + Hide(); + bMirrored=bNewMirrored; + DragStat().NextMove(rPnt); + Show(); + } +} + +bool SdrDragMirror::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (bMirrored) + { + getSdrDragView().MirrorMarkedObj(DragStat().GetRef1(),DragStat().GetRef2(),bCopy); + } + + return true; +} + +PointerStyle SdrDragMirror::GetSdrDragPointer() const +{ + return PointerStyle::Mirror; +} + + +SdrDragGradient::SdrDragGradient(SdrDragView& rNewView, bool bGrad) +: SdrDragMethod(rNewView), + pIAOHandle(nullptr), + bIsGradient(bGrad) +{ +} + +OUString SdrDragGradient::GetSdrDragComment() const +{ + if(IsGradient()) + return ImpGetDescriptionStr(STR_DragMethGradient); + else + return ImpGetDescriptionStr(STR_DragMethTransparence); +} + +bool SdrDragGradient::BeginSdrDrag() +{ + bool bRetval(false); + + pIAOHandle = static_cast(GetHdlList().GetHdl(IsGradient() ? SdrHdlKind::Gradient : SdrHdlKind::Transparence)); + + if(pIAOHandle) + { + // save old values + DragStat().SetRef1( pIAOHandle->GetPos() ); + DragStat().SetRef2( pIAOHandle->Get2ndPos() ); + + // what was hit? + bool bHit(false); + SdrHdlColor* pColHdl = pIAOHandle->GetColorHdl1(); + + // init handling flags + pIAOHandle->SetMoveSingleHandle(false); + pIAOHandle->SetMoveFirstHandle(false); + + // test first color handle + if(pColHdl) + { + basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y()); + + if(pColHdl->getOverlayObjectList().isHitLogic(aPosition)) + { + bHit = true; + pIAOHandle->SetMoveSingleHandle(true); + pIAOHandle->SetMoveFirstHandle(true); + } + } + + // test second color handle + pColHdl = pIAOHandle->GetColorHdl2(); + + if(!bHit && pColHdl) + { + basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y()); + + if(pColHdl->getOverlayObjectList().isHitLogic(aPosition)) + { + bHit = true; + pIAOHandle->SetMoveSingleHandle(true); + } + } + + // test gradient handle itself + if(!bHit) + { + basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y()); + + if(pIAOHandle->getOverlayObjectList().isHitLogic(aPosition)) + { + bHit = true; + } + } + + // everything up and running :o} + bRetval = bHit; + } + else + { + OSL_FAIL("SdrDragGradient::BeginSdrDrag(): IAOGradient not found."); + } + + return bRetval; +} + +void SdrDragGradient::MoveSdrDrag(const Point& rPnt) +{ + if(!(pIAOHandle && DragStat().CheckMinMoved(rPnt))) + return; + + DragStat().NextMove(rPnt); + + // Do the Move here!!! DragStat().GetStart() + Point aMoveDiff = rPnt - DragStat().GetStart(); + + if(pIAOHandle->IsMoveSingleHandle()) + { + if(pIAOHandle->IsMoveFirstHandle()) + { + pIAOHandle->SetPos(DragStat().GetRef1() + aMoveDiff); + if(pIAOHandle->GetColorHdl1()) + pIAOHandle->GetColorHdl1()->SetPos(DragStat().GetRef1() + aMoveDiff); + } + else + { + pIAOHandle->Set2ndPos(DragStat().GetRef2() + aMoveDiff); + if(pIAOHandle->GetColorHdl2()) + pIAOHandle->GetColorHdl2()->SetPos(DragStat().GetRef2() + aMoveDiff); + } + } + else + { + pIAOHandle->SetPos(DragStat().GetRef1() + aMoveDiff); + pIAOHandle->Set2ndPos(DragStat().GetRef2() + aMoveDiff); + + if(pIAOHandle->GetColorHdl1()) + pIAOHandle->GetColorHdl1()->SetPos(DragStat().GetRef1() + aMoveDiff); + + if(pIAOHandle->GetColorHdl2()) + pIAOHandle->GetColorHdl2()->SetPos(DragStat().GetRef2() + aMoveDiff); + } + + // new state + pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), false, false); +} + +bool SdrDragGradient::EndSdrDrag(bool /*bCopy*/) +{ + Ref1() = pIAOHandle->GetPos(); + Ref2() = pIAOHandle->Get2ndPos(); + + // new state + pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), true, true); + + return true; +} + +void SdrDragGradient::CancelSdrDrag() +{ + // restore old values + pIAOHandle->SetPos(DragStat().GetRef1()); + pIAOHandle->Set2ndPos(DragStat().GetRef2()); + + if(pIAOHandle->GetColorHdl1()) + pIAOHandle->GetColorHdl1()->SetPos(DragStat().GetRef1()); + + if(pIAOHandle->GetColorHdl2()) + pIAOHandle->GetColorHdl2()->SetPos(DragStat().GetRef2()); + + // new state + pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), true, false); +} + +PointerStyle SdrDragGradient::GetSdrDragPointer() const +{ + return PointerStyle::RefHand; +} + + +SdrDragCrook::SdrDragCrook(SdrDragView& rNewView) +: SdrDragMethod(rNewView), + aFact(1,1), + bContortionAllowed(false), + bNoContortionAllowed(false), + bContortion(false), + bResizeAllowed(false), + bResize(false), + bRotateAllowed(false), + bRotate(false), + bVertical(false), + bValid(false), + bLft(false), + bRgt(false), + bUpr(false), + bLwr(false), + bAtCenter(false), + nAngle(0), + nMarkSize(0), + eMode(SdrCrookMode::Rotate) +{ +} + +OUString SdrDragCrook::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(!bContortion ? STR_DragMethCrook : STR_DragMethCrookContortion); + + if(bValid) + { + aStr += " ("; + + sal_Int32 nVal(nAngle); + + if(bAtCenter) + nVal *= 2; + + nVal = std::abs(nVal); + aStr += SdrModel::GetAngleString(Degree100(nVal)) + ")"; + } + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +// These defines parametrize the created raster +// for interactions +#define DRAG_CROOK_RASTER_MINIMUM (4) +#define DRAG_CROOK_RASTER_MAXIMUM (15) +#define DRAG_CROOK_RASTER_DISTANCE (30) + +static basegfx::B2DPolyPolygon impCreateDragRaster(SdrPageView const & rPageView, const tools::Rectangle& rMarkRect) +{ + basegfx::B2DPolyPolygon aRetval; + + if(rPageView.PageWindowCount()) + { + OutputDevice& rOut = rPageView.GetPageWindow(0)->GetPaintWindow().GetOutputDevice(); + tools::Rectangle aPixelSize = rOut.LogicToPixel(rMarkRect); + sal_uInt32 nHorDiv(aPixelSize.GetWidth() / DRAG_CROOK_RASTER_DISTANCE); + sal_uInt32 nVerDiv(aPixelSize.GetHeight() / DRAG_CROOK_RASTER_DISTANCE); + + if(nHorDiv > DRAG_CROOK_RASTER_MAXIMUM) + nHorDiv = DRAG_CROOK_RASTER_MAXIMUM; + if(nHorDiv < DRAG_CROOK_RASTER_MINIMUM) + nHorDiv = DRAG_CROOK_RASTER_MINIMUM; + + if(nVerDiv > DRAG_CROOK_RASTER_MAXIMUM) + nVerDiv = DRAG_CROOK_RASTER_MAXIMUM; + if(nVerDiv < DRAG_CROOK_RASTER_MINIMUM) + nVerDiv = DRAG_CROOK_RASTER_MINIMUM; + + const double fXLen(rMarkRect.GetWidth() / static_cast(nHorDiv)); + const double fYLen(rMarkRect.GetHeight() / static_cast(nVerDiv)); + double fYPos(rMarkRect.Top()); + sal_uInt32 a, b; + + for(a = 0; a <= nVerDiv; a++) + { + // horizontal lines + for(b = 0; b < nHorDiv; b++) + { + basegfx::B2DPolygon aHorLineSegment; + + const double fNewX(rMarkRect.Left() + (b * fXLen)); + aHorLineSegment.append(basegfx::B2DPoint(fNewX, fYPos)); + aHorLineSegment.appendBezierSegment( + basegfx::B2DPoint(fNewX + (fXLen * (1.0 / 3.0)), fYPos), + basegfx::B2DPoint(fNewX + (fXLen * (2.0 / 3.0)), fYPos), + basegfx::B2DPoint(fNewX + fXLen, fYPos)); + aRetval.append(aHorLineSegment); + } + + // increments + fYPos += fYLen; + } + + double fXPos(rMarkRect.Left()); + + for(a = 0; a <= nHorDiv; a++) + { + // vertical lines + for(b = 0; b < nVerDiv; b++) + { + basegfx::B2DPolygon aVerLineSegment; + + const double fNewY(rMarkRect.Top() + (b * fYLen)); + aVerLineSegment.append(basegfx::B2DPoint(fXPos, fNewY)); + aVerLineSegment.appendBezierSegment( + basegfx::B2DPoint(fXPos, fNewY + (fYLen * (1.0 / 3.0))), + basegfx::B2DPoint(fXPos, fNewY + (fYLen * (2.0 / 3.0))), + basegfx::B2DPoint(fXPos, fNewY + fYLen)); + aRetval.append(aVerLineSegment); + } + + // increments + fXPos += fXLen; + } + } + + return aRetval; +} + +void SdrDragCrook::createSdrDragEntries() +{ + // Add extended frame raster first, so it will be behind objects + if(getSdrDragView().GetSdrPageView()) + { + const basegfx::B2DPolyPolygon aDragRaster(impCreateDragRaster(*getSdrDragView().GetSdrPageView(), GetMarkedRect())); + + if(aDragRaster.count()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPolyPolygon(aDragRaster))); + } + } + + // call parent + SdrDragMethod::createSdrDragEntries(); +} + +bool SdrDragCrook::BeginSdrDrag() +{ + bContortionAllowed=getSdrDragView().IsCrookAllowed(); + bNoContortionAllowed=getSdrDragView().IsCrookAllowed(true); + bResizeAllowed=getSdrDragView().IsResizeAllowed(); + bRotateAllowed=getSdrDragView().IsRotateAllowed(); + + if (bContortionAllowed || bNoContortionAllowed) + { + bVertical=(GetDragHdlKind()==SdrHdlKind::Lower || GetDragHdlKind()==SdrHdlKind::Upper); + aMarkRect=GetMarkedRect(); + aMarkCenter=aMarkRect.Center(); + nMarkSize=bVertical ? (aMarkRect.GetHeight()-1) : (aMarkRect.GetWidth()-1); + aCenter=aMarkCenter; + aStart=DragStat().GetStart(); + Show(); + return true; + } + else + { + return false; + } +} + +void SdrDragCrook::MovAllPoints(basegfx::B2DPolyPolygon& rTarget) +{ + SdrPageView* pPV = getSdrDragView().GetSdrPageView(); + + if(!pPV) + return; + + XPolyPolygon aTempPolyPoly(rTarget); + + if (pPV->HasMarkedObjPageView()) + { + sal_uInt16 nPolyCount=aTempPolyPoly.Count(); + + if (!bContortion && !getSdrDragView().IsNoDragXorPolys()) + { + sal_uInt16 n1st=0,nLast=0; + Point aC(aCenter); + + while (n1ststd::abs(dy1); + else + bValid = std::abs(dy1)*100>std::abs(dx1); + } + + tools::Long nNewRad=0; + nAngle=0_deg100; + + if (bValid) + { + double a=0; // slope of the radius + Degree100 nPntAngle(0); + + if (bVertical) + { + a=static_cast(dy1)/static_cast(dx1); // slope of the radius + nNewRad=(static_cast(dy1*a)+dx1) /2; + aNewCenter.AdjustX(nNewRad ); + nPntAngle=GetAngle(aPnt-aNewCenter); + } + else + { + a=static_cast(dx1)/static_cast(dy1); // slope of the radius + nNewRad=(static_cast(dx1*a)+dy1) /2; + aNewCenter.AdjustY(nNewRad ); + nPntAngle=GetAngle(aPnt-aNewCenter)-9000_deg100; + } + + if (!bAtCenter) + { + if (nNewRad<0) + { + if (bRgt) nPntAngle += 18000_deg100; + if (bLft) nPntAngle = 18000_deg100 - nPntAngle; + if (bLwr) nPntAngle =- nPntAngle; + } + else + { + if (bRgt) nPntAngle = -nPntAngle; + if (bUpr) nPntAngle = 18000_deg100 - nPntAngle; + if (bLwr) nPntAngle += 18000_deg100; + } + + nPntAngle=NormAngle36000(nPntAngle); + } + else + { + if (nNewRad<0) nPntAngle += 18000_deg100; + if (bVertical) nPntAngle = 18000_deg100 - nPntAngle; + nPntAngle = NormAngle18000(nPntAngle); + nPntAngle = abs(nPntAngle); + } + + double nCircumference = 2 * std::abs(nNewRad) * M_PI; + + if (bResize) + { + tools::Long nMul=static_cast(nCircumference * NormAngle36000(nPntAngle).get() / 36000.0); + + if (bAtCenter) + nMul*=2; + + aNewFract=Fraction(nMul,nMarkSize); + nAngle=nPntAngle; + } + else + { + nAngle = Degree100(static_cast((nMarkSize*360/nCircumference)*100)/2); + + if (nAngle==0_deg100) + bValid=false; + } + } + + if (nAngle==0_deg100 || nNewRad==0) + bValid=false; + + if (!bValid) + nNewRad=0; + + if (!bValid && bResize) + { + tools::Long nMul=bVertical ? dy1 : dx1; + + if (bLft || bUpr) + nMul=-nMul; + + tools::Long nDiv=nMarkSize; + + if (bAtCenter) + { + nMul*=2; + nMul = std::abs(nMul); + } + + aNewFract=Fraction(nMul,nDiv); + } + + if (aNewCenter==aCenter && bNewContortion==bContortion && aNewFract==aFact && + bNewMoveOnly == getMoveOnly() && bNewRotate==bRotate && eNewMode==eMode) + return; + + Hide(); + setMoveOnly(bNewMoveOnly); + bRotate=bNewRotate; + eMode=eNewMode; + bContortion=bNewContortion; + aCenter=aNewCenter; + aFact=aNewFract; + aRad=Point(nNewRad,nNewRad); + bResize=aFact!=Fraction(1,1) && aFact.GetDenominator()!=0 && aFact.IsValid(); + DragStat().NextMove(aPnt); + Show(); +} + +void SdrDragCrook::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + const bool bDoResize(aFact!=Fraction(1,1)); + const bool bDoCrook(aCenter!=aMarkCenter && aRad.X()!=0 && aRad.Y()!=0); + + if (!(bDoCrook || bDoResize)) + return; + + if (bDoResize) + { + Fraction aFact1(1,1); + + if (bContortion) + { + if (bVertical) + { + rTarget.Resize(aCenter,aFact1,aFact); + } + else + { + rTarget.Resize(aCenter,aFact,aFact1); + } + } + else + { + Point aCtr0(rTarget.GetSnapRect().Center()); + Point aCtr1(aCtr0); + + if (bVertical) + { + ResizePoint(aCtr1,aCenter,aFact1,aFact); + } + else + { + ResizePoint(aCtr1,aCenter,aFact,aFact1); + } + + Size aSiz(aCtr1.X()-aCtr0.X(),aCtr1.Y()-aCtr0.Y()); + + rTarget.Move(aSiz); + } + } + + if (bDoCrook) + { + const tools::Rectangle aLocalMarkRect(getSdrDragView().GetMarkedObjRect()); + const bool bLocalRotate(!bContortion && eMode == SdrCrookMode::Rotate && getSdrDragView().IsRotateAllowed()); + + SdrEditView::ImpCrookObj(&rTarget,aCenter,aRad,eMode,bVertical,!bContortion,bLocalRotate,aLocalMarkRect); + } +} + +void SdrDragCrook::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget) +{ + // use helper derived from old stuff + MovAllPoints(rTarget); +} + +bool SdrDragCrook::EndSdrDrag(bool bCopy) +{ + Hide(); + + if (bResize && aFact==Fraction(1,1)) + bResize=false; + + const bool bUndo = getSdrDragView().IsUndoEnabled(); + + bool bDoCrook=aCenter!=aMarkCenter && aRad.X()!=0 && aRad.Y()!=0; + + if (bDoCrook || bResize) + { + if (bResize && bUndo) + { + OUString aStr = ImpGetDescriptionStr(!bContortion?STR_EditCrook:STR_EditCrookContortion); + + if (bCopy) + aStr += SvxResId(STR_EditWithCopy); + + getSdrDragView().BegUndo(aStr); + } + + if (bResize) + { + Fraction aFact1(1,1); + + if (bContortion) + { + if (bVertical) + getSdrDragView().ResizeMarkedObj(aCenter,aFact1,aFact,bCopy); + else + getSdrDragView().ResizeMarkedObj(aCenter,aFact,aFact1,bCopy); + } + else + { + if (bCopy) + getSdrDragView().CopyMarkedObj(); + + const size_t nMarkCount=getSdrDragView().GetMarkedObjectList().GetMarkCount(); + + for (size_t nm=0; nmGetMarkedSdrObj(); + Point aCtr0(pO->GetSnapRect().Center()); + Point aCtr1(aCtr0); + + if (bVertical) + ResizePoint(aCtr1,aCenter,aFact1,aFact); + else + ResizePoint(aCtr1,aCenter,aFact,aFact1); + + Size aSiz(aCtr1.X()-aCtr0.X(),aCtr1.Y()-aCtr0.Y()); + if( bUndo ) + AddUndo(getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoMoveObject(*pO,aSiz)); + pO->Move(aSiz); + } + } + + bCopy=false; + } + + if (bDoCrook) + { + getSdrDragView().CrookMarkedObj(aCenter,aRad,eMode,bVertical,!bContortion,bCopy); + } + + if (bResize && bUndo) + getSdrDragView().EndUndo(); + + return true; + } + + return false; +} + +PointerStyle SdrDragCrook::GetSdrDragPointer() const +{ + return PointerStyle::Crook; +} + + +SdrDragDistort::SdrDragDistort(SdrDragView& rNewView) +: SdrDragMethod(rNewView), + nPolyPt(0), + bContortionAllowed(false), + bNoContortionAllowed(false), + bContortion(false) +{ +} + +OUString SdrDragDistort::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethDistort) + + " (x=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDX()) + + " y=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDY()) + + ")"; + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +void SdrDragDistort::createSdrDragEntries() +{ + // Add extended frame raster first, so it will be behind objects + if(getSdrDragView().GetSdrPageView()) + { + const basegfx::B2DPolyPolygon aDragRaster(impCreateDragRaster(*getSdrDragView().GetSdrPageView(), GetMarkedRect())); + + if(aDragRaster.count()) + { + addSdrDragEntry(std::unique_ptr(new SdrDragEntryPolyPolygon(aDragRaster))); + } + } + + // call parent + SdrDragMethod::createSdrDragEntries(); +} + +bool SdrDragDistort::BeginSdrDrag() +{ + bContortionAllowed=getSdrDragView().IsDistortAllowed(); + bNoContortionAllowed=getSdrDragView().IsDistortAllowed(true); + + if (bContortionAllowed || bNoContortionAllowed) + { + SdrHdlKind eKind=GetDragHdlKind(); + nPolyPt=0xFFFF; + + if (eKind==SdrHdlKind::UpperLeft) nPolyPt=0; + if (eKind==SdrHdlKind::UpperRight) nPolyPt=1; + if (eKind==SdrHdlKind::LowerRight) nPolyPt=2; + if (eKind==SdrHdlKind::LowerLeft) nPolyPt=3; + if (nPolyPt>3) return false; + + aMarkRect=GetMarkedRect(); + aDistortedRect=XPolygon(aMarkRect); + Show(); + return true; + } + else + { + return false; + } +} + +void SdrDragDistort::MovAllPoints(basegfx::B2DPolyPolygon& rTarget) +{ + if (!bContortion) + return; + + SdrPageView* pPV = getSdrDragView().GetSdrPageView(); + + if(pPV && pPV->HasMarkedObjPageView()) + { + basegfx::B2DPolyPolygon aDragPolygon(rTarget); + const basegfx::B2DRange aOriginalRange = vcl::unotools::b2DRectangleFromRectangle(aMarkRect); + const basegfx::B2DPoint aTopLeft(aDistortedRect[0].X(), aDistortedRect[0].Y()); + const basegfx::B2DPoint aTopRight(aDistortedRect[1].X(), aDistortedRect[1].Y()); + const basegfx::B2DPoint aBottomLeft(aDistortedRect[3].X(), aDistortedRect[3].Y()); + const basegfx::B2DPoint aBottomRight(aDistortedRect[2].X(), aDistortedRect[2].Y()); + + aDragPolygon = basegfx::utils::distort(aDragPolygon, aOriginalRange, aTopLeft, aTopRight, aBottomLeft, aBottomRight); + rTarget = aDragPolygon; + } +} + +void SdrDragDistort::MoveSdrDrag(const Point& rPnt) +{ + if (!DragStat().CheckMinMoved(rPnt)) + return; + + Point aPnt(GetSnapPos(rPnt)); + + if (getSdrDragView().IsOrtho()) + OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho()); + + bool bNewContortion=(bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed; + + if (bNewContortion!=bContortion || aDistortedRect[nPolyPt]!=aPnt) + { + Hide(); + aDistortedRect[nPolyPt]=aPnt; + bContortion=bNewContortion; + DragStat().NextMove(aPnt); + Show(); + } +} + +bool SdrDragDistort::EndSdrDrag(bool bCopy) +{ + Hide(); + bool bDoDistort=DragStat().GetDX()!=0 || DragStat().GetDY()!=0; + + if (bDoDistort) + { + getSdrDragView().DistortMarkedObj(aMarkRect,aDistortedRect,!bContortion,bCopy); + return true; + } + + return false; +} + +PointerStyle SdrDragDistort::GetSdrDragPointer() const +{ + return PointerStyle::RefHand; +} + +void SdrDragDistort::applyCurrentTransformationToSdrObject(SdrObject& rTarget) +{ + const bool bDoDistort(DragStat().GetDX()!=0 || DragStat().GetDY()!=0); + + if (bDoDistort) + { + SdrEditView::ImpDistortObj(&rTarget, aMarkRect, aDistortedRect, !bContortion); + } +} + +void SdrDragDistort::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget) +{ + // use helper derived from old stuff + MovAllPoints(rTarget); +} + + +SdrDragCrop::SdrDragCrop(SdrDragView& rNewView) +: SdrDragObjOwn(rNewView) +{ + // switch off solid dragging for crop; it just makes no sense since showing + // a 50% transparent object above the original will not be visible + setSolidDraggingActive(false); +} + +OUString SdrDragCrop::GetSdrDragComment() const +{ + OUString aStr = ImpGetDescriptionStr(STR_DragMethCrop) + + " (x=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDX()) + + " y=" + + getSdrDragView().GetModel().GetMetricString(DragStat().GetDY()) + + ")"; + + if(getSdrDragView().IsDragWithCopy()) + aStr += SvxResId(STR_EditWithCopy); + return aStr; +} + +bool SdrDragCrop::BeginSdrDrag() +{ + // call parent + bool bRetval(SdrDragObjOwn::BeginSdrDrag()); + + if(!GetDragHdl()) + { + // we need the DragHdl, break if not there + bRetval = false; + } + + return bRetval; +} + +bool SdrDragCrop::EndSdrDrag(bool /*bCopy*/) +{ + Hide(); + + if(0 == DragStat().GetDX() && 0 == DragStat().GetDY()) + { + // no change, done + return false; + } + + const SdrMarkList& rMarkList = getSdrDragView().GetMarkedObjectList(); + + if(1 != rMarkList.GetMarkCount()) + { + // Crop only with single Object selected + return false; + } + + // prepare for SdrGrafObj or others. This code has to work with usual + // SdrGrafObj's from Draw/Impress/Calc, but also with SdrObjects from + // Writer. It would be better to handle this in Writer directly, but + // there are currently no easy mechanisms to plug an alternative interaction + // from there + SdrObject* pSdrObject = rMarkList.GetMark(0)->GetMarkedSdrObj(); + rtl::Reference pFullDragClone; + bool bExternal(false); + SdrObject* pExternalSdrObject(nullptr); + + // RotGrfFlyFrame: Crop decision for DrawingLayer/Writer now + // locally, no two-in-one methods any more + if (nullptr != pSdrObject && dynamic_cast< const SdrGrafObj* >(pSdrObject) == nullptr) + { + // If Writer, get the already offered for interaction SdrGrafObj + // and set up for using that replacement object that contains the + // real transformation. That SdrObject is owned and has to be deleted, + // so use a std::unique_ptr with special handling for the protected + // SDrObject destructor + pFullDragClone = pSdrObject->getFullDragClone(); + + if(dynamic_cast< SdrGrafObj* >(pFullDragClone.get())) + { + bExternal = true; + pExternalSdrObject = pSdrObject; + pSdrObject = pFullDragClone.get(); + } + } + + // get and check for SdrGrafObj now + SdrGrafObj* pObj = dynamic_cast( pSdrObject ); + + if(!pObj) + { + return false; + } + + // no undo for external needed, done there + const bool bUndo(!bExternal && getSdrDragView().IsUndoEnabled()); + + if(bUndo) + { + OUString aUndoStr = ImpGetDescriptionStr(STR_DragMethCrop); + + getSdrDragView().BegUndo( aUndoStr ); + getSdrDragView().AddUndo(getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + // also need attr undo, the SdrGrafCropItem will be changed + getSdrDragView().AddUndo(getSdrDragView().GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pObj)); + } + + // get the original objects transformation + basegfx::B2DHomMatrix aOriginalMatrix; + basegfx::B2DPolyPolygon aPolyPolygon; + bool bShearCorrected(false); + pObj->TRGetBaseGeometry(aOriginalMatrix, aPolyPolygon); + + { // correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080 + const basegfx::utils::B2DHomMatrixBufferedDecompose aTmpDecomp(aOriginalMatrix); + + if(!basegfx::fTools::equalZero(aTmpDecomp.getShearX())) + { + bShearCorrected = true; + aOriginalMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aTmpDecomp.getScale(), + -aTmpDecomp.getShearX(), + aTmpDecomp.getRotate(), + aTmpDecomp.getTranslate()); + } + } + + // generate start point of original drag vector in unit coordinates (the + // vis-a-vis of the drag point) + basegfx::B2DPoint aLocalStart(0.0, 0.0); + bool bOnAxis(false); + + switch(GetDragHdlKind()) + { + case SdrHdlKind::UpperLeft: aLocalStart.setX(1.0); aLocalStart.setY(1.0); break; + case SdrHdlKind::Upper: aLocalStart.setX(0.5); aLocalStart.setY(1.0); bOnAxis = true; break; + case SdrHdlKind::UpperRight: aLocalStart.setX(0.0); aLocalStart.setY(1.0); break; + case SdrHdlKind::Left : aLocalStart.setX(1.0); aLocalStart.setY(0.5); bOnAxis = true; break; + case SdrHdlKind::Right: aLocalStart.setX(0.0); aLocalStart.setY(0.5); bOnAxis = true; break; + case SdrHdlKind::LowerLeft: aLocalStart.setX(1.0); aLocalStart.setY(0.0); break; + case SdrHdlKind::Lower: aLocalStart.setX(0.5); aLocalStart.setY(0.0); bOnAxis = true; break; + case SdrHdlKind::LowerRight: aLocalStart.setX(0.0); aLocalStart.setY(0.0); break; + default: break; + } + + // create the current drag position in unit coordinates. To get there, + // transform back the DragPoint to UnitCoordinates + basegfx::B2DHomMatrix aInverse(aOriginalMatrix); + aInverse.invert(); + basegfx::B2DPoint aLocalCurrent(aInverse * basegfx::B2DPoint(DragStat().GetNow().X(), DragStat().GetNow().Y())); + + // if one of the edge handles is used, limit to X or Y drag only + if(bOnAxis) + { + if(basegfx::fTools::equal(aLocalStart.getX(), 0.5)) + { + aLocalCurrent.setX(aLocalStart.getX()); + } + else + { + aLocalCurrent.setY(aLocalStart.getY()); + } + } + + // create internal change in unit coordinates + basegfx::B2DHomMatrix aDiscreteChangeMatrix; + + if(!basegfx::fTools::equal(aLocalCurrent.getX(), aLocalStart.getX())) + { + if(aLocalStart.getX() < 0.5) + { + aDiscreteChangeMatrix.scale(aLocalCurrent.getX(), 1.0); + } + else + { + aDiscreteChangeMatrix.scale(1.0 - aLocalCurrent.getX(), 1.0); + aDiscreteChangeMatrix.translate(aLocalCurrent.getX(), 0.0); + } + } + + if(!basegfx::fTools::equal(aLocalCurrent.getY(), aLocalStart.getY())) + { + if(aLocalStart.getY() < 0.5) + { + aDiscreteChangeMatrix.scale(1.0, aLocalCurrent.getY()); + } + else + { + aDiscreteChangeMatrix.scale(1.0, 1.0 - aLocalCurrent.getY()); + aDiscreteChangeMatrix.translate(0.0, aLocalCurrent.getY()); + } + } + + // We now have the whole executed Crop in UnitCoordinates in + // aDiscreteChangeMatrix, go to concrete sizes now. + // Create the unrotated original rectangle and the unrotated modified + // rectangle as Ranges + const basegfx::utils::B2DHomMatrixBufferedDecompose aOriginalMatrixDecomp(aOriginalMatrix); + + // prepare unsheared/unrotated versions of the old and new transformation + const basegfx::B2DHomMatrix aOriginalMatrixNoShearNoRotate( + basegfx::utils::createScaleTranslateB2DHomMatrix( + basegfx::absolute(aOriginalMatrixDecomp.getScale()), + aOriginalMatrixDecomp.getTranslate())); + + // create the ranges for these + basegfx::B2DRange aRangeOriginalNoShearNoRotate(0.0, 0.0, 1.0, 1.0); + basegfx::B2DRange aRangeNewNoShearNoRotate(0.0, 0.0, 1.0, 1.0); + aRangeOriginalNoShearNoRotate.transform(aOriginalMatrixNoShearNoRotate); + aRangeNewNoShearNoRotate.transform(aOriginalMatrixNoShearNoRotate * aDiscreteChangeMatrix); + + if(bExternal) + { + // With aLocalStart point (opposed to dragged point), X scale and Y scale, + // we call crop (virtual method) on pSdrObject which calls VirtFlyDrawObj + // crop. Use aLocalStart unchanged, so being relative to the Crop-Action, + // the called instance knows best how to use it + const double fScaleX(aRangeNewNoShearNoRotate.getWidth() / aRangeOriginalNoShearNoRotate.getWidth()); + const double fScaleY(aRangeNewNoShearNoRotate.getHeight() / aRangeOriginalNoShearNoRotate.getHeight()); + + pExternalSdrObject->Crop( + aLocalStart, + fScaleX, + fScaleY); + } + else + { + // prepare matrix to apply to object; evtl. back-correct shear + basegfx::B2DHomMatrix aNewObjectMatrix(aOriginalMatrix * aDiscreteChangeMatrix); + + if(bShearCorrected) + { + // back-correct shear + const basegfx::utils::B2DHomMatrixBufferedDecompose aTmpDecomp(aNewObjectMatrix); + + aNewObjectMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aTmpDecomp.getScale(), + -aTmpDecomp.getShearX(), + aTmpDecomp.getRotate(), + aTmpDecomp.getTranslate()); + } + + // apply change to object by applying the unit coordinate change followed + // by the original change + pObj->TRSetBaseGeometry(aNewObjectMatrix, aPolyPolygon); + + // extract the old Rectangle structures + tools::Rectangle aOldRect( + basegfx::fround(aRangeOriginalNoShearNoRotate.getMinX()), + basegfx::fround(aRangeOriginalNoShearNoRotate.getMinY()), + basegfx::fround(aRangeOriginalNoShearNoRotate.getMaxX()), + basegfx::fround(aRangeOriginalNoShearNoRotate.getMaxY())); + tools::Rectangle aNewRect( + basegfx::fround(aRangeNewNoShearNoRotate.getMinX()), + basegfx::fround(aRangeNewNoShearNoRotate.getMinY()), + basegfx::fround(aRangeNewNoShearNoRotate.getMaxX()), + basegfx::fround(aRangeNewNoShearNoRotate.getMaxY())); + + // continue with the old original stuff + if (!aOldRect.GetWidth() || !aOldRect.GetHeight()) + { + throw o3tl::divide_by_zero(); + } + + if((pObj->GetGraphicType() == GraphicType::NONE) || (pObj->GetGraphicType() == GraphicType::Default)) + { + return false; + } + + const GraphicObject& rGraphicObject(pObj->GetGraphicObject()); + // tdf#117145 Usually Writer will go the bExternal path (see above), but more correct for + // the future is to use the MapMode from the SdrModel/SfxItemPool if the Writer's current + // special handling should be unified to this path in the future. Usually it *should* be + // MapUnit::Map100thMM, but better do not mix up Units. + // Checked now what SwVirtFlyDrawObj::NbcCrop is doing - it calculates everything forced + // to MapUnit::Map100thMM, but extracts/packs Twips to the used SdrGrafCropItem in Writer. + const MapMode aMapModePool(pObj->getSdrModelFromSdrObject().GetItemPool().GetMetric(0)); + Size aGraphicSize(rGraphicObject.GetPrefSize()); + + if(MapUnit::MapPixel == rGraphicObject.GetPrefMapMode().GetMapUnit()) + { + aGraphicSize = Application::GetDefaultDevice()->PixelToLogic(aGraphicSize, aMapModePool); + } + else + { + aGraphicSize = OutputDevice::LogicToLogic(aGraphicSize, rGraphicObject.GetPrefMapMode(), aMapModePool); + } + + if(0 == aGraphicSize.Width() || 0 == aGraphicSize.Height()) + { + return false; + } + + const SdrGrafCropItem& rOldCrop = pObj->GetMergedItem(SDRATTR_GRAFCROP); + double fScaleX = ( aGraphicSize.Width() - rOldCrop.GetLeft() - rOldCrop.GetRight() ) / static_cast(aOldRect.GetWidth()); + double fScaleY = ( aGraphicSize.Height() - rOldCrop.GetTop() - rOldCrop.GetBottom() ) / static_cast(aOldRect.GetHeight()); + + sal_Int32 nDiffLeft = aNewRect.Left() - aOldRect.Left(); + sal_Int32 nDiffTop = aNewRect.Top() - aOldRect.Top(); + sal_Int32 nDiffRight = aNewRect.Right() - aOldRect.Right(); + sal_Int32 nDiffBottom = aNewRect.Bottom() - aOldRect.Bottom(); + + if(pObj->IsMirrored()) + { + // mirrored X or Y, for old stuff, exchange X + // check for aw080 + sal_Int32 nTmp(nDiffLeft); + nDiffLeft = -nDiffRight; + nDiffRight = -nTmp; + } + + sal_Int32 nLeftCrop = static_cast( rOldCrop.GetLeft() + nDiffLeft * fScaleX ); + sal_Int32 nTopCrop = static_cast( rOldCrop.GetTop() + nDiffTop * fScaleY ); + sal_Int32 nRightCrop = static_cast( rOldCrop.GetRight() - nDiffRight * fScaleX ); + sal_Int32 nBottomCrop = static_cast( rOldCrop.GetBottom() - nDiffBottom * fScaleY ); + + SfxItemPool& rPool = getSdrDragView().GetModel().GetItemPool(); + SfxItemSetFixed aSet( rPool ); + aSet.Put( SdrGrafCropItem( nLeftCrop, nTopCrop, nRightCrop, nBottomCrop ) ); + getSdrDragView().SetAttributes( aSet, false ); + } + + if(bUndo) + { + getSdrDragView().EndUndo(); + } + + return true; +} + +PointerStyle SdrDragCrop::GetSdrDragPointer() const +{ + return PointerStyle::Crop; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svddrgv.cxx b/svx/source/svdraw/svddrgv.cxx new file mode 100644 index 0000000000..8b9567c20b --- /dev/null +++ b/svx/source/svdraw/svddrgv.cxx @@ -0,0 +1,920 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "svddrgm1.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace sdr; + +SdrDragView::SdrDragView(SdrModel& rSdrModel, OutputDevice* pOut) + : SdrExchangeView(rSdrModel, pOut) + , mpDragHdl(nullptr) + , mpInsPointUndo(nullptr) + , meDragHdl(SdrHdlKind::Move) + , mnDragThresholdPixels(6) + , mbFramDrag(false) + , mbMarkedHitMovesAlways(false) + , mbDragLimit(false) + , mbDragHdl(false) + , mbDragStripes(false) + , mbSolidDragging(utl::ConfigManager::IsFuzzing() || SvtOptionsDrawinglayer::IsSolidDragCreate()) + , mbResizeAtCenter(false) + , mbCrookAtCenter(false) + , mbDragWithCopy(false) + , mbInsGluePoint(false) + , mbInsObjPointMode(false) + , mbInsGluePointMode(false) + , mbNoDragXorPolys(false) +{ + meDragMode = SdrDragMode::Move; +} + +SdrDragView::~SdrDragView() +{ +} + +bool SdrDragView::IsAction() const +{ + return (mpCurrentSdrDragMethod || SdrExchangeView::IsAction()); +} + +void SdrDragView::MovAction(const Point& rPnt) +{ + SdrExchangeView::MovAction(rPnt); + if (mpCurrentSdrDragMethod) + { + MovDragObj(rPnt); + } +} + +void SdrDragView::EndAction() +{ + if (mpCurrentSdrDragMethod) + { + EndDragObj(); + } + SdrExchangeView::EndAction(); +} + +void SdrDragView::BckAction() +{ + SdrExchangeView::BckAction(); + BrkDragObj(); +} + +void SdrDragView::BrkAction() +{ + SdrExchangeView::BrkAction(); + BrkDragObj(); +} + +void SdrDragView::TakeActionRect(tools::Rectangle& rRect) const +{ + if (mpCurrentSdrDragMethod) + { + rRect=maDragStat.GetActionRect(); + if (rRect.IsEmpty()) + { + SdrPageView* pPV = GetSdrPageView(); + + if(pPV&& pPV->HasMarkedObjPageView()) + { + // #i95646# is this used..? + const basegfx::B2DRange aBoundRange(mpCurrentSdrDragMethod->getCurrentRange()); + if (aBoundRange.isEmpty()) + { + rRect.SetEmpty(); + } + else + { + rRect = tools::Rectangle( + basegfx::fround(aBoundRange.getMinX()), basegfx::fround(aBoundRange.getMinY()), + basegfx::fround(aBoundRange.getMaxX()), basegfx::fround(aBoundRange.getMaxY())); + } + } + } + if (rRect.IsEmpty()) + { + rRect=tools::Rectangle(maDragStat.GetNow(),maDragStat.GetNow()); + } + } + else + { + SdrExchangeView::TakeActionRect(rRect); + } +} + +bool SdrDragView::TakeDragObjAnchorPos(Point& rPos, bool bTR ) const +{ + tools::Rectangle aR; + TakeActionRect(aR); + rPos = bTR ? aR.TopRight() : aR.TopLeft(); + if (GetMarkedObjectCount()==1 && IsDragObj() && // only on single selection + !IsDraggingPoints() && !IsDraggingGluePoints() && // not when moving points + dynamic_cast( mpCurrentSdrDragMethod.get() ) == nullptr) // not when moving handles + { + SdrObject* pObj=GetMarkedObjectByIndex(0); + if (auto pCaptionObj = dynamic_cast(pObj)) + { + Point aPt(pCaptionObj->GetTailPos()); + bool bTail=meDragHdl==SdrHdlKind::Poly; // drag tail + bool bOwn=dynamic_cast( mpCurrentSdrDragMethod.get() ) != nullptr; // specific to object + if (!bTail) + { // for bTail, TakeActionRect already does the right thing + if (bOwn) + { // bOwn may be MoveTextFrame, ResizeTextFrame, but may not (any more) be DragTail + rPos=aPt; + } + else + { + // drag the whole Object (Move, Resize, ...) + const basegfx::B2DPoint aTransformed(mpCurrentSdrDragMethod->getCurrentTransformation() * basegfx::B2DPoint(aPt.X(), aPt.Y())); + rPos.setX( basegfx::fround(aTransformed.getX()) ); + rPos.setY( basegfx::fround(aTransformed.getY()) ); + } + } + } + return true; + } + return false; +} + + +bool SdrDragView::TakeDragLimit(SdrDragMode /*eMode*/, tools::Rectangle& /*rRect*/) const +{ + return false; +} + +bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl, short nMinMov, SdrDragMethod* _pForcedMeth) +{ + BrkAction(); + + // so we don't leak the object on early return + std::unique_ptr pForcedMeth(_pForcedMeth); + + bool bRet=false; + { + SetDragWithCopy(false); + //TODO: aAni.Reset(); + mpCurrentSdrDragMethod=nullptr; + SdrDragMode eTmpMode=meDragMode; + if (eTmpMode==SdrDragMode::Move && pHdl!=nullptr && pHdl->GetKind()!=SdrHdlKind::Move) { + eTmpMode=SdrDragMode::Resize; + } + mbDragLimit=TakeDragLimit(eTmpMode,maDragLimit); + mbFramDrag=ImpIsFrameHandles(); + if (!mbFramDrag && + (mpMarkedObj==nullptr || !mpMarkedObj->hasSpecialDrag()) && + (pHdl==nullptr || pHdl->GetObj()==nullptr)) { + mbFramDrag=true; + } + + Point aPnt(rPnt); + basegfx::B2DVector aGridOffset(0.0, 0.0); + + // Coordinate maybe affected by GridOffset, so we may need to + // adapt to Model-coordinates here + if((comphelper::LibreOfficeKit::isActive() && mpMarkedObj + && getPossibleGridOffsetForSdrObject(aGridOffset, GetMarkedObjectByIndex(0), GetSdrPageView())) + || (getPossibleGridOffsetForPosition( + aGridOffset, + basegfx::B2DPoint(aPnt.X(), aPnt.Y()), + GetSdrPageView()))) + { + aPnt.AdjustX(basegfx::fround(-aGridOffset.getX())); + aPnt.AdjustY(basegfx::fround(-aGridOffset.getY())); + } + + if(pHdl == nullptr + || pHdl->GetKind() == SdrHdlKind::Move + || pHdl->GetKind() == SdrHdlKind::MirrorAxis + || pHdl->GetKind() == SdrHdlKind::Transparence + || pHdl->GetKind() == SdrHdlKind::Gradient) + { + maDragStat.Reset(aPnt); + } + else + { + maDragStat.Reset(pHdl->GetPos()); + } + + maDragStat.SetView(static_cast(this)); + maDragStat.SetPageView(mpMarkedPV); // <<-- DragPV has to go here!!! + maDragStat.SetMinMove(ImpGetMinMovLogic(nMinMov,pOut)); + maDragStat.SetHdl(pHdl); + maDragStat.NextPoint(); + mpDragWin=pOut; + mpDragHdl=pHdl; + meDragHdl= pHdl==nullptr ? SdrHdlKind::Move : pHdl->GetKind(); + mbDragHdl=meDragHdl==SdrHdlKind::Ref1 || meDragHdl==SdrHdlKind::Ref2 || meDragHdl==SdrHdlKind::MirrorAxis; + + // Expand test for SdrHdlKind::Anchor_TR + bool bNotDraggable = (SdrHdlKind::Anchor == meDragHdl || SdrHdlKind::Anchor_TR == meDragHdl); + + if(pHdl && (pHdl->GetKind() == SdrHdlKind::SmartTag) && pForcedMeth ) + { + // just use the forced method for smart tags + } + else if(mbDragHdl) + { + mpCurrentSdrDragMethod.reset(new SdrDragMovHdl(*this)); + } + else if(!bNotDraggable) + { + switch (meDragMode) + { + case SdrDragMode::Rotate: case SdrDragMode::Shear: + { + switch (meDragHdl) + { + case SdrHdlKind::Left: case SdrHdlKind::Right: + case SdrHdlKind::Upper: case SdrHdlKind::Lower: + { + // are 3D objects selected? + bool b3DObjSelected = false; + for(size_t a=0; !b3DObjSelected && a(mpMarkedObj)->IsTextFrame() ) + bSingleTextObjMark = true; + } + if ( bSingleTextObjMark ) + mpCurrentSdrDragMethod.reset( new SdrDragObjOwn(*this) ); + else + mpCurrentSdrDragMethod.reset( new SdrDragResize(*this) ); + } + } + else + { + if(SdrHdlKind::Move == meDragHdl) + { + const bool bCustomShapeSelected(1 == GetMarkedObjectCount() && dynamic_cast(GetMarkedObjectByIndex(0)) != nullptr); + + if(bCustomShapeSelected) + { + mpCurrentSdrDragMethod.reset( new SdrDragMove( *this ) ); + } + } + else if(SdrHdlKind::Poly == meDragHdl) + { + const bool bConnectorSelected(1 == GetMarkedObjectCount() && dynamic_cast(GetMarkedObjectByIndex(0)) != nullptr); + + if(bConnectorSelected) + { + // #i97784# + // fallback to old behaviour for connectors (see + // text in task description for more details) + } + else if(!IsMoveAllowed() || !IsResizeAllowed()) + { + // #i77187# + // do not allow move of polygon points if object is move or size protected + return false; + } + } + + if(!mpCurrentSdrDragMethod) + { + // fallback to DragSpecial if no interaction defined + mpCurrentSdrDragMethod.reset( new SdrDragObjOwn(*this) ); + } + } + } + } + } + } + if (pForcedMeth) + { + mpCurrentSdrDragMethod = std::move(pForcedMeth); + } + maDragStat.SetDragMethod(mpCurrentSdrDragMethod.get()); + if (mpCurrentSdrDragMethod) + { + bRet = mpCurrentSdrDragMethod->BeginSdrDrag(); + if (!bRet) + { + if (pHdl==nullptr && dynamic_cast< const SdrDragObjOwn* >(mpCurrentSdrDragMethod.get()) != nullptr) + { + // Obj may not Move SpecialDrag, so try with MoveFrameDrag + mpCurrentSdrDragMethod.reset(); + + if (!IsMoveAllowed()) + return false; + + mbFramDrag=true; + mpCurrentSdrDragMethod.reset( new SdrDragMove(*this) ); + maDragStat.SetDragMethod(mpCurrentSdrDragMethod.get()); + bRet = mpCurrentSdrDragMethod->BeginSdrDrag(); + } + } + if (!bRet) + { + mpCurrentSdrDragMethod.reset(); + maDragStat.SetDragMethod(mpCurrentSdrDragMethod.get()); + } + } + } + + return bRet; +} + +void SdrDragView::MovDragObj(const Point& rPnt) +{ + if (!mpCurrentSdrDragMethod) + return; + + Point aPnt(rPnt); + basegfx::B2DVector aGridOffset(0.0, 0.0); + + // Coordinate maybe affected by GridOffset, so we may need to + // adapt to Model-coordinates here + if((comphelper::LibreOfficeKit::isActive() && mpMarkedObj + && getPossibleGridOffsetForSdrObject(aGridOffset, GetMarkedObjectByIndex(0), GetSdrPageView())) + || (getPossibleGridOffsetForPosition( + aGridOffset, + basegfx::B2DPoint(aPnt.X(), aPnt.Y()), + GetSdrPageView()))) + { + aPnt.AdjustX(basegfx::fround(-aGridOffset.getX())); + aPnt.AdjustY(basegfx::fround(-aGridOffset.getY())); + } + + ImpLimitToWorkArea(aPnt); + mpCurrentSdrDragMethod->MoveSdrDrag(aPnt); // this call already makes a Hide()/Show combination +} + +bool SdrDragView::EndDragObj(bool bCopy) +{ + bool bRet(false); + + // #i73341# If inserting GluePoint, do not insist on last points being different + if(mpCurrentSdrDragMethod && maDragStat.IsMinMoved() && (IsInsertGluePoint() || maDragStat.GetNow() != maDragStat.GetPrev())) + { + sal_Int32 nSavedHdlCount=0; + + if (bEliminatePolyPoints) + { + nSavedHdlCount=GetMarkablePointCount(); + } + + const bool bUndo = IsUndoEnabled(); + if (IsInsertGluePoint() && bUndo) + { + BegUndo(maInsPointUndoStr); + AddUndo(std::unique_ptr(mpInsPointUndo)); + } + + bRet = mpCurrentSdrDragMethod->EndSdrDrag(bCopy); + + if( IsInsertGluePoint() && bUndo) + EndUndo(); + + mpCurrentSdrDragMethod.reset(); + + if (bEliminatePolyPoints) + { + if (nSavedHdlCount!=GetMarkablePointCount()) + { + UnmarkAllPoints(); + } + } + + if (mbInsPolyPoint) + { + SetMarkHandles(nullptr); + mbInsPolyPoint=false; + if( bUndo ) + { + BegUndo(maInsPointUndoStr); + AddUndo(std::unique_ptr(mpInsPointUndo)); + EndUndo(); + } + } + + meDragHdl=SdrHdlKind::Move; + mpDragHdl=nullptr; + + if (!mbSomeObjChgdFlag) + { + // Obj did not broadcast (e. g. Writer FlyFrames) + if(!mbDragHdl) + { + AdjustMarkHdl(); + } + } + } + else + { + BrkDragObj(); + } + + mbInsPolyPoint=false; + SetInsertGluePoint(false); + + return bRet; +} + +void SdrDragView::BrkDragObj() +{ + if (!mpCurrentSdrDragMethod) + return; + + mpCurrentSdrDragMethod->CancelSdrDrag(); + + mpCurrentSdrDragMethod.reset(); + + if (mbInsPolyPoint) + { + mpInsPointUndo->Undo(); // delete inserted point again + delete mpInsPointUndo; + mpInsPointUndo=nullptr; + SetMarkHandles(nullptr); + mbInsPolyPoint=false; + } + + if (IsInsertGluePoint()) + { + mpInsPointUndo->Undo(); // delete inserted gluepoint again + delete mpInsPointUndo; + mpInsPointUndo=nullptr; + SetInsertGluePoint(false); + } + + meDragHdl=SdrHdlKind::Move; + mpDragHdl=nullptr; +} + +bool SdrDragView::IsInsObjPointPossible() const +{ + return mpMarkedObj!=nullptr && mpMarkedObj->IsPolyObj(); +} + +bool SdrDragView::ImpBegInsObjPoint(bool bIdxZwang, const Point& rPnt, bool bNewObj, OutputDevice* pOut) +{ + bool bRet(false); + + if(auto pMarkedPath = dynamic_cast( mpMarkedObj)) + { + BrkAction(); + mpInsPointUndo = dynamic_cast(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*mpMarkedObj).release()); + DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" ); + + OUString aStr(SvxResId(STR_DragInsertPoint)); + + maInsPointUndoStr = aStr.replaceFirst("%1", mpMarkedObj->TakeObjNameSingul() ); + + Point aPt(rPnt); + + if(bNewObj) + aPt = GetSnapPos(aPt,mpMarkedPV); + + bool bClosed0 = pMarkedPath->IsClosedObj(); + + const sal_uInt32 nInsPointNum { bIdxZwang + ? pMarkedPath->NbcInsPoint(aPt, bNewObj) + : pMarkedPath->NbcInsPointOld(aPt, bNewObj) + }; + + if(bClosed0 != pMarkedPath->IsClosedObj()) + { + // Obj was closed implicitly + // object changed + pMarkedPath->SetChanged(); + pMarkedPath->BroadcastObjectChange(); + } + + if (nInsPointNum != SAL_MAX_UINT32) + { + mbInsPolyPoint = true; + UnmarkAllPoints(); + AdjustMarkHdl(); + + bRet = BegDragObj(rPnt, pOut, maHdlList.GetHdl(nInsPointNum), 0); + + if (bRet) + { + maDragStat.SetMinMoved(); + MovDragObj(rPnt); + } + } + else + { + delete mpInsPointUndo; + mpInsPointUndo = nullptr; + } + } + + return bRet; +} + +bool SdrDragView::EndInsObjPoint(SdrCreateCmd eCmd) +{ + if(IsInsObjPoint()) + { + Point aPnt(maDragStat.GetNow()); + bool bOk=EndDragObj(); + if (bOk && eCmd!=SdrCreateCmd::ForceEnd) + { + // Ret=True means: Action is over. + bOk = ! ImpBegInsObjPoint(true, aPnt, eCmd == SdrCreateCmd::NextObject, mpDragWin); + } + + return bOk; + } else return false; +} + +bool SdrDragView::IsInsGluePointPossible() const +{ + bool bRet=false; + if (IsInsGluePointMode() && AreObjectsMarked()) + { + if (GetMarkedObjectCount()==1) + { + // return sal_False, if only 1 object which is a connector. + const SdrObject* pObj=GetMarkedObjectByIndex(0); + if (dynamic_cast(pObj) == nullptr) + { + bRet=true; + } + } + else + { + bRet=true; + } + } + return bRet; +} + +bool SdrDragView::BegInsGluePoint(const Point& rPnt) +{ + bool bRet=false; + SdrObject* pObj; + SdrPageView* pPV; + if (PickMarkedObj(rPnt,pObj,pPV,SdrSearchOptions::PASS2BOUND)) + { + BrkAction(); + UnmarkAllGluePoints(); + mpInsPointUndo = dynamic_cast(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj).release()); + DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" ); + OUString aStr(SvxResId(STR_DragInsertGluePoint)); + + maInsPointUndoStr = aStr.replaceFirst("%1", pObj->TakeObjNameSingul() ); + + SdrGluePointList* pGPL=pObj->ForceGluePointList(); + if (pGPL!=nullptr) + { + sal_uInt16 nGlueIdx=pGPL->Insert(SdrGluePoint()); + SdrGluePoint& rGP=(*pGPL)[nGlueIdx]; + sal_uInt16 nGlueId=rGP.GetId(); + rGP.SetAbsolutePos(rPnt,*pObj); + + SdrHdl* pHdl=nullptr; + if (MarkGluePoint(pObj,nGlueId,false)) + { + pHdl=GetGluePointHdl(pObj,nGlueId); + } + if (pHdl!=nullptr && pHdl->GetKind()==SdrHdlKind::Glue && pHdl->GetObj()==pObj && pHdl->GetObjHdlNum()==nGlueId) + { + SetInsertGluePoint(true); + bRet=BegDragObj(rPnt,nullptr,pHdl,0); + if (bRet) + { + maDragStat.SetMinMoved(); + MovDragObj(rPnt); + } + else + { + SetInsertGluePoint(false); + delete mpInsPointUndo; + mpInsPointUndo=nullptr; + } + } + else + { + OSL_FAIL("BegInsGluePoint(): GluePoint handle not found."); + } + } + else + { + // no gluepoints possible for this object (e. g. Edge) + SetInsertGluePoint(false); + delete mpInsPointUndo; + mpInsPointUndo=nullptr; + } + } + + return bRet; +} + +void SdrDragView::ShowDragObj() +{ + if(!mpCurrentSdrDragMethod || maDragStat.IsShown()) + return; + + // Changed for the GridOffset stuff: No longer iterate over + // SdrPaintWindow(s), but now over SdrPageWindow(s), so doing the + // same as the SdrHdl visualizations (see ::CreateB2dIAObject) do. + // This is needed to get access to an ObjectContact which is needed + // to evtl. process that GridOffset in CreateOverlayGeometry + SdrPageView* pPageView(GetSdrPageView()); + + if(nullptr != pPageView) + { + for(sal_uInt32 a(0); a < pPageView->PageWindowCount(); a++) + { + const SdrPageWindow& rPageWindow(*pPageView->GetPageWindow(a)); + const SdrPaintWindow& rPaintWindow(rPageWindow.GetPaintWindow()); + + if(rPaintWindow.OutputToWindow()) + { + const rtl::Reference& xOverlayManager( + rPaintWindow.GetOverlayManager()); + + if(xOverlayManager.is()) + { + mpCurrentSdrDragMethod->CreateOverlayGeometry( + *xOverlayManager, + rPageWindow.GetObjectContact()); + + // #i101679# Force changed overlay to be shown + xOverlayManager->flush(); + } + } + } + } + + maDragStat.SetShown(true); +} + +void SdrDragView::HideDragObj() +{ + if(mpCurrentSdrDragMethod && maDragStat.IsShown()) + { + mpCurrentSdrDragMethod->destroyOverlayGeometry(); + maDragStat.SetShown(false); + } +} + + +void SdrDragView::SetNoDragXorPolys(bool bOn) +{ + if (IsNoDragXorPolys()==bOn) + return; + + const bool bDragging(mpCurrentSdrDragMethod); + const bool bShown(bDragging && maDragStat.IsShown()); + + if(bShown) + { + HideDragObj(); + } + + mbNoDragXorPolys = bOn; + + if(bDragging) + { + // force recreation of drag content + mpCurrentSdrDragMethod->resetSdrDragEntries(); + } + + if(bShown) + { + ShowDragObj(); + } +} + +void SdrDragView::SetDragStripes(bool bOn) +{ + if (mpCurrentSdrDragMethod && maDragStat.IsShown()) + { + HideDragObj(); + mbDragStripes=bOn; + ShowDragObj(); + } + else + { + mbDragStripes=bOn; + } +} + +bool SdrDragView::IsOrthoDesired() const +{ + if( dynamic_cast< const SdrDragObjOwn* >( mpCurrentSdrDragMethod.get() ) + || dynamic_cast< const SdrDragResize* >(mpCurrentSdrDragMethod.get() )) + { + return m_bOrthoDesiredOnMarked; + } + + return false; +} + +void SdrDragView::SetMarkHandles(SfxViewShell* pOtherShell) +{ + if( mpDragHdl ) + mpDragHdl = nullptr; + + SdrExchangeView::SetMarkHandles(pOtherShell); +} + +void SdrDragView::SetSolidDragging(bool bOn) +{ + if(mbSolidDragging != bOn) + { + mbSolidDragging = bOn; + } +} + +bool SdrDragView::IsSolidDragging() const +{ + // allow each user to disable by having a local setting, but using AND for + // checking allowance + return mbSolidDragging && SvtOptionsDrawinglayer::IsSolidDragCreate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdedtv.cxx b/svx/source/svdraw/svdedtv.cxx new file mode 100644 index 0000000000..8c1c60bba6 --- /dev/null +++ b/svx/source/svdraw/svdedtv.cxx @@ -0,0 +1,1084 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace com::sun::star; + +void SdrEditView::ImpResetPossibilityFlags() +{ + m_bReadOnly =false; + + m_bGroupPossible =false; + m_bUnGroupPossible =false; + m_bGrpEnterPossible =false; + m_bToTopPossible =false; + m_bToBtmPossible =false; + m_bReverseOrderPossible =false; + + m_bImportMtfPossible =false; + m_bCombinePossible =false; + m_bDismantlePossible =false; + m_bCombineNoPolyPolyPossible =false; + m_bDismantleMakeLinesPossible=false; + m_bOrthoDesiredOnMarked =false; + + m_bOneOrMoreMovable =false; + m_bMoreThanOneNoMovRot =false; + m_bContortionPossible =false; + m_bMoveAllowed =false; + m_bResizeFreeAllowed =false; + m_bResizePropAllowed =false; + m_bRotateFreeAllowed =false; + m_bRotate90Allowed =false; + m_bMirrorFreeAllowed =false; + m_bMirror45Allowed =false; + m_bMirror90Allowed =false; + m_bTransparenceAllowed =false; + m_bCropAllowed =false; + m_bGradientAllowed =false; + m_bShearAllowed =false; + m_bEdgeRadiusAllowed =false; + m_bCanConvToPath =false; + m_bCanConvToPoly =false; + m_bCanConvToContour =false; + m_bMoveProtect =false; + m_bResizeProtect =false; +} + +SdrEditView::SdrEditView(SdrModel& rSdrModel, OutputDevice* pOut) + : SdrMarkView(rSdrModel, pOut) + , m_bPossibilitiesDirty(true) + , m_bReadOnly(false) + , m_bGroupPossible(false) + , m_bUnGroupPossible(false) + , m_bGrpEnterPossible(false) + , m_bToTopPossible(false) + , m_bToBtmPossible(false) + , m_bReverseOrderPossible(false) + , m_bImportMtfPossible(false) + , m_bCombinePossible(false) + , m_bDismantlePossible(false) + , m_bCombineNoPolyPolyPossible(false) + , m_bDismantleMakeLinesPossible(false) + , m_bOrthoDesiredOnMarked(false) + , m_bOneOrMoreMovable(false) + , m_bMoreThanOneNoMovRot(false) + , m_bContortionPossible(false) + , m_bMoveAllowed(false) + , m_bResizeFreeAllowed(false) + , m_bResizePropAllowed(false) + , m_bRotateFreeAllowed(false) + , m_bRotate90Allowed(false) + , m_bMirrorFreeAllowed(false) + , m_bMirror45Allowed(false) + , m_bMirror90Allowed(false) + , m_bShearAllowed(false) + , m_bEdgeRadiusAllowed(false) + , m_bTransparenceAllowed(false) + , m_bCropAllowed(false) + , m_bGradientAllowed(false) + , m_bCanConvToPath(false) + , m_bCanConvToPoly(false) + , m_bCanConvToContour(false) + , m_bMoveProtect(false) + , m_bResizeProtect(false) +{ +} + +SdrEditView::~SdrEditView() +{ +} + +void SdrEditView::InsertNewLayer(const OUString& rName, sal_uInt16 nPos) +{ + SdrLayerAdmin& rLA = GetModel().GetLayerAdmin(); + sal_uInt16 nMax=rLA.GetLayerCount(); + if (nPos>nMax) nPos=nMax; + rLA.NewLayer(rName,nPos); + + if( GetModel().IsUndoEnabled() ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewLayer(nPos,rLA, GetModel())); + + GetModel().SetChanged(); +} + +bool SdrEditView::ImpDelLayerCheck(SdrObjList const * pOL, SdrLayerID nDelID) const +{ + bool bDelAll(true); + + for(size_t nObjNum = pOL->GetObjCount(); nObjNum > 0 && bDelAll;) + { + nObjNum--; + SdrObject* pObj = pOL->GetObj(nObjNum); + SdrObjList* pSubOL = pObj->GetSubList(); + + // explicitly test for group objects and 3d scenes + if(pSubOL && (dynamic_cast(pObj) != nullptr || DynCastE3dScene(pObj))) + { + if(!ImpDelLayerCheck(pSubOL, nDelID)) + { + bDelAll = false; + } + } + else + { + if(pObj->GetLayer() != nDelID) + { + bDelAll = false; + } + } + } + + return bDelAll; +} + +void SdrEditView::ImpDelLayerDelObjs(SdrObjList* pOL, SdrLayerID nDelID) +{ + const size_t nObjCount(pOL->GetObjCount()); + // make sure OrdNums are correct + pOL->GetObj(0)->GetOrdNum(); + + const bool bUndo = GetModel().IsUndoEnabled(); + + for(size_t nObjNum = nObjCount; nObjNum > 0;) + { + nObjNum--; + SdrObject* pObj = pOL->GetObj(nObjNum); + SdrObjList* pSubOL = pObj->GetSubList(); + + + // explicitly test for group objects and 3d scenes + if(pSubOL && (dynamic_cast( pObj) != nullptr || DynCastE3dScene(pObj))) + { + if(ImpDelLayerCheck(pSubOL, nDelID)) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true)); + pOL->RemoveObject(nObjNum); + } + else + { + ImpDelLayerDelObjs(pSubOL, nDelID); + } + } + else + { + if(pObj->GetLayer() == nDelID) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true)); + pOL->RemoveObject(nObjNum); + } + } + } +} + +void SdrEditView::DeleteLayer(const OUString& rName) +{ + SdrLayerAdmin& rLA = GetModel().GetLayerAdmin(); + SdrLayer* pLayer = rLA.GetLayer(rName); + + if(!pLayer) + return; + + sal_uInt16 nLayerNum(rLA.GetLayerPos(pLayer)); + SdrLayerID nDelID = pLayer->GetID(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_UndoDelLayer)); + + bool bMaPg(true); + + for(sal_uInt16 nPageKind(0); nPageKind < 2; nPageKind++) + { + // MasterPages and DrawPages + sal_uInt16 nPgCount(bMaPg ? GetModel().GetMasterPageCount() : GetModel().GetPageCount()); + + for(sal_uInt16 nPgNum(0); nPgNum < nPgCount; nPgNum++) + { + // over all pages + SdrPage* pPage = bMaPg ? GetModel().GetMasterPage(nPgNum) : GetModel().GetPage(nPgNum); + const size_t nObjCount(pPage->GetObjCount()); + + // make sure OrdNums are correct + if(nObjCount) + pPage->GetObj(0)->GetOrdNum(); + + for(size_t nObjNum(nObjCount); nObjNum > 0;) + { + nObjNum--; + SdrObject* pObj = pPage->GetObj(nObjNum); + SdrObjList* pSubOL = pObj->GetSubList(); + + // explicitly test for group objects and 3d scenes + if(pSubOL && (dynamic_cast(pObj) != nullptr || DynCastE3dScene(pObj))) + { + if(ImpDelLayerCheck(pSubOL, nDelID)) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true)); + pPage->RemoveObject(nObjNum); + } + else + { + ImpDelLayerDelObjs(pSubOL, nDelID); + } + } + else + { + if(pObj->GetLayer() == nDelID) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj, true)); + pPage->RemoveObject(nObjNum); + } + } + } + } + bMaPg = false; + } + + if( bUndo ) + { + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteLayer(nLayerNum, rLA, GetModel())); + // coverity[leaked_storage] - ownership transferred to UndoDeleteLayer + rLA.RemoveLayer(nLayerNum).release(); + EndUndo(); + } + else + { + rLA.RemoveLayer(nLayerNum); + } + + GetModel().SetChanged(); +} + + +void SdrEditView::EndUndo() +{ + // #i13033# + // Comparison changed to 1L since EndUndo() is called later now + // and EndUndo WILL change count to count-1 + if(1 == GetModel().GetUndoBracketLevel()) + { + ImpBroadcastEdgesOfMarkedNodes(); + } + + // #i13033# + // moved to bottom to still have access to UNDOs inside of + // ImpBroadcastEdgesOfMarkedNodes() + GetModel().EndUndo(); +} + +void SdrEditView::ImpBroadcastEdgesOfMarkedNodes() +{ + std::vector::const_iterator iterPos; + const std::vector& rAllMarkedObjects = GetTransitiveHullOfMarkedObjects(); + + // #i13033# + // New mechanism to search for necessary disconnections for + // changed connectors inside the transitive hull of all at + // the beginning of UNDO selected objects + for(size_t a(0); a < rAllMarkedObjects.size(); a++) + { + SdrEdgeObj* pEdge = dynamic_cast( rAllMarkedObjects[a] ); + + if(pEdge) + { + SdrObject* pObj1 = pEdge->GetConnectedNode(false); + SdrObject* pObj2 = pEdge->GetConnectedNode(true); + + if(pObj1 && !pEdge->CheckNodeConnection(false)) + { + iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj1); + + if (iterPos == rAllMarkedObjects.end()) + { + if( IsUndoEnabled() ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pEdge)); + pEdge->DisconnectFromNode(false); + } + } + + if(pObj2 && !pEdge->CheckNodeConnection(true)) + { + iterPos = std::find(rAllMarkedObjects.begin(),rAllMarkedObjects.end(),pObj2); + + if (iterPos == rAllMarkedObjects.end()) + { + if( IsUndoEnabled() ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pEdge)); + pEdge->DisconnectFromNode(true); + } + } + } + } + + const size_t nMarkedEdgeCnt = GetMarkedEdgesOfMarkedNodes().GetMarkCount(); + + for (size_t i=0; iGetMarkedSdrObj(); + SdrEdgeObj* pEdge=dynamic_cast( pEdgeTmp ); + if (pEdge!=nullptr) { + pEdge->SetEdgeTrackDirty(); + } + } +} + + +// Possibilities + + +void SdrEditView::MarkListHasChanged() +{ + SdrMarkView::MarkListHasChanged(); + m_bPossibilitiesDirty=true; +} + +void SdrEditView::ModelHasChanged() +{ + SdrMarkView::ModelHasChanged(); + m_bPossibilitiesDirty=true; +} + +bool SdrEditView::IsResizeAllowed(bool bProp) const +{ + ForcePossibilities(); + if (m_bResizeProtect) return false; + if (bProp) return m_bResizePropAllowed; + return m_bResizeFreeAllowed; +} + +bool SdrEditView::IsRotateAllowed(bool b90Deg) const +{ + ForcePossibilities(); + if (m_bMoveProtect) return false; + if (b90Deg) return m_bRotate90Allowed; + return m_bRotateFreeAllowed; +} + +bool SdrEditView::IsMirrorAllowed(bool b45Deg, bool b90Deg) const +{ + ForcePossibilities(); + if (m_bMoveProtect) return false; + if (b90Deg) return m_bMirror90Allowed; + if (b45Deg) return m_bMirror45Allowed; + return m_bMirrorFreeAllowed; +} + +bool SdrEditView::IsTransparenceAllowed() const +{ + ForcePossibilities(); + return m_bTransparenceAllowed; +} + +bool SdrEditView::IsCropAllowed() const +{ + ForcePossibilities(); + return m_bCropAllowed; +} + +bool SdrEditView::IsGradientAllowed() const +{ + ForcePossibilities(); + return m_bGradientAllowed; +} + +bool SdrEditView::IsShearAllowed() const +{ + ForcePossibilities(); + if (m_bResizeProtect) return false; + return m_bShearAllowed; +} + +bool SdrEditView::IsEdgeRadiusAllowed() const +{ + ForcePossibilities(); + return m_bEdgeRadiusAllowed; +} + +bool SdrEditView::IsCrookAllowed(bool bNoContortion) const +{ + // CrookMode missing here (no rotations allowed when shearing ...) + ForcePossibilities(); + if (bNoContortion) { + if (!m_bRotateFreeAllowed) return false; + return !m_bMoveProtect && m_bMoveAllowed; + } else { + return !m_bResizeProtect && m_bContortionPossible; + } +} + +bool SdrEditView::IsDistortAllowed(bool bNoContortion) const +{ + ForcePossibilities(); + if (bNoContortion) { + return false; + } else { + return !m_bResizeProtect && m_bContortionPossible; + } +} + +bool SdrEditView::IsCombinePossible(bool bNoPolyPoly) const +{ + ForcePossibilities(); + if (bNoPolyPoly) return m_bCombineNoPolyPolyPossible; + else return m_bCombinePossible; +} + +bool SdrEditView::IsDismantlePossible(bool bMakeLines) const +{ + ForcePossibilities(); + if (bMakeLines) return m_bDismantleMakeLinesPossible; + else return m_bDismantlePossible; +} + +void SdrEditView::CheckPossibilities() +{ + if (mbSomeObjChgdFlag) + { + m_bPossibilitiesDirty = true; + + // This call IS necessary to correct the MarkList, in which + // no longer to the model belonging objects still can reside. + // These ones need to be removed. + CheckMarked(); + } + + if (!m_bPossibilitiesDirty) + return; + + ImpResetPossibilityFlags(); + SortMarkedObjects(); + const size_t nMarkCount = GetMarkedObjectCount(); + if (nMarkCount != 0) + { + m_bReverseOrderPossible = (nMarkCount >= 2); + + size_t nMovableCount=0; + m_bGroupPossible=nMarkCount>=2; + m_bCombinePossible=nMarkCount>=2; + if (nMarkCount==1) + { + // check bCombinePossible more thoroughly + // still missing ... + const SdrObject* pObj=GetMarkedObjectByIndex(0); + //const SdrPathObj* pPath=dynamic_cast( pObj ); + bool bGroup=pObj->GetSubList()!=nullptr; + bool bHasText=pObj->GetOutlinerParaObject()!=nullptr; + if (bGroup || bHasText) { + m_bCombinePossible=true; + } + } + m_bCombineNoPolyPolyPossible=m_bCombinePossible; + // accept transformations for now + m_bMoveAllowed =true; + m_bResizeFreeAllowed=true; + m_bResizePropAllowed=true; + m_bRotateFreeAllowed=true; + m_bRotate90Allowed =true; + m_bMirrorFreeAllowed=true; + m_bMirror45Allowed =true; + m_bMirror90Allowed =true; + m_bShearAllowed =true; + m_bEdgeRadiusAllowed=false; + m_bContortionPossible=true; + m_bCanConvToContour = true; + + // these ones are only allowed when single object is selected + m_bTransparenceAllowed = (nMarkCount == 1); + m_bGradientAllowed = (nMarkCount == 1); + m_bCropAllowed = (nMarkCount == 1); + if(m_bGradientAllowed) + { + // gradient depends on fill style + const SdrMark* pM = GetSdrMarkByIndex(0); + const SdrObject* pObj = pM->GetMarkedSdrObj(); + + // may be group object, so get merged ItemSet + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + SfxItemState eState = rSet.GetItemState(XATTR_FILLSTYLE, false); + + if(SfxItemState::DONTCARE != eState) + { + // If state is not DONTCARE, test the item + drawing::FillStyle eFillStyle = rSet.Get(XATTR_FILLSTYLE).GetValue(); + + if(eFillStyle != drawing::FillStyle_GRADIENT) + { + m_bGradientAllowed = false; + } + } + } + + bool bNoMovRotFound=false; + const SdrPageView* pPV0=nullptr; + + for (size_t nm=0; nmGetMarkedSdrObj(); + const SdrPageView* pPV=pM->GetPageView(); + if (pPV!=pPV0) { + if (pPV->IsReadOnly()) m_bReadOnly=true; + pPV0=pPV; + } + + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + bool bMovPrt=pObj->IsMoveProtect(); + bool bSizPrt=pObj->IsResizeProtect(); + if (!bMovPrt && aInfo.bMoveAllowed) nMovableCount++; // count MovableObjs + if (bMovPrt) m_bMoveProtect=true; + if (bSizPrt) m_bResizeProtect=true; + + // not allowed when not allowed at one object + if(!aInfo.bTransparenceAllowed) + m_bTransparenceAllowed = false; + + // If one of these can't do something, none can + if (!aInfo.bMoveAllowed ) m_bMoveAllowed =false; + if (!aInfo.bResizeFreeAllowed) m_bResizeFreeAllowed=false; + if (!aInfo.bResizePropAllowed) m_bResizePropAllowed=false; + if (!aInfo.bRotateFreeAllowed) m_bRotateFreeAllowed=false; + if (!aInfo.bRotate90Allowed ) m_bRotate90Allowed =false; + if (!aInfo.bMirrorFreeAllowed) m_bMirrorFreeAllowed=false; + if (!aInfo.bMirror45Allowed ) m_bMirror45Allowed =false; + if (!aInfo.bMirror90Allowed ) m_bMirror90Allowed =false; + if (!aInfo.bShearAllowed ) m_bShearAllowed =false; + if (aInfo.bEdgeRadiusAllowed) m_bEdgeRadiusAllowed=true; + if (aInfo.bNoContortion ) m_bContortionPossible=false; + // For Crook with Contortion: all objects have to be + // Movable and Rotatable, except for a maximum of 1 of them + if (!m_bMoreThanOneNoMovRot) { + if (!aInfo.bMoveAllowed || !aInfo.bResizeFreeAllowed) { + m_bMoreThanOneNoMovRot=bNoMovRotFound; + bNoMovRotFound=true; + } + } + + // Must be resizable to allow cropping + if (!aInfo.bResizeFreeAllowed && !aInfo.bResizePropAllowed) + m_bCropAllowed = false; + + // if one member cannot be converted, no conversion is possible + if(!aInfo.bCanConvToContour) + m_bCanConvToContour = false; + + // Ungroup + if (!m_bUnGroupPossible) m_bUnGroupPossible=pObj->GetSubList()!=nullptr; + // ConvertToCurve: If at least one can be converted, that is fine. + if (aInfo.bCanConvToPath ) m_bCanConvToPath =true; + if (aInfo.bCanConvToPoly ) m_bCanConvToPoly =true; + + // Combine/Dismantle + if(m_bCombinePossible) + { + m_bCombinePossible = ImpCanConvertForCombine(pObj); + m_bCombineNoPolyPolyPossible = m_bCombinePossible; + } + + if (!m_bDismantlePossible) m_bDismantlePossible = ImpCanDismantle(pObj, false); + if (!m_bDismantleMakeLinesPossible) m_bDismantleMakeLinesPossible = ImpCanDismantle(pObj, true); + // check OrthoDesiredOnMarked + if (!m_bOrthoDesiredOnMarked && !aInfo.bNoOrthoDesired) m_bOrthoDesiredOnMarked=true; + // check ImportMtf + + if (!m_bImportMtfPossible) + { + const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pObj); + if (pSdrGrafObj != nullptr) + { + if ((pSdrGrafObj->HasGDIMetaFile() && !pSdrGrafObj->IsEPS()) || + pSdrGrafObj->isEmbeddedVectorGraphicData()) + { + m_bImportMtfPossible = true; + } + } + + const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(pObj); + if (pSdrOle2Obj) + { + m_bImportMtfPossible = pSdrOle2Obj->GetObjRef().is(); + } + } + } + + m_bOneOrMoreMovable=nMovableCount!=0; + m_bGrpEnterPossible=m_bUnGroupPossible; + } + ImpCheckToTopBtmPossible(); + static_cast(this)->ImpCheckPolyPossibilities(); + m_bPossibilitiesDirty=false; + + if (m_bReadOnly) { + bool bTemp=m_bGrpEnterPossible; + ImpResetPossibilityFlags(); + m_bReadOnly=true; + m_bGrpEnterPossible=bTemp; + } + if (!m_bMoveAllowed) return; + + // Don't allow moving glued connectors. + // Currently only implemented for single selection. + if (nMarkCount==1) { + SdrObject* pObj=GetMarkedObjectByIndex(0); + SdrEdgeObj* pEdge=dynamic_cast( pObj ); + if (pEdge!=nullptr) { + SdrObject* pNode1=pEdge->GetConnectedNode(true); + SdrObject* pNode2=pEdge->GetConnectedNode(false); + if (pNode1!=nullptr || pNode2!=nullptr) m_bMoveAllowed=false; + } + } + + // Don't allow enter Diagrams + if (1 == nMarkCount && m_bGrpEnterPossible) + { + SdrObject* pCandidate(GetMarkedObjectByIndex(0)); + + if(nullptr != pCandidate && pCandidate->isDiagram()) + m_bGrpEnterPossible = false; + } +} + + +void SdrEditView::ForceMarkedObjToAnotherPage() +{ + bool bFlg=false; + for (size_t nm=0; nmGetMarkedSdrObj(); + tools::Rectangle aObjRect(pObj->GetCurrentBoundRect()); + tools::Rectangle aPgRect(pM->GetPageView()->GetPageRect()); + if (!aObjRect.Overlaps(aPgRect)) { + bool bFnd=false; + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + bFnd = aObjRect.Overlaps(pPV->GetPageRect()); + } + + if(bFnd) + { + pM->GetPageView()->GetObjList()->RemoveObject(pObj->GetOrdNum()); + pPV->GetObjList()->InsertObject(pObj, SAL_MAX_SIZE); + pM->SetPageView(pPV); + InvalidateAllWin(aObjRect); + bFlg=true; + } + } + } + if (bFlg) { + MarkListHasChanged(); + } +} + +std::vector> SdrEditView::DeleteMarkedList(SdrMarkList const& rMark) +{ + std::vector> ret; + if (rMark.GetMarkCount()!=0) + { + rMark.ForceSort(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(); + const size_t nMarkCount(rMark.GetMarkCount()); + + if(nMarkCount) + { + std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters; + + if( bUndo ) + { + for(size_t nm = nMarkCount; nm > 0;) + { + --nm; + SdrMark* pM = rMark.GetMark(nm); + SdrObject* pObj = pM->GetMarkedSdrObj(); + + // extra undo actions for changed connector which now may hold its laid out path (SJ) + AddUndoActions(CreateConnectorUndo( *pObj )); + + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); + } + } + + // make sure, OrderNums are correct: + rMark.GetMark(0)->GetMarkedSdrObj()->GetOrdNum(); + + for(size_t nm = nMarkCount; nm > 0;) + { + --nm; + SdrMark* pM = rMark.GetMark(nm); + SdrObject* pObj = pM->GetMarkedSdrObj(); + SdrObjList* pOL = pObj->getParentSdrObjListFromSdrObject(); + const size_t nOrdNum(pObj->GetOrdNumDirect()); + + bool bIs3D = DynCastE3dObject(pObj); + // set up a scene updater if object is a 3d object + if(bIs3D) + { + aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj)); + } + + if( !bUndo ) + { + // tdf#108863 and tdf#108889 don't delete objects before EndUndo() + ret.push_back(pObj); + } + + pOL->RemoveObject(nOrdNum); + } + + // fire scene updaters + while(!aUpdaters.empty()) + { + delete aUpdaters.back(); + aUpdaters.pop_back(); + } + } + + if( bUndo ) + EndUndo(); + } + return ret; +} + +static void lcl_LazyDelete(std::vector> & rLazyDelete) +{ + // now delete removed scene objects + while (!rLazyDelete.empty()) + rLazyDelete.pop_back(); +} + +void SdrEditView::DeleteMarkedObj() +{ + // #i110981# return when nothing is to be done at all + if(!GetMarkedObjectCount()) + { + return; + } + + // moved breaking action and undo start outside loop + BrkAction(); + BegUndo(SvxResId(STR_EditDelete),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::Delete); + + std::vector> lazyDeleteObjects; + // remove as long as something is selected. This allows to schedule objects for + // removal for a next run as needed + while(GetMarkedObjectCount()) + { + // vector to remember the parents which may be empty after object removal + std::vector< SdrObject* > aParents; + + { + const SdrMarkList& rMarkList = GetMarkedObjectList(); + const size_t nCount(rMarkList.GetMarkCount()); + + for(size_t a = 0; a < nCount; ++a) + { + // in the first run, add all found parents, but only once + SdrMark* pMark(rMarkList.GetMark(a)); + SdrObject* pObject(pMark->GetMarkedSdrObj()); + SdrObject* pParent(pObject->getParentSdrObjectFromSdrObject()); + + if(pParent) + { + if(!aParents.empty()) + { + std::vector< SdrObject* >::iterator aFindResult = + std::find(aParents.begin(), aParents.end(), pParent); + + if(aFindResult == aParents.end()) + { + aParents.push_back(pParent); + } + } + else + { + aParents.push_back(pParent); + } + } + } + + if(!aParents.empty()) + { + // in a 2nd run, remove all objects which may already be scheduled for + // removal. I am not sure if this can happen, but theoretically + // a to-be-removed object may already be the group/3DScene itself + for(size_t a = 0; a < nCount; ++a) + { + SdrMark* pMark = rMarkList.GetMark(a); + SdrObject* pObject = pMark->GetMarkedSdrObj(); + + std::vector< SdrObject* >::iterator aFindResult = + std::find(aParents.begin(), aParents.end(), pObject); + + if(aFindResult != aParents.end()) + { + aParents.erase(aFindResult); + } + } + } + } + + // original stuff: remove selected objects. Handle clear will + // do something only once + auto temp(DeleteMarkedList(GetMarkedObjectList())); + lazyDeleteObjects.insert(lazyDeleteObjects.end(), temp.begin(), temp.end()); + GetMarkedObjectListWriteAccess().Clear(); + maHdlList.Clear(); + + while(!aParents.empty() && !GetMarkedObjectCount()) + { + // iterate over remembered parents + SdrObject* pParent = aParents.back(); + aParents.pop_back(); + + if(pParent->GetSubList() && 0 == pParent->GetSubList()->GetObjCount()) + { + // we detected an empty parent, a candidate to leave group/3DScene + // if entered + if(GetSdrPageView()->GetCurrentGroup() + && GetSdrPageView()->GetCurrentGroup() == pParent) + { + GetSdrPageView()->LeaveOneGroup(); + } + + // schedule empty parent for removal + GetMarkedObjectListWriteAccess().InsertEntry( + SdrMark(pParent, GetSdrPageView())); + } + } + } + + // end undo and change messaging moved at the end + EndUndo(); + MarkListHasChanged(); + + lcl_LazyDelete(lazyDeleteObjects); +} + +void SdrEditView::CopyMarkedObj() +{ + SortMarkedObjects(); + + SdrMarkList aSourceObjectsForCopy(GetMarkedObjectList()); + // The following loop is used instead of MarkList::Merge(), to be + // able to flag the MarkEntries. + const size_t nEdgeCnt = GetEdgesOfMarkedNodes().GetMarkCount(); + for (size_t nEdgeNum=0; nEdgeNum aNameSet; + const size_t nMarkCount=aSourceObjectsForCopy.GetMarkCount(); + for (size_t nm=0; nmGetMarkedSdrObj()); + rtl::Reference pO(pSource->CloneSdrObject(pSource->getSdrModelFromSdrObject())); + if (pO!=nullptr) { + pM->GetPageView()->GetObjList()->InsertObjectThenMakeNameUnique(pO.get(), aNameSet); + + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoCopyObject(*pO)); + + SdrMark aME(*pM); + aME.SetMarkedSdrObj(pO.get()); + aCloneList.AddPair(pM->GetMarkedSdrObj(), pO.get()); + + if (pM->GetUser()==0) + { + // otherwise it is only an Edge we have to copy as well + GetMarkedObjectListWriteAccess().InsertEntry(aME); + } + } else { + nCloneErrCnt++; + } + } + + // #i13033# + // New mechanism to re-create the connections of cloned connectors + aCloneList.CopyConnections(); + + if(nCloneErrCnt) + { +#ifdef DBG_UTIL + OStringBuffer aStr("SdrEditView::CopyMarkedObj(): Error when cloning "); + + if(nCloneErrCnt == 1) + { + aStr.append("a drawing object."); + } + else + { + aStr.append(OString::number(static_cast(nCloneErrCnt)) + + " drawing objects."); + } + + aStr.append(" This object's/These objects's connections will not be copied."); + OSL_FAIL(aStr.getStr()); +#endif + } + MarkListHasChanged(); +} + + +bool SdrEditView::InsertObjectAtView(SdrObject* pObj, SdrPageView& rPV, SdrInsertFlags nOptions) +{ + if (nOptions & SdrInsertFlags::SETDEFLAYER) { + SdrLayerID nLayer=rPV.GetPage()->GetLayerAdmin().GetLayerID(maActualLayer); + if (nLayer==SDRLAYER_NOTFOUND) nLayer=SdrLayerID(0); + if (rPV.GetLockedLayers().IsSet(nLayer) || !rPV.GetVisibleLayers().IsSet(nLayer)) { + return false; + } + pObj->NbcSetLayer(nLayer); + } + if (nOptions & SdrInsertFlags::SETDEFATTR) { + if (mpDefaultStyleSheet!=nullptr) pObj->NbcSetStyleSheet(mpDefaultStyleSheet, false); + pObj->SetMergedItemSet(maDefaultAttr); + } + if (!pObj->IsInserted()) { + rPV.GetObjList()->InsertObject(pObj, SAL_MAX_SIZE); + } + + css::uno::Reference xServices(GetModel().getUnoModel(), + css::uno::UNO_QUERY); + if (xServices.is() && (xServices->supportsService("com.sun.star.sheet.SpreadsheetDocument") || + xServices->supportsService("com.sun.star.text.TextDocument"))) + { + const bool bUndo(IsUndoEnabled()); + GetModel().EnableUndo(false); + pObj->MakeNameUnique(); + GetModel().EnableUndo(bUndo); + } + + if( IsUndoEnabled()) + { + bool bDontDeleteReally = true; + EndTextEditCurrentView(bDontDeleteReally); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pObj)); + } + + if (!(nOptions & SdrInsertFlags::DONTMARK)) { + if (!(nOptions & SdrInsertFlags::ADDMARK)) UnmarkAllObj(); + MarkObj(pObj,&rPV); + } + return true; +} + +void SdrEditView::ReplaceObjectAtView(SdrObject* pOldObj, SdrPageView& rPV, SdrObject* pNewObj, bool bMark) +{ + if(IsTextEdit()) + { +#ifdef DBG_UTIL + if(auto pTextObj = DynCastSdrTextObj(pOldObj)) + if (pTextObj->IsTextEditActive()) + OSL_ENSURE(false, "OldObject is in TextEdit mode, this has to be ended before replacing it using SdrEndTextEdit (!)"); + + if(auto pTextObj = DynCastSdrTextObj(pNewObj)) + if (pTextObj->IsTextEditActive()) + OSL_ENSURE(false, "NewObject is in TextEdit mode, this has to be ended before replacing it using SdrEndTextEdit (!)"); +#endif + + // #i123468# emergency repair situation, needs to cast up to a class derived from + // this one; (aw080 has a mechanism for that and the view hierarchy is secured to + // always be a SdrView) + SdrView *pSdrView = dynamic_cast(this); + if (pSdrView) + pSdrView->SdrEndTextEdit(); + } + + SdrObjList* pOL=pOldObj->getParentSdrObjListFromSdrObject(); + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoReplaceObject(*pOldObj,*pNewObj)); + + if( IsObjMarked( pOldObj ) ) + MarkObj( pOldObj, &rPV, true /*unmark!*/ ); + + pOL->ReplaceObject(pNewObj,pOldObj->GetOrdNum()); + + if (bMark) MarkObj(pNewObj,&rPV); +} + + +bool SdrEditView::IsUndoEnabled() const +{ + return GetModel().IsUndoEnabled(); +} + +void SdrEditView::EndTextEditAllViews() const +{ + GetModel().ForAllListeners( + [](SfxListener* pListener) + { + SdrObjEditView* pView = dynamic_cast(pListener); + if (pView && pView->IsTextEdit()) + pView->SdrEndTextEdit(); + return false; + }); +} + +void SdrEditView::EndTextEditCurrentView(bool bDontDeleteReally) +{ + if (IsTextEdit()) + { + SdrView* pSdrView = dynamic_cast(this); + if (pSdrView) + pSdrView->SdrEndTextEdit(bDontDeleteReally); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdedtv1.cxx b/svx/source/svdraw/svdedtv1.cxx new file mode 100644 index 0000000000..ee8945a821 --- /dev/null +++ b/svx/source/svdraw/svdedtv1.cxx @@ -0,0 +1,2019 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// EditView + + +void SdrEditView::SetMarkedObjRect(const tools::Rectangle& rRect) +{ + DBG_ASSERT(!rRect.IsEmpty(),"SetMarkedObjRect() with an empty Rect does not make sense."); + if (rRect.IsEmpty()) return; + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) return; + tools::Rectangle aR0(GetMarkedObjRect()); + DBG_ASSERT(!aR0.IsEmpty(),"SetMarkedObjRect(): GetMarkedObjRect() is empty."); + if (aR0.IsEmpty()) return; + tools::Long x0=aR0.Left(); + tools::Long y0=aR0.Top(); + tools::Long w0=aR0.Right()-x0; + tools::Long h0=aR0.Bottom()-y0; + tools::Long x1=rRect.Left(); + tools::Long y1=rRect.Top(); + tools::Long w1=rRect.Right()-x1; + tools::Long h1=rRect.Bottom()-y1; + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + BegUndo(ImpGetDescriptionString(STR_EditPosSize)); + } + + for (size_t nm=0; nmGetMarkedSdrObj(); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + + tools::Rectangle aR1(pO->GetSnapRect()); + if (!aR1.IsEmpty()) + { + if (aR1==aR0) + { + aR1=rRect; + } + else + { // transform aR1 to aR0 after rRect + aR1.Move(-x0,-y0); + BigInt l(aR1.Left()); + BigInt r(aR1.Right()); + BigInt t(aR1.Top()); + BigInt b(aR1.Bottom()); + if (w0!=0) { + l*=w1; l/=w0; + r*=w1; r/=w0; + } else { + l=0; r=w1; + } + if (h0!=0) { + t*=h1; t/=h0; + b*=h1; b/=h0; + } else { + t=0; b=h1; + } + aR1.SetLeft(tools::Long(l) ); + aR1.SetRight(tools::Long(r) ); + aR1.SetTop(tools::Long(t) ); + aR1.SetBottom(tools::Long(b) ); + aR1.Move(x1,y1); + } + pO->SetSnapRect(aR1); + } else { + OSL_FAIL("SetMarkedObjRect(): pObj->GetSnapRect() returns empty Rect"); + } + } + if( bUndo ) + EndUndo(); +} + +std::vector< std::unique_ptr > SdrEditView::CreateConnectorUndo( const SdrObject& rO ) +{ + std::vector< std::unique_ptr > vUndoActions; + + if ( rO.GetBroadcaster() ) + { + const SdrPage* pPage = rO.getSdrPageFromSdrObject(); + if ( pPage ) + { + SdrObjListIter aIter(pPage, SdrIterMode::DeepWithGroups); + while( aIter.IsMore() ) + { + SdrObject* pPartObj = aIter.Next(); + if ( dynamic_cast( pPartObj) != nullptr ) + { + if ( ( pPartObj->GetConnectedNode( false ) == &rO ) || + ( pPartObj->GetConnectedNode( true ) == &rO ) ) + { + vUndoActions.push_back(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPartObj)); + } + } + } + } + } + return vUndoActions; +} + +void SdrEditView::AddUndoActions( std::vector< std::unique_ptr > aUndoActions ) +{ + for (auto & rAction : aUndoActions) + AddUndo( std::move(rAction) ); +} + +void SdrEditView::MoveMarkedObj(const Size& rSiz, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr(SvxResId(STR_EditMove)); + if (bCopy) + aStr += SvxResId(STR_EditWithCopy); + // needs its own UndoGroup because of its parameters + BegUndo(aStr,GetDescriptionOfMarkedObjects(),SdrRepeatFunc::Move); + } + + if (bCopy) + CopyMarkedObj(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if( bUndo ) + { + AddUndoActions( CreateConnectorUndo( *pO ) ); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoMoveObject(*pO,rSiz)); + } + pO->Move(rSiz); + } + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr {ImpGetDescriptionString(STR_EditResize)}; + if (bCopy) + aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if( bUndo ) + { + AddUndoActions( CreateConnectorUndo( *pO ) ); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + } + pO->Resize(rRef,xFact,yFact); + } + + if( bUndo ) + EndUndo(); +} +void SdrEditView::ResizeMultMarkedObj(const Point& rRef, + const Fraction& xFact, + const Fraction& yFact, + const bool bWdh, + const bool bHgt) +{ + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + BegUndo(ImpGetDescriptionString(STR_EditResize)); + } + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if( bUndo ) + { + AddUndoActions( CreateConnectorUndo( *pO ) ); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + } + + Fraction aFrac(1,1); + if (bWdh && xFact.IsValid() && bHgt && yFact.IsValid()) + pO->Resize(rRef, xFact, yFact); + else if (bWdh && xFact.IsValid()) + pO->Resize(rRef, xFact, aFrac); + else if (bHgt && yFact.IsValid()) + pO->Resize(rRef, aFrac, yFact); + } + if( bUndo ) + EndUndo(); +} + +Degree100 SdrEditView::GetMarkedObjRotate() const +{ + Degree100 nRetval(0); + + if(GetMarkedObjectCount()) + { + SdrMark* pM = GetSdrMarkByIndex(0); + SdrObject* pO = pM->GetMarkedSdrObj(); + + nRetval = pO->GetRotateAngle(); + } + + return nRetval; +} + +void SdrEditView::RotateMarkedObj(const Point& rRef, Degree100 nAngle, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr {ImpGetDescriptionString(STR_EditRotate)}; + if (bCopy) aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + double nSin = sin(toRadians(nAngle)); + double nCos = cos(toRadians(nAngle)); + const size_t nMarkCount(GetMarkedObjectCount()); + + if(nMarkCount) + { + std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters; + + for(size_t nm = 0; nm < nMarkCount; ++nm) + { + SdrMark* pM = GetSdrMarkByIndex(nm); + SdrObject* pO = pM->GetMarkedSdrObj(); + + if( bUndo ) + { + // extra undo actions for changed connector which now may hold its laid out path (SJ) + AddUndoActions( CreateConnectorUndo( *pO ) ); + + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + } + + // set up a scene updater if object is a 3d object + if(DynCastE3dObject(pO)) + { + aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO)); + } + + pO->Rotate(rRef,nAngle,nSin,nCos); + } + + // fire scene updaters + while(!aUpdaters.empty()) + { + delete aUpdaters.back(); + aUpdaters.pop_back(); + } + } + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr; + Point aDif(rRef2-rRef1); + if (aDif.X()==0) + aStr = ImpGetDescriptionString(STR_EditMirrorHori); + else if (aDif.Y()==0) + aStr = ImpGetDescriptionString(STR_EditMirrorVert); + else if (std::abs(aDif.X()) == std::abs(aDif.Y())) + aStr = ImpGetDescriptionString(STR_EditMirrorDiag); + else + aStr = ImpGetDescriptionString(STR_EditMirrorFree); + if (bCopy) aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + const size_t nMarkCount(GetMarkedObjectCount()); + + if(nMarkCount) + { + std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters; + + for(size_t nm = 0; nm < nMarkCount; ++nm) + { + SdrMark* pM = GetSdrMarkByIndex(nm); + SdrObject* pO = pM->GetMarkedSdrObj(); + + if( bUndo ) + { + // extra undo actions for changed connector which now may hold its laid out path (SJ) + AddUndoActions( CreateConnectorUndo( *pO ) ); + + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + } + + // set up a scene updater if object is a 3d object + if(DynCastE3dObject(pO)) + { + aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO)); + } + + pO->Mirror(rRef1,rRef2); + } + + // fire scene updaters + while(!aUpdaters.empty()) + { + delete aUpdaters.back(); + aUpdaters.pop_back(); + } + } + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::MirrorMarkedObjHorizontal() +{ + Point aCenter(GetMarkedObjRect().Center()); + Point aPt2(aCenter); + aPt2.AdjustY( 1 ); + MirrorMarkedObj(aCenter,aPt2); +} + +void SdrEditView::MirrorMarkedObjVertical() +{ + Point aCenter(GetMarkedObjRect().Center()); + Point aPt2(aCenter); + aPt2.AdjustX( 1 ); + MirrorMarkedObj(aCenter,aPt2); +} + +Degree100 SdrEditView::GetMarkedObjShear() const +{ + bool b1st=true; + bool bOk=true; + Degree100 nAngle(0); + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + Degree100 nAngle2=pO->GetShearAngle(); + if (b1st) nAngle=nAngle2; + else if (nAngle2!=nAngle) bOk=false; + b1st=false; + } + if (nAngle>SDRMAXSHEAR) nAngle=SDRMAXSHEAR; + if (nAngle<-SDRMAXSHEAR) nAngle=-SDRMAXSHEAR; + if (!bOk) nAngle=0_deg100; + return nAngle; +} + +void SdrEditView::ShearMarkedObj(const Point& rRef, Degree100 nAngle, bool bVShear, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr {ImpGetDescriptionString(STR_EditShear)}; + if (bCopy) + aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + double nTan = tan(toRadians(nAngle)); + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if( bUndo ) + { + AddUndoActions( CreateConnectorUndo( *pO ) ); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + } + pO->Shear(rRef,nAngle,nTan,bVShear); + } + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad, + SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bRotate, const tools::Rectangle& rMarkRect) +{ + SdrPathObj* pPath=dynamic_cast( pO ); + bool bDone = false; + + if(pPath!=nullptr && !bNoContortion) + { + XPolyPolygon aXPP(pPath->GetPathPoly()); + switch (eMode) { + case SdrCrookMode::Rotate : CrookRotatePoly (aXPP,rRef,rRad,bVertical); break; + case SdrCrookMode::Slant : CrookSlantPoly (aXPP,rRef,rRad,bVertical); break; + case SdrCrookMode::Stretch: CrookStretchPoly(aXPP,rRef,rRad,bVertical,rMarkRect); break; + } // switch + pPath->SetPathPoly(aXPP.getB2DPolyPolygon()); + bDone = true; + } + + if(!bDone && !pPath && pO->IsPolyObj() && 0 != pO->GetPointCount()) + { + // for PolyObj's, but NOT for SdrPathObj's, e.g. the measurement object + sal_uInt32 nPointCount(pO->GetPointCount()); + XPolygon aXP(static_cast(nPointCount)); + sal_uInt32 nPtNum; + + for(nPtNum = 0; nPtNum < nPointCount; nPtNum++) + { + Point aPt(pO->GetPoint(nPtNum)); + aXP[static_cast(nPtNum)]=aPt; + } + + switch (eMode) + { + case SdrCrookMode::Rotate : CrookRotatePoly (aXP,rRef,rRad,bVertical); break; + case SdrCrookMode::Slant : CrookSlantPoly (aXP,rRef,rRad,bVertical); break; + case SdrCrookMode::Stretch: CrookStretchPoly(aXP,rRef,rRad,bVertical,rMarkRect); break; + } + + for(nPtNum = 0; nPtNum < nPointCount; nPtNum++) + { + // broadcasting could be optimized here, but for the + // current two points of the measurement object, it's fine + pO->SetPoint(aXP[static_cast(nPtNum)],nPtNum); + } + + bDone = true; + } + + if(bDone) + return; + + // for all others or if bNoContortion + Point aCtr0(pO->GetSnapRect().Center()); + Point aCtr1(aCtr0); + bool bRotOk(false); + double nSin(0.0), nCos(1.0); + double nAngle(0.0); + + if(0 != rRad.X() && 0 != rRad.Y()) + { + bRotOk = bRotate; + + switch (eMode) + { + case SdrCrookMode::Rotate : nAngle=CrookRotateXPoint (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical); bRotOk=bRotate; break; + case SdrCrookMode::Slant : nAngle=CrookSlantXPoint (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical); break; + case SdrCrookMode::Stretch: nAngle=CrookStretchXPoint(aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical,rMarkRect); break; + } + } + + aCtr1 -= aCtr0; + + if(bRotOk) + pO->Rotate(aCtr0, Degree100(FRound(basegfx::rad2deg<100>(nAngle))), nSin, nCos); + + pO->Move(Size(aCtr1.X(),aCtr1.Y())); +} + +void SdrEditView::CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode, + bool bVertical, bool bNoContortion, bool bCopy) +{ + tools::Rectangle aMarkRect(GetMarkedObjRect()); + const bool bUndo = IsUndoEnabled(); + + bool bRotate=bNoContortion && eMode==SdrCrookMode::Rotate && IsRotateAllowed(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr {ImpGetDescriptionString(bNoContortion ? STR_EditCrook : STR_EditCrookContortion)}; + if (bCopy) + aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + + const SdrObjList* pOL=pO->GetSubList(); + if (bNoContortion || pOL==nullptr) { + ImpCrookObj(pO,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect); + } else { + SdrObjListIter aIter(pOL,SdrIterMode::DeepNoGroups); + while (aIter.IsMore()) { + SdrObject* pO1=aIter.Next(); + ImpCrookObj(pO1,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect); + } + } + } + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::ImpDistortObj(SdrObject* pO, const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion) +{ + SdrPathObj* pPath = dynamic_cast( pO ); + + if(!bNoContortion && pPath) + { + XPolyPolygon aXPP(pPath->GetPathPoly()); + aXPP.Distort(rRef, rDistortedRect); + pPath->SetPathPoly(aXPP.getB2DPolyPolygon()); + } + else if(pO->IsPolyObj()) + { + // e. g. for the measurement object + sal_uInt32 nPointCount(pO->GetPointCount()); + XPolygon aXP(static_cast(nPointCount)); + sal_uInt32 nPtNum; + + for(nPtNum = 0; nPtNum < nPointCount; nPtNum++) + { + Point aPt(pO->GetPoint(nPtNum)); + aXP[static_cast(nPtNum)]=aPt; + } + + aXP.Distort(rRef, rDistortedRect); + + for(nPtNum = 0; nPtNum < nPointCount; nPtNum++) + { + // broadcasting could be optimized here, but for the + // current two points of the measurement object it's fine + pO->SetPoint(aXP[static_cast(nPtNum)],nPtNum); + } + } +} + +void SdrEditView::DistortMarkedObj(const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion, bool bCopy) +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr {ImpGetDescriptionString(STR_EditDistort)}; + if (bCopy) + aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr); + } + + if (bCopy) + CopyMarkedObj(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pO)); + + tools::Rectangle aRefRect(rRef); + const SdrObjList* pOL=pO->GetSubList(); + if (bNoContortion || pOL==nullptr) { + ImpDistortObj(pO,aRefRect,rDistortedRect,bNoContortion); + } else { + SdrObjListIter aIter(pOL,SdrIterMode::DeepNoGroups); + while (aIter.IsMore()) { + SdrObject* pO1=aIter.Next(); + ImpDistortObj(pO1,aRefRect,rDistortedRect,bNoContortion); + } + } + } + if( bUndo ) + EndUndo(); +} + + +void SdrEditView::SetNotPersistAttrToMarked(const SfxItemSet& rAttr) +{ + // bReplaceAll has no effect here + tools::Rectangle aAllSnapRect(GetMarkedObjRect()); + if (const SdrTransformRef1XItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF1X)) + { + tools::Long n = pPoolItem->GetValue(); + SetRef1(Point(n,GetRef1().Y())); + } + if (const SdrTransformRef1YItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF1Y)) + { + tools::Long n = pPoolItem->GetValue(); + SetRef1(Point(GetRef1().X(),n)); + } + if (const SdrTransformRef2XItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF2X)) + { + tools::Long n = pPoolItem->GetValue(); + SetRef2(Point(n,GetRef2().Y())); + } + if (const SdrTransformRef2YItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF2Y)) + { + tools::Long n = pPoolItem->GetValue(); + SetRef2(Point(GetRef2().X(),n)); + } + tools::Long nAllPosX=0; bool bAllPosX=false; + tools::Long nAllPosY=0; bool bAllPosY=false; + tools::Long nAllWdt=0; bool bAllWdt=false; + tools::Long nAllHgt=0; bool bAllHgt=false; + bool bDoIt=false; + if (const SdrAllPositionXItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ALLPOSITIONX)) + { + nAllPosX = pPoolItem->GetValue(); + bAllPosX=true; bDoIt=true; + } + if (const SdrAllPositionYItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ALLPOSITIONY)) + { + nAllPosY = pPoolItem->GetValue(); + bAllPosY=true; bDoIt=true; + } + if (const SdrAllSizeWidthItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ALLSIZEWIDTH)) + { + nAllWdt = pPoolItem->GetValue(); + bAllWdt=true; bDoIt=true; + } + if (const SdrAllSizeHeightItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ALLSIZEHEIGHT)) + { + nAllHgt = pPoolItem->GetValue(); + bAllHgt=true; bDoIt=true; + } + if (bDoIt) { + tools::Rectangle aRect(aAllSnapRect); // TODO: change this for PolyPt's and GluePt's!!! + if (bAllPosX) aRect.Move(nAllPosX-aRect.Left(),0); + if (bAllPosY) aRect.Move(0,nAllPosY-aRect.Top()); + if (bAllWdt) aRect.SetRight(aAllSnapRect.Left()+nAllWdt ); + if (bAllHgt) aRect.SetBottom(aAllSnapRect.Top()+nAllHgt ); + SetMarkedObjRect(aRect); + } + if (const SdrResizeXAllItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_RESIZEXALL)) + { + Fraction aXFact = pPoolItem->GetValue(); + ResizeMarkedObj(aAllSnapRect.TopLeft(),aXFact,Fraction(1,1)); + } + if (const SdrResizeYAllItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_RESIZEYALL)) + { + Fraction aYFact = pPoolItem->GetValue(); + ResizeMarkedObj(aAllSnapRect.TopLeft(),Fraction(1,1),aYFact); + } + if (const SdrRotateAllItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ROTATEALL)) + { + Degree100 nAngle = pPoolItem->GetValue(); + RotateMarkedObj(aAllSnapRect.Center(),nAngle); + } + if (const SdrHorzShearAllItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_HORZSHEARALL)) + { + Degree100 nAngle = pPoolItem->GetValue(); + ShearMarkedObj(aAllSnapRect.Center(),nAngle); + } + if (const SdrVertShearAllItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_VERTSHEARALL)) + { + Degree100 nAngle = pPoolItem->GetValue(); + ShearMarkedObj(aAllSnapRect.Center(),nAngle,true); + } + + const bool bUndo = IsUndoEnabled(); + + // TODO: check if WhichRange is necessary. + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + pObj->ApplyNotPersistAttr(rAttr); + } +} + +void SdrEditView::MergeNotPersistAttrFromMarked(SfxItemSet& rAttr) const +{ + // TODO: Take into account the origin and PvPos. + tools::Rectangle aAllSnapRect(GetMarkedObjRect()); // TODO: change this for PolyPt's and GluePt's!!! + tools::Long nAllSnapPosX=aAllSnapRect.Left(); + tools::Long nAllSnapPosY=aAllSnapRect.Top(); + tools::Long nAllSnapWdt=aAllSnapRect.GetWidth()-1; + tools::Long nAllSnapHgt=aAllSnapRect.GetHeight()-1; + // TODO: could go into CheckPossibilities + bool bMovProtect = false, bMovProtectDC = false; + bool bSizProtect = false, bSizProtectDC = false; + bool bPrintable = true, bPrintableDC = false; + bool bVisible = true, bVisibleDC = false; + SdrLayerID nLayerId(0); + bool bLayerDC=false; + tools::Long nSnapPosX=0; bool bSnapPosXDC=false; + tools::Long nSnapPosY=0; bool bSnapPosYDC=false; + tools::Long nSnapWdt=0; bool bSnapWdtDC=false; + tools::Long nSnapHgt=0; bool bSnapHgtDC=false; + tools::Long nLogicWdt=0; bool bLogicWdtDC=false,bLogicWdtDiff=false; + tools::Long nLogicHgt=0; bool bLogicHgtDC=false,bLogicHgtDiff=false; + Degree100 nRotAngle(0); bool bRotAngleDC=false; + Degree100 nShrAngle(0); bool bShrAngleDC=false; + tools::Rectangle aSnapRect; + tools::Rectangle aLogicRect; + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + if (nm==0) { + nLayerId=pObj->GetLayer(); + bMovProtect=pObj->IsMoveProtect(); + bSizProtect=pObj->IsResizeProtect(); + bPrintable =pObj->IsPrintable(); + bVisible = pObj->IsVisible(); + tools::Rectangle aSnapRect2(pObj->GetSnapRect()); + tools::Rectangle aLogicRect2(pObj->GetLogicRect()); + nSnapPosX=aSnapRect2.Left(); + nSnapPosY=aSnapRect2.Top(); + nSnapWdt=aSnapRect2.GetWidth()-1; + nSnapHgt=aSnapRect2.GetHeight()-1; + nLogicWdt=aLogicRect2.GetWidth()-1; + nLogicHgt=aLogicRect2.GetHeight()-1; + bLogicWdtDiff=nLogicWdt!=nSnapWdt; + bLogicHgtDiff=nLogicHgt!=nSnapHgt; + nRotAngle=pObj->GetRotateAngle(); + nShrAngle=pObj->GetShearAngle(); + } else { + if (!bLayerDC && nLayerId !=pObj->GetLayer()) bLayerDC = true; + if (!bMovProtectDC && bMovProtect!=pObj->IsMoveProtect()) bMovProtectDC = true; + if (!bSizProtectDC && bSizProtect!=pObj->IsResizeProtect()) bSizProtectDC = true; + if (!bPrintableDC && bPrintable !=pObj->IsPrintable()) bPrintableDC = true; + if (!bVisibleDC && bVisible !=pObj->IsVisible()) bVisibleDC=true; + if (!bRotAngleDC && nRotAngle !=pObj->GetRotateAngle()) bRotAngleDC=true; + if (!bShrAngleDC && nShrAngle !=pObj->GetShearAngle()) bShrAngleDC=true; + if (!bSnapWdtDC || !bSnapHgtDC || !bSnapPosXDC || !bSnapPosYDC || !bLogicWdtDiff || !bLogicHgtDiff) { + aSnapRect=pObj->GetSnapRect(); + if (nSnapPosX!=aSnapRect.Left()) bSnapPosXDC=true; + if (nSnapPosY!=aSnapRect.Top()) bSnapPosYDC=true; + if (nSnapWdt!=aSnapRect.GetWidth()-1) bSnapWdtDC=true; + if (nSnapHgt!=aSnapRect.GetHeight()-1) bSnapHgtDC=true; + } + if (!bLogicWdtDC || !bLogicHgtDC || !bLogicWdtDiff || !bLogicHgtDiff) { + aLogicRect=pObj->GetLogicRect(); + if (nLogicWdt!=aLogicRect.GetWidth()-1) bLogicWdtDC=true; + if (nLogicHgt!=aLogicRect.GetHeight()-1) bLogicHgtDC=true; + if (!bLogicWdtDiff && aSnapRect.GetWidth()!=aLogicRect.GetWidth()) bLogicWdtDiff=true; + if (!bLogicHgtDiff && aSnapRect.GetHeight()!=aLogicRect.GetHeight()) bLogicHgtDiff=true; + } + } + } + + if (bSnapPosXDC || nAllSnapPosX!=nSnapPosX) rAttr.Put(SdrAllPositionXItem(nAllSnapPosX)); + if (bSnapPosYDC || nAllSnapPosY!=nSnapPosY) rAttr.Put(SdrAllPositionYItem(nAllSnapPosY)); + if (bSnapWdtDC || nAllSnapWdt !=nSnapWdt ) rAttr.Put(SdrAllSizeWidthItem(nAllSnapWdt)); + if (bSnapHgtDC || nAllSnapHgt !=nSnapHgt ) rAttr.Put(SdrAllSizeHeightItem(nAllSnapHgt)); + + // items for pure transformations + rAttr.Put(SdrMoveXItem()); + rAttr.Put(SdrMoveYItem()); + rAttr.Put(SdrResizeXOneItem()); + rAttr.Put(SdrResizeYOneItem()); + rAttr.Put(SdrRotateOneItem()); + rAttr.Put(SdrHorzShearOneItem()); + rAttr.Put(SdrVertShearOneItem()); + + if (nMarkCount>1) { + rAttr.Put(SdrResizeXAllItem()); + rAttr.Put(SdrResizeYAllItem()); + rAttr.Put(SdrRotateAllItem()); + rAttr.Put(SdrHorzShearAllItem()); + rAttr.Put(SdrVertShearAllItem()); + } + + if(meDragMode == SdrDragMode::Rotate || meDragMode == SdrDragMode::Mirror) + { + rAttr.Put(SdrTransformRef1XItem(GetRef1().X())); + rAttr.Put(SdrTransformRef1YItem(GetRef1().Y())); + } + + if(meDragMode == SdrDragMode::Mirror) + { + rAttr.Put(SdrTransformRef2XItem(GetRef2().X())); + rAttr.Put(SdrTransformRef2YItem(GetRef2().Y())); + } +} + +SfxItemSet SdrEditView::GetAttrFromMarked(bool bOnlyHardAttr) const +{ + SfxItemSet aSet(GetModel().GetItemPool()); + MergeAttrFromMarked(aSet,bOnlyHardAttr); + //the EE_FEATURE items should not be set with SetAttrToMarked (see error message there) + //so we do not set them here + // #i32448# + // Do not disable, but clear the items. + aSet.ClearItem(EE_FEATURE_TAB); + aSet.ClearItem(EE_FEATURE_LINEBR); + aSet.ClearItem(EE_FEATURE_NOTCONV); + aSet.ClearItem(EE_FEATURE_FIELD); + + return aSet; +} + +void SdrEditView::MergeAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const +{ + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t a = 0; a < nMarkCount; ++a) + { + // #80277# merging was done wrong in the prev version + SdrObject *pObj = GetMarkedObjectByIndex(a); + if (!pObj) + { + continue; + } + + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + SfxWhichIter aIter(rSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + + while(nWhich) + { + if(!bOnlyHardAttr) + { + if(SfxItemState::DONTCARE == aIter.GetItemState(false)) + rAttr.InvalidateItem(nWhich); + else + rAttr.MergeValue(rSet.Get(nWhich), true); + } + else if(SfxItemState::SET == aIter.GetItemState(false)) + { + const SfxPoolItem& rItem = rSet.Get(nWhich); + rAttr.MergeValue(rItem, true); + } + + if (comphelper::LibreOfficeKit::isActive()) + { + OUString sPayload; + switch(nWhich) + { + case XATTR_LINECOLOR: + { + const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINECOLOR); + if (pItem) + { + Color aColor = static_cast(pItem)->GetColorValue(); + sPayload = OUString::number(static_cast(aColor)); + + sPayload = ".uno:XLineColor=" + sPayload; + } + break; + } + + case XATTR_FILLCOLOR: + { + const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLCOLOR); + if (pItem) + { + Color aColor = static_cast(pItem)->GetColorValue(); + sPayload = OUString::number(static_cast(aColor)); + + sPayload = ".uno:FillColor=" + sPayload; + } + break; + } + + case XATTR_FILLTRANSPARENCE: + { + const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLTRANSPARENCE); + if (pItem) + { + sal_uInt16 nTransparency = static_cast(pItem)->GetValue(); + sPayload = OUString::number(nTransparency); + + sPayload = ".uno:FillTransparence=" + sPayload; + } + break; + } + + case XATTR_LINETRANSPARENCE: + { + const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINETRANSPARENCE); + if (pItem) + { + sal_uInt16 nTransparency = static_cast(pItem)->GetValue(); + sPayload = OUString::number(nTransparency); + + sPayload = ".uno:LineTransparence=" + sPayload; + } + break; + } + + case XATTR_LINEWIDTH: + { + const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINEWIDTH); + if (pItem) + { + sal_uInt32 nWidth = static_cast(pItem)->GetValue(); + sPayload = OUString::number(nWidth); + + sPayload = ".uno:LineWidth=" + sPayload; + } + break; + } + + case SDRATTR_SHADOWTRANSPARENCE: + { + const SfxPoolItem* pItem = rSet.GetItem(SDRATTR_SHADOWTRANSPARENCE); + if (pItem) + { + sal_uInt16 nWidth = static_cast(pItem)->GetValue(); + sPayload = OUString::number(nWidth); + + sPayload = ".uno:FillShadowTransparency=" + sPayload; + } + break; + } + } + + if (!sPayload.isEmpty()) + GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, + OUStringToOString(sPayload, RTL_TEXTENCODING_ASCII_US)); + } + + nWhich = aIter.NextWhich(); + } + } +} + +std::vector GetAllCharPropIds(const SfxItemSet& rSet) +{ + std::vector aCharWhichIds; + { + SfxItemIter aIter(rSet); + for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem()) + { + if (!IsInvalidItem(pItem)) + { + sal_uInt16 nWhich = pItem->Which(); + if (nWhich>=EE_CHAR_START && nWhich<=EE_CHAR_END) + aCharWhichIds.push_back( nWhich ); + } + } + } + return aCharWhichIds; +} + +std::vector GetAllCharPropIds(std::span< const SfxPoolItem* const > aChangedItems) +{ + std::vector aCharWhichIds; + for (const SfxPoolItem* pItem : aChangedItems) + { + sal_uInt16 nWhich = pItem->Which(); + if (nWhich>=EE_CHAR_START && nWhich<=EE_CHAR_END) + aCharWhichIds.push_back( nWhich ); + } + return aCharWhichIds; +} + +void SdrEditView::SetAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll) +{ + if (!AreObjectsMarked()) + return; + +#ifdef DBG_UTIL + { + bool bHasEEFeatureItems=false; + SfxItemIter aIter(rAttr); + for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem; + pItem = aIter.NextItem()) + { + if (!IsInvalidItem(pItem)) { + sal_uInt16 nW=pItem->Which(); + if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true; + } + } + if(bHasEEFeatureItems) + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Info, VclButtonsType::Ok, + "SdrEditView::SetAttrToMarked(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents.")); + xInfoBox->run(); + } + } +#endif + + // #103836# if the user sets character attributes to the complete shape, + // we want to remove all hard set character attributes with same + // which ids from the text. We do that later but here we remember + // all character attribute which id's that are set. + std::vector aCharWhichIds(GetAllCharPropIds(rAttr)); + + // To make Undo reconstruct text attributes correctly after Format.Standard + bool bHasEEItems=SearchOutlinerItems(rAttr,bReplaceAll); + + // save additional geometry information when paragraph or character attributes + // are changed and the geometrical shape of the text object might be changed + bool bPossibleGeomChange(false); + SfxWhichIter aIter(rAttr); + sal_uInt16 nWhich = aIter.FirstWhich(); + while(!bPossibleGeomChange && nWhich) + { + SfxItemState eState = aIter.GetItemState(); + if(eState == SfxItemState::SET) + { + if((nWhich >= SDRATTR_TEXT_MINFRAMEHEIGHT && nWhich <= SDRATTR_TEXT_CONTOURFRAME) + || nWhich == SDRATTR_3DOBJ_PERCENT_DIAGONAL + || nWhich == SDRATTR_3DOBJ_BACKSCALE + || nWhich == SDRATTR_3DOBJ_DEPTH + || nWhich == SDRATTR_3DOBJ_END_ANGLE + || nWhich == SDRATTR_3DSCENE_DISTANCE) + { + bPossibleGeomChange = true; + } + } + nWhich = aIter.NextWhich(); + } + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + BegUndo(ImpGetDescriptionString(STR_EditSetAttributes)); + } + + const size_t nMarkCount(GetMarkedObjectCount()); + std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters; + + // create ItemSet without SfxItemState::DONTCARE. Put() + // uses its second parameter (bInvalidAsDefault) to + // remove all such items to set them to default. + SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges()); + aAttr.Put(rAttr); + + // #i38135# + bool bResetAnimationTimer(false); + + const bool bLineStartWidthExplicitChange(SfxItemState::SET + == aAttr.GetItemState(XATTR_LINESTARTWIDTH)); + const bool bLineEndWidthExplicitChange(SfxItemState::SET + == aAttr.GetItemState(XATTR_LINEENDWIDTH)); + // check if LineWidth is part of the change + const bool bAdaptStartEndWidths(!(bLineStartWidthExplicitChange && bLineEndWidthExplicitChange) + && SfxItemState::SET == aAttr.GetItemState(XATTR_LINEWIDTH)); + sal_Int32 nNewLineWidth(0); + + if(bAdaptStartEndWidths) + { + nNewLineWidth = aAttr.Get(XATTR_LINEWIDTH).GetValue(); + } + + for (size_t nm=0; nmGetMarkedSdrObj(); + + if( bUndo ) + { + SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >( pObj ); + if ( pEdgeObj ) + bPossibleGeomChange = true; + else + AddUndoActions( CreateConnectorUndo( *pObj ) ); + } + + // new geometry undo + if(bPossibleGeomChange && bUndo) + { + // save position and size of object, too + AddUndo( GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + } + + if( bUndo ) + { + // #i8508# + // If this is a text object also rescue the OutlinerParaObject since + // applying attributes to the object may change text layout when + // multiple portions exist with multiple formats. If an OutlinerParaObject + // really exists and needs to be rescued is evaluated in the undo + // implementation itself. + const bool bRescueText = DynCastSdrTextObj(pObj) != nullptr; + + // add attribute undo + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pObj,false,bHasEEItems || bPossibleGeomChange || bRescueText)); + } + + // set up a scene updater if object is a 3d object + if(DynCastE3dObject(pObj)) + { + aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj)); + } + + sal_Int32 nOldLineWidth(0); + if (bAdaptStartEndWidths) + { + nOldLineWidth = pObj->GetMergedItem(XATTR_LINEWIDTH).GetValue(); + } + + // set attributes at object + pObj->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll); + + if(bAdaptStartEndWidths) + { + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + + if(nOldLineWidth != nNewLineWidth) + { + if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINESTARTWIDTH)) + { + const sal_Int32 nValAct(rSet.Get(XATTR_LINESTARTWIDTH).GetValue()); + const sal_Int32 nValNewStart(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10))); + + pObj->SetMergedItem(XLineStartWidthItem(nValNewStart)); + } + + if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINEENDWIDTH)) + { + const sal_Int32 nValAct(rSet.Get(XATTR_LINEENDWIDTH).GetValue()); + const sal_Int32 nValNewEnd(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10))); + + pObj->SetMergedItem(XLineEndWidthItem(nValNewEnd)); + } + } + } + + if(auto pTextObj = DynCastSdrTextObj( pObj)) + { + if(!aCharWhichIds.empty()) + { + tools::Rectangle aOldBoundRect = pTextObj->GetLastBoundRect(); + + // #110094#-14 pTextObj->SendRepaintBroadcast(pTextObj->GetBoundRect()); + pTextObj->RemoveOutlinerCharacterAttribs( aCharWhichIds ); + + // object has changed, should be called from + // RemoveOutlinerCharacterAttribs. This will change when the text + // object implementation changes. + pTextObj->SetChanged(); + + pTextObj->BroadcastObjectChange(); + pTextObj->SendUserCall(SdrUserCallType::ChangeAttr, aOldBoundRect); + } + } + + // #i38495# + if(!bResetAnimationTimer) + { + if(pObj->GetViewContact().isAnimatedInAnyViewObjectContact()) + { + bResetAnimationTimer = true; + } + } + } + + // fire scene updaters + while(!aUpdaters.empty()) + { + delete aUpdaters.back(); + aUpdaters.pop_back(); + } + + // #i38135# + if(bResetAnimationTimer) + { + SetAnimationTimer(0); + } + + // better check before what to do: + // pObj->SetAttr() or SetNotPersistAttr() + // TODO: missing implementation! + SetNotPersistAttrToMarked(rAttr); + + if( bUndo ) + EndUndo(); +} + +SfxStyleSheet* SdrEditView::GetStyleSheetFromMarked() const +{ + SfxStyleSheet* pRet=nullptr; + bool b1st=true; + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj()->GetStyleSheet(); + if (b1st) pRet=pSS; + else if (pRet!=pSS) return nullptr; // different stylesheets + b1st=false; + } + return pRet; +} + +void SdrEditView::SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + if (!AreObjectsMarked()) + return; + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr; + if (pStyleSheet!=nullptr) + aStr = ImpGetDescriptionString(STR_EditSetStylesheet); + else + aStr = ImpGetDescriptionString(STR_EditDelStylesheet); + BegUndo(aStr); + } + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj())); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pM->GetMarkedSdrObj(),true,true)); + } + pM->GetMarkedSdrObj()->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); + } + + if( bUndo ) + EndUndo(); +} + + +void SdrEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const +{ + if(GetMarkedObjectCount()) + { + rTargetSet.Put(GetAttrFromMarked(bOnlyHardAttr), false); + } + else + { + SdrMarkView::GetAttributes(rTargetSet, bOnlyHardAttr); + } +} + +void SdrEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll) +{ + if (GetMarkedObjectCount()!=0) { + SetAttrToMarked(rSet,bReplaceAll); + } else { + SdrMarkView::SetAttributes(rSet,bReplaceAll); + } +} + +SfxStyleSheet* SdrEditView::GetStyleSheet() const +{ + if (GetMarkedObjectCount()!=0) { + return GetStyleSheetFromMarked(); + } else { + return SdrMarkView::GetStyleSheet(); + } +} + +void SdrEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + if (GetMarkedObjectCount()!=0) { + SetStyleSheetToMarked(pStyleSheet,bDontRemoveHardAttr); + } else { + SdrMarkView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr); + } +} + + +SfxItemSet SdrEditView::GetGeoAttrFromMarked() const +{ + SfxItemSet aRetSet( + GetModel().GetItemPool(), + svl::Items< // SID_ATTR_TRANSFORM_... from s:svxids.hrc + SDRATTR_CORNER_RADIUS, SDRATTR_CORNER_RADIUS, + SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_ANGLE, + SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_AUTOHEIGHT>); + + if (AreObjectsMarked()) + { + SfxItemSet aMarkAttr(GetAttrFromMarked(false)); // because of AutoGrowHeight and corner radius + tools::Rectangle aRect(GetMarkedObjRect()); + + if(GetSdrPageView()) + { + GetSdrPageView()->LogicToPagePos(aRect); + } + + // position + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_X,aRect.Left())); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_Y,aRect.Top())); + + // size + tools::Long nResizeRefX=aRect.Left(); + tools::Long nResizeRefY=aRect.Top(); + if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for resizing, too + nResizeRefX=maRef1.X(); + nResizeRefY=maRef1.Y(); + } + aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_WIDTH,aRect.Right()-aRect.Left())); + aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_HEIGHT,aRect.Bottom()-aRect.Top())); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_X,nResizeRefX)); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_Y,nResizeRefY)); + + Point aRotateAxe(maRef1); + + if(GetSdrPageView()) + { + GetSdrPageView()->LogicToPagePos(aRotateAxe); + } + + // rotation + tools::Long nRotateRefX=aRect.Center().X(); + tools::Long nRotateRefY=aRect.Center().Y(); + if (meDragMode==SdrDragMode::Rotate) { + nRotateRefX=aRotateAxe.X(); + nRotateRefY=aRotateAxe.Y(); + } + aRetSet.Put(SdrAngleItem(SID_ATTR_TRANSFORM_ANGLE,GetMarkedObjRotate())); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_X,nRotateRefX)); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_Y,nRotateRefY)); + + // shearing + tools::Long nShearRefX=aRect.Left(); + tools::Long nShearRefY=aRect.Bottom(); + if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for shearing, too + nShearRefX=aRotateAxe.X(); + nShearRefY=aRotateAxe.Y(); + } + aRetSet.Put(SdrAngleItem(SID_ATTR_TRANSFORM_SHEAR,GetMarkedObjShear())); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X,nShearRefX)); + aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y,nShearRefY)); + + // check every object whether it is protected + const SdrMarkList& rMarkList=GetMarkedObjectList(); + const size_t nMarkCount=rMarkList.GetMarkCount(); + SdrObject* pObj=rMarkList.GetMark(0)->GetMarkedSdrObj(); + bool bPosProt=pObj->IsMoveProtect(); + bool bSizProt=pObj->IsResizeProtect(); + bool bPosProtDontCare=false; + bool bSizProtDontCare=false; + for (size_t i=1; iGetMarkedSdrObj(); + if (bPosProt!=pObj->IsMoveProtect()) bPosProtDontCare=true; + if (bSizProt!=pObj->IsResizeProtect()) bSizProtDontCare=true; + } + + // InvalidateItem sets item to DONT_CARE + if (bPosProtDontCare) { + aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_POS); + } else { + aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_POS,bPosProt)); + } + if (bSizProtDontCare) { + aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_SIZE); + } else { + aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_SIZE,bSizProt)); + } + + SfxItemState eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWWIDTH); + bool bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue(); + if (eState==SfxItemState::DONTCARE) { + aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOWIDTH); + } else if (eState==SfxItemState::SET) { + aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOWIDTH,bAutoGrow)); + } + + eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWHEIGHT); + bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + if (eState==SfxItemState::DONTCARE) { + aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOHEIGHT); + } else if (eState==SfxItemState::SET) { + aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOHEIGHT,bAutoGrow)); + } + + eState=aMarkAttr.GetItemState(SDRATTR_CORNER_RADIUS); + tools::Long nRadius=aMarkAttr.Get(SDRATTR_CORNER_RADIUS).GetValue(); + if (eState==SfxItemState::DONTCARE) { + aRetSet.InvalidateItem(SDRATTR_CORNER_RADIUS); + } else if (eState==SfxItemState::SET) { + aRetSet.Put(makeSdrEckenradiusItem(nRadius)); + } + + basegfx::B2DHomMatrix aTransformation; + + if(nMarkCount > 1) + { + // multiple objects, range is collected in aRect + aTransformation = basegfx::utils::createScaleTranslateB2DHomMatrix( + aRect.Left(), aRect.Top(), + aRect.getOpenWidth(), aRect.getOpenHeight()); + } + else + { + // single object, get homogen transformation + basegfx::B2DPolyPolygon aPolyPolygon; + + pObj->TRGetBaseGeometry(aTransformation, aPolyPolygon); + } + + if(aTransformation.isIdentity()) + { + aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_MATRIX); + } + else + { + css::geometry::AffineMatrix2D aAffineMatrix2D; + Point aPageOffset(0, 0); + + if(GetSdrPageView()) + { + aPageOffset = GetSdrPageView()->GetPageOrigin(); + } + + aAffineMatrix2D.m00 = aTransformation.get(0, 0); + aAffineMatrix2D.m01 = aTransformation.get(0, 1); + aAffineMatrix2D.m02 = aTransformation.get(0, 2) - aPageOffset.X(); + aAffineMatrix2D.m10 = aTransformation.get(1, 0); + aAffineMatrix2D.m11 = aTransformation.get(1, 1); + aAffineMatrix2D.m12 = aTransformation.get(1, 2) - aPageOffset.Y(); + + aRetSet.Put(AffineMatrixItem(&aAffineMatrix2D)); + } + } + + return aRetSet; +} + +static Point ImpGetPoint(const tools::Rectangle& rRect, RectPoint eRP) +{ + switch(eRP) { + case RectPoint::LT: return rRect.TopLeft(); + case RectPoint::MT: return rRect.TopCenter(); + case RectPoint::RT: return rRect.TopRight(); + case RectPoint::LM: return rRect.LeftCenter(); + case RectPoint::MM: return rRect.Center(); + case RectPoint::RM: return rRect.RightCenter(); + case RectPoint::LB: return rRect.BottomLeft(); + case RectPoint::MB: return rRect.BottomCenter(); + case RectPoint::RB: return rRect.BottomRight(); + } + return Point(); // Should not happen! +} + +void SdrEditView::SetGeoAttrToMarked(const SfxItemSet& rAttr, bool addPageMargin) +{ + const bool bTiledRendering = comphelper::LibreOfficeKit::isActive(); + + tools::Rectangle aRect(GetMarkedObjRect()); + + if(GetSdrPageView()) + { + if (addPageMargin) + { + SdrPage * pPage = GetSdrPageView()->GetPage(); + Point upperLeft(pPage->GetLeftBorder(), pPage->GetUpperBorder()); + aRect.Move(upperLeft.getX(), upperLeft.getY()); + } + GetSdrPageView()->LogicToPagePos(aRect); + } + + Degree100 nOldRotateAngle=GetMarkedObjRotate(); + Degree100 nOldShearAngle=GetMarkedObjShear(); + const SdrMarkList& rMarkList=GetMarkedObjectList(); + SdrObject* pObj=nullptr; + + RectPoint eSizePoint=RectPoint::MM; + tools::Long nPosDX=0; + tools::Long nPosDY=0; + tools::Long nSizX=0; + tools::Long nSizY=0; + Degree100 nRotateAngle(0); + + bool bModeIsRotate(meDragMode == SdrDragMode::Rotate); + tools::Long nRotateX(0); + tools::Long nRotateY(0); + tools::Long nOldRotateX(0); + tools::Long nOldRotateY(0); + if(bModeIsRotate) + { + Point aRotateAxe(maRef1); + + if(GetSdrPageView()) + { + GetSdrPageView()->LogicToPagePos(aRotateAxe); + } + + nRotateX = nOldRotateX = aRotateAxe.X(); + nRotateY = nOldRotateY = aRotateAxe.Y(); + } + + Degree100 nShearAngle(0); + tools::Long nShearX=0; + tools::Long nShearY=0; + bool bShearVert=false; + + bool bChgPos=false; + bool bChgSiz=false; + bool bChgWdh=false; + bool bChgHgt=false; + bool bRotate=false; + bool bShear =false; + + bool bSetAttr=false; + SfxItemSet aSetAttr(GetModel().GetItemPool()); + + // position + if (const SfxInt32Item *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_POS_X)) + { + nPosDX = pPoolItem->GetValue() - aRect.Left(); + bChgPos=true; + } + if (const SfxInt32Item *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_POS_Y)) + { + nPosDY = pPoolItem->GetValue() - aRect.Top(); + bChgPos=true; + } + // size + if (const SfxUInt32Item *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_WIDTH)) + { + nSizX = pPoolItem->GetValue(); + bChgSiz=true; + bChgWdh=true; + } + if (const SfxUInt32Item *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_HEIGHT)) + { + nSizY = pPoolItem->GetValue(); + bChgSiz=true; + bChgHgt=true; + } + if (bChgSiz) { + if (bTiledRendering && SfxItemState::SET != rAttr.GetItemState(SID_ATTR_TRANSFORM_SIZE_POINT)) + eSizePoint = RectPoint::LT; + else + eSizePoint = static_cast(rAttr.Get(SID_ATTR_TRANSFORM_SIZE_POINT).GetValue()); + } + + // rotation + if (const SdrAngleItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_DELTA_ANGLE)) + { + nRotateAngle = pPoolItem->GetValue(); + bRotate = (nRotateAngle != 0_deg100); + } + + // rotation + if (const SdrAngleItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_ANGLE)) + { + nRotateAngle = pPoolItem->GetValue() - nOldRotateAngle; + bRotate = (nRotateAngle != 0_deg100); + } + + // position rotation point x + if(bRotate || rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_ROT_X)) + nRotateX = rAttr.Get(SID_ATTR_TRANSFORM_ROT_X).GetValue(); + + // position rotation point y + if(bRotate || rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_ROT_Y)) + nRotateY = rAttr.Get(SID_ATTR_TRANSFORM_ROT_Y).GetValue(); + + // shearing + if (const SdrAngleItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_SHEAR)) + { + Degree100 nNewShearAngle=pPoolItem->GetValue(); + if (nNewShearAngle>SDRMAXSHEAR) nNewShearAngle=SDRMAXSHEAR; + if (nNewShearAngle<-SDRMAXSHEAR) nNewShearAngle=-SDRMAXSHEAR; + if (nNewShearAngle!=nOldShearAngle) { + bShearVert = rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_VERTICAL).GetValue(); + if (bShearVert) { + nShearAngle=nNewShearAngle; + } else { + if (nNewShearAngle!=0_deg100 && nOldShearAngle!=0_deg100) { + // bug fix + double nOld = tan(toRadians(nOldShearAngle)); + double nNew = tan(toRadians(nNewShearAngle)); + nNew-=nOld; + nNew = basegfx::rad2deg<100>(atan(nNew)); + nShearAngle=Degree100(FRound(nNew)); + } else { + nShearAngle=nNewShearAngle-nOldShearAngle; + } + } + bShear=nShearAngle!=0_deg100; + if (bShear) { + nShearX = rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_X).GetValue(); + nShearY = rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_Y).GetValue(); + } + } + } + + // AutoGrow + if (const SfxBoolItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_AUTOWIDTH)) + { + bool bAutoGrow = pPoolItem->GetValue(); + aSetAttr.Put(makeSdrTextAutoGrowWidthItem(bAutoGrow)); + bSetAttr=true; + } + + if (const SfxBoolItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_AUTOHEIGHT)) + { + bool bAutoGrow = pPoolItem->GetValue(); + aSetAttr.Put(makeSdrTextAutoGrowHeightItem(bAutoGrow)); + bSetAttr=true; + } + + // corner radius + if (m_bEdgeRadiusAllowed) + if (const SdrMetricItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_CORNER_RADIUS)) + { + tools::Long nRadius = pPoolItem->GetValue(); + aSetAttr.Put(makeSdrEckenradiusItem(nRadius)); + bSetAttr=true; + } + + ForcePossibilities(); + + BegUndo(SvxResId(STR_EditTransform),GetDescriptionOfMarkedObjects()); + + if (bSetAttr) { + SetAttrToMarked(aSetAttr,false); + } + + // change size and height + if (bChgSiz && (m_bResizeFreeAllowed || m_bResizePropAllowed)) { + Fraction aWdt(nSizX,aRect.Right()-aRect.Left()); + Fraction aHgt(nSizY,aRect.Bottom()-aRect.Top()); + Point aRef(ImpGetPoint(aRect,eSizePoint)); + + if(GetSdrPageView()) + { + GetSdrPageView()->PagePosToLogic(aRef); + } + + ResizeMultMarkedObj(aRef, aWdt, aHgt, bChgWdh, bChgHgt); + } + + // rotate + if (bRotate && (m_bRotateFreeAllowed || m_bRotate90Allowed)) { + Point aRef(nRotateX,nRotateY); + + if(GetSdrPageView()) + { + GetSdrPageView()->PagePosToLogic(aRef); + } + + RotateMarkedObj(aRef,nRotateAngle); + } + + // set rotation point position + if(bModeIsRotate && (nRotateX != nOldRotateX || nRotateY != nOldRotateY)) + { + Point aNewRef1(nRotateX, nRotateY); + + if(GetSdrPageView()) + { + GetSdrPageView()->PagePosToLogic(aNewRef1); + } + + SetRef1(aNewRef1); + } + + // shear + if (bShear && m_bShearAllowed) { + Point aRef(nShearX,nShearY); + + if(GetSdrPageView()) + { + GetSdrPageView()->PagePosToLogic(aRef); + } + + ShearMarkedObj(aRef,nShearAngle,bShearVert); + + // #i74358# + // ShearMarkedObj creates a linear combination of the existing transformation and + // the new shear to apply. If the object is already transformed (e.g. rotated) the + // linear combination will not decompose to the same start values again, but to a + // new combination. Thus it makes no sense to check if the wanted shear is reached + // or not. Taking out. + } + + // change position + if (bChgPos && m_bMoveAllowed) { + MoveMarkedObj(Size(nPosDX,nPosDY)); + } + + const size_t nMarkCount=rMarkList.GetMarkCount(); + // protect position + if(const SfxBoolItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_PROTECT_POS)) + { + const bool bProtPos(pPoolItem->GetValue()); + bool bChanged(false); + + for(size_t i = 0; i < nMarkCount; ++i) + { + pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if(pObj->IsMoveProtect() != bProtPos) + { + bChanged = true; + pObj->SetMoveProtect(bProtPos); + + if(bProtPos) + { + pObj->SetResizeProtect(true); + } + } + } + + if(bChanged) + { + m_bMoveProtect = bProtPos; + + if(bProtPos) + { + m_bResizeProtect = true; + } + + // #i77187# there is no simple method to get the toolbars updated + // in the application. The App is listening to selection change and i + // will use it here (even if not true). It's acceptable since changing + // this model data is pretty rare and only possible using the F4 dialog + MarkListHasChanged(); + } + } + + if(!m_bMoveProtect) + { + // protect size + if(const SfxBoolItem *pPoolItem = rAttr.GetItemIfSet(SID_ATTR_TRANSFORM_PROTECT_SIZE)) + { + const bool bProtSize(pPoolItem->GetValue()); + bool bChanged(false); + + for(size_t i = 0; i < nMarkCount; ++i) + { + pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if(pObj->IsResizeProtect() != bProtSize) + { + bChanged = true; + pObj->SetResizeProtect(bProtSize); + } + } + + if(bChanged) + { + m_bResizeProtect = bProtSize; + + // #i77187# see above + MarkListHasChanged(); + } + } + } + + EndUndo(); +} + + +bool SdrEditView::IsAlignPossible() const +{ // at least two selected objects, at least one of them movable + ForcePossibilities(); + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) return false; // nothing selected! + if (nCount==1) return m_bMoveAllowed; // align single object to page + return m_bOneOrMoreMovable; // otherwise: MarkCount>=2 +} + +void SdrEditView::AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert) +{ + if (eHor==SdrHorAlign::NONE && eVert==SdrVertAlign::NONE) + return; + + SortMarkedObjects(); + if (!GetMarkedObjectCount()) + return; + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + EndTextEditCurrentView(); + OUString aStr(GetDescriptionOfMarkedObjects()); + if (eHor==SdrHorAlign::NONE) + { + switch (eVert) + { + case SdrVertAlign::Top: + aStr = ImpGetDescriptionString(STR_EditAlignVTop); + break; + case SdrVertAlign::Bottom: + aStr = ImpGetDescriptionString(STR_EditAlignVBottom); + break; + case SdrVertAlign::Center: + aStr = ImpGetDescriptionString(STR_EditAlignVCenter); + break; + default: break; + } + } + else if (eVert==SdrVertAlign::NONE) + { + switch (eHor) + { + case SdrHorAlign::Left: + aStr = ImpGetDescriptionString(STR_EditAlignHLeft); + break; + case SdrHorAlign::Right: + aStr = ImpGetDescriptionString(STR_EditAlignHRight); + break; + case SdrHorAlign::Center: + aStr = ImpGetDescriptionString(STR_EditAlignHCenter); + break; + default: break; + } + } + else if (eHor==SdrHorAlign::Center && eVert==SdrVertAlign::Center) + { + aStr = ImpGetDescriptionString(STR_EditAlignCenter); + } + else + { + aStr = ImpGetDescriptionString(STR_EditAlign); + } + BegUndo(aStr); + } + + tools::Rectangle aBound; + const size_t nMarkCount=GetMarkedObjectCount(); + bool bHasFixed=false; + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + if (!aInfo.bMoveAllowed || pObj->IsMoveProtect()) + { + tools::Rectangle aObjRect(pObj->GetSnapRect()); + aBound.Union(aObjRect); + bHasFixed=true; + } + } + if (!bHasFixed) + { + if (nMarkCount==1) + { // align single object to page + const SdrObject* pObj=GetMarkedObjectByIndex(0); + const SdrPage* pPage=pObj->getSdrPageFromSdrObject(); + const SdrPageGridFrameList* pGFL=pPage->GetGridFrameList(GetSdrPageViewOfMarkedByIndex(0),&(pObj->GetSnapRect())); + const SdrPageGridFrame* pFrame=nullptr; + if (pGFL!=nullptr && pGFL->GetCount()!=0) + { // Writer + pFrame=&((*pGFL)[0]); + } + + if (pFrame!=nullptr) + { // Writer + aBound=pFrame->GetUserArea(); + } + else + { + aBound=tools::Rectangle(pPage->GetLeftBorder(),pPage->GetUpperBorder(), + pPage->GetWidth()-pPage->GetRightBorder(), + pPage->GetHeight()-pPage->GetLowerBorder()); + } + } + else + { + aBound=GetMarkedObjRect(); + } + } + Point aCenter(aBound.Center()); + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + if (aInfo.bMoveAllowed && !pObj->IsMoveProtect()) + { + tools::Long nXMov=0; + tools::Long nYMov=0; + tools::Rectangle aObjRect(pObj->GetSnapRect()); + switch (eVert) + { + case SdrVertAlign::Top : nYMov=aBound.Top() -aObjRect.Top() ; break; + case SdrVertAlign::Bottom: nYMov=aBound.Bottom()-aObjRect.Bottom() ; break; + case SdrVertAlign::Center: nYMov=aCenter.Y() -aObjRect.Center().Y(); break; + default: break; + } + switch (eHor) + { + case SdrHorAlign::Left : nXMov=aBound.Left() -aObjRect.Left() ; break; + case SdrHorAlign::Right : nXMov=aBound.Right() -aObjRect.Right() ; break; + case SdrHorAlign::Center: nXMov=aCenter.X() -aObjRect.Center().X(); break; + default: break; + } + if (nXMov!=0 || nYMov!=0) + { + // SdrEdgeObj needs an extra SdrUndoGeoObj since the + // connections may need to be saved + if( bUndo ) + { + if( dynamic_cast(pObj) ) + { + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + } + + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoMoveObject(*pObj,Size(nXMov,nYMov))); + } + + pObj->Move(Size(nXMov,nYMov)); + } + } + } + + if( bUndo ) + EndUndo(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdedtv2.cxx b/svx/source/svdraw/svdedtv2.cxx new file mode 100644 index 0000000000..8ef7afa195 --- /dev/null +++ b/svx/source/svdraw/svdedtv2.cxx @@ -0,0 +1,2238 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "svdfmtf.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +SdrObject* SdrEditView::GetMaxToTopObj(SdrObject* /*pObj*/) const +{ + return nullptr; +} + +SdrObject* SdrEditView::GetMaxToBtmObj(SdrObject* /*pObj*/) const +{ + return nullptr; +} + +void SdrEditView::ObjOrderChanged(SdrObject* /*pObj*/, size_t /*nOldPos*/, size_t /*nNewPos*/) +{ +} + +void SdrEditView::MovMarkedToTop() +{ + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) + return; + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(SvxResId(STR_EditMovToTop),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::MoveToTop); + + SortMarkedObjects(); + for (size_t nm=0; nmGetOrdNum(); + } + bool bChg=false; + SdrObjList* pOL0=nullptr; + size_t nNewPos=0; + for (size_t nm=nCount; nm>0;) + { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) + { + nNewPos = pOL->GetObjCount()-1; + pOL0=pOL; + } + const size_t nNowPos = pObj->GetOrdNumDirect(); + const tools::Rectangle& rBR=pObj->GetCurrentBoundRect(); + size_t nCmpPos = nNowPos+1; + SdrObject* pMaxObj=GetMaxToTopObj(pObj); + if (pMaxObj!=nullptr) + { + size_t nMaxPos=pMaxObj->GetOrdNum(); + if (nMaxPos!=0) + nMaxPos--; + if (nNewPos>nMaxPos) + nNewPos=nMaxPos; // neither go faster... + if (nNewPosGetObj(nCmpPos); + if (pCmpObj==nullptr) + { + OSL_FAIL("MovMarkedToTop(): Reference object not found."); + bEnd=true; + } + else if (pCmpObj==pMaxObj) + { + nNewPos=nCmpPos; + nNewPos--; + bEnd=true; + } + else if (rBR.Overlaps(pCmpObj->GetCurrentBoundRect())) + { + nNewPos=nCmpPos; + bEnd=true; + } + else + { + nCmpPos++; + } + } + if (nNowPos!=nNewPos) + { + bChg=true; + pOL->SetObjectOrdNum(nNowPos,nNewPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); + ObjOrderChanged(pObj,nNowPos,nNewPos); + } + nNewPos--; + } + + if( bUndo ) + EndUndo(); + + if (bChg) + MarkListHasChanged(); +} + +void SdrEditView::MovMarkedToBtm() +{ + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) + return; + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(SvxResId(STR_EditMovToBtm),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::MoveToBottom); + + SortMarkedObjects(); + for (size_t nm=0; nmGetOrdNum(); + } + + bool bChg=false; + SdrObjList* pOL0=nullptr; + size_t nNewPos=0; + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) + { + nNewPos=0; + pOL0=pOL; + } + const size_t nNowPos = pObj->GetOrdNumDirect(); + const tools::Rectangle& rBR=pObj->GetCurrentBoundRect(); + size_t nCmpPos = nNowPos; + if (nCmpPos>0) + --nCmpPos; + SdrObject* pMaxObj=GetMaxToBtmObj(pObj); + if (pMaxObj!=nullptr) + { + const size_t nMinPos=pMaxObj->GetOrdNum()+1; + if (nNewPosnNowPos) + nNewPos=nNowPos; // nor go in the other direction + } + bool bEnd=false; + // nNewPos in this case is the "maximum" position + // the object may reach without going faster than the object before + // it (multiple selection). + while (nCmpPos>nNewPos && !bEnd) + { + SdrObject* pCmpObj=pOL->GetObj(nCmpPos); + if (pCmpObj==nullptr) + { + OSL_FAIL("MovMarkedToBtm(): Reference object not found."); + bEnd=true; + } + else if (pCmpObj==pMaxObj) + { + nNewPos=nCmpPos; + nNewPos++; + bEnd=true; + } + else if (rBR.Overlaps(pCmpObj->GetCurrentBoundRect())) + { + nNewPos=nCmpPos; + bEnd=true; + } + else + { + nCmpPos--; + } + } + if (nNowPos!=nNewPos) + { + bChg=true; + pOL->SetObjectOrdNum(nNowPos,nNewPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); + ObjOrderChanged(pObj,nNowPos,nNewPos); + } + nNewPos++; + } + + if(bUndo) + EndUndo(); + + if(bChg) + MarkListHasChanged(); +} + +void SdrEditView::PutMarkedToTop() +{ + PutMarkedInFrontOfObj(nullptr); +} + +void SdrEditView::PutMarkedInFrontOfObj(const SdrObject* pRefObj) +{ + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) + return; + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditPutToTop),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::PutToTop); + + SortMarkedObjects(); + + if (pRefObj!=nullptr) + { + // Make "in front of the object" work, even if the + // selected objects are already in front of the other object + const size_t nRefMark=TryToFindMarkedObject(pRefObj); + SdrMark aRefMark; + if (nRefMark!=SAL_MAX_SIZE) + { + aRefMark=*GetSdrMarkByIndex(nRefMark); + GetMarkedObjectListWriteAccess().DeleteMark(nRefMark); + } + PutMarkedToBtm(); + if (nRefMark!=SAL_MAX_SIZE) + { + GetMarkedObjectListWriteAccess().InsertEntry(aRefMark); + SortMarkedObjects(); + } + } + for (size_t nm=0; nmGetOrdNum(); + } + bool bChg=false; + SdrObjList* pOL0=nullptr; + size_t nNewPos=0; + for (size_t nm=nCount; nm>0;) + { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + if (pObj!=pRefObj) + { + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) + { + nNewPos=pOL->GetObjCount()-1; + pOL0=pOL; + } + const size_t nNowPos=pObj->GetOrdNumDirect(); + SdrObject* pMaxObj=GetMaxToTopObj(pObj); + if (pMaxObj!=nullptr) + { + size_t nMaxOrd=pMaxObj->GetOrdNum(); // sadly doesn't work any other way + if (nMaxOrd>0) + nMaxOrd--; + if (nNewPos>nMaxOrd) + nNewPos=nMaxOrd; // neither go faster... + if (nNewPosgetParentSdrObjListFromSdrObject()==pObj->getParentSdrObjListFromSdrObject()) + { + const size_t nMaxOrd=pRefObj->GetOrdNum(); // sadly doesn't work any other way + if (nNewPos>nMaxOrd) + nNewPos=nMaxOrd; // neither go faster... + if (nNewPosSetObjectOrdNum(nNowPos,nNewPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); + ObjOrderChanged(pObj,nNowPos,nNewPos); + } + nNewPos--; + } // if (pObj!=pRefObj) + } // for loop over all selected objects + + if( bUndo ) + EndUndo(); + + if(bChg) + MarkListHasChanged(); +} + +void SdrEditView::PutMarkedToBtm() +{ + PutMarkedBehindObj(nullptr); +} + +void SdrEditView::PutMarkedBehindObj(const SdrObject* pRefObj) +{ + const size_t nCount=GetMarkedObjectCount(); + if (nCount==0) + return; + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(SvxResId(STR_EditPutToBtm),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::PutToBottom); + + SortMarkedObjects(); + if (pRefObj!=nullptr) + { + // Make "behind the object" work, even if the + // selected objects are already behind the other object + const size_t nRefMark=TryToFindMarkedObject(pRefObj); + SdrMark aRefMark; + if (nRefMark!=SAL_MAX_SIZE) + { + aRefMark=*GetSdrMarkByIndex(nRefMark); + GetMarkedObjectListWriteAccess().DeleteMark(nRefMark); + } + PutMarkedToTop(); + if (nRefMark!=SAL_MAX_SIZE) + { + GetMarkedObjectListWriteAccess().InsertEntry(aRefMark); + SortMarkedObjects(); + } + } + for (size_t nm=0; nmGetOrdNum(); + } + bool bChg=false; + SdrObjList* pOL0=nullptr; + size_t nNewPos=0; + for (size_t nm=0; nmGetMarkedSdrObj(); + if (pObj!=pRefObj) { + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) { + nNewPos=0; + pOL0=pOL; + } + const size_t nNowPos=pObj->GetOrdNumDirect(); + SdrObject* pMinObj=GetMaxToBtmObj(pObj); + if (pMinObj!=nullptr) { + const size_t nMinOrd=pMinObj->GetOrdNum()+1; // sadly doesn't work any differently + if (nNewPosnNowPos) nNewPos=nNowPos; // nor go into the other direction + } + if (pRefObj!=nullptr) { + if (pRefObj->getParentSdrObjListFromSdrObject()==pObj->getParentSdrObjListFromSdrObject()) { + const size_t nMinOrd=pRefObj->GetOrdNum(); // sadly doesn't work any differently + if (nNewPosnNowPos) nNewPos=nNowPos; // nor go into the other direction + } else { + nNewPos=nNowPos; // different PageView, so don't change + } + } + if (nNowPos!=nNewPos) { + bChg=true; + pOL->SetObjectOrdNum(nNowPos,nNewPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj,nNowPos,nNewPos)); + ObjOrderChanged(pObj,nNowPos,nNewPos); + } + nNewPos++; + } // if (pObj!=pRefObj) + } // for loop over all selected objects + + if(bUndo) + EndUndo(); + + if(bChg) + MarkListHasChanged(); + +} + +void SdrEditView::ReverseOrderOfMarked() +{ + SortMarkedObjects(); + const size_t nMarkCount=GetMarkedObjectCount(); + if (nMarkCount<=0) + return; + + bool bChg=false; + + bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditRevOrder),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::ReverseOrder); + + size_t a=0; + do { + // take into account selection across multiple PageViews + size_t b=a+1; + while (bGetObjList(); + size_t c=b; + if (aGetOrdNum(); + } + while (aGetOrdNumDirect(); + const size_t nOrd2=pObj2->GetOrdNumDirect(); + if( bUndo ) + { + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj1,nOrd1,nOrd2)); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectOrdNum(*pObj2,nOrd2-1,nOrd1)); + } + pOL->SetObjectOrdNum(nOrd1,nOrd2); + // Obj 2 has moved forward by one position, so now nOrd2-1 + pOL->SetObjectOrdNum(nOrd2-1,nOrd1); + // use Replace instead of SetOrdNum for performance reasons (recalculation of Ordnums) + ++a; + --c; + bChg=true; + } + a=b+1; + } while (agetParentSdrObjListFromSdrObject(); + SAL_WARN_IF(!pOL, "svx", "Object somehow has no ObjList"); + size_t nMax = pOL ? pOL->GetObjCount() : 0; + size_t nMin = 0; + const size_t nObjNum=pObj->GetOrdNum(); + SdrObject* pRestrict=GetMaxToTopObj(pObj); + if (pRestrict!=nullptr) { + const size_t nRestrict=pRestrict->GetOrdNum(); + if (nRestrictGetOrdNum(); + if (nRestrict>nMin) nMin=nRestrict; + } + m_bToTopPossible=nObjNumnMin; + } else { // multiple selection + SdrObjList* pOL0=nullptr; + size_t nPos0 = 0; + for (size_t nm = 0; !m_bToBtmPossible && nmgetParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) { + nPos0 = 0; + pOL0=pOL; + } + const size_t nPos = pObj->GetOrdNum(); + m_bToBtmPossible = nPos && (nPos-1 > nPos0); + nPos0 = nPos; + } + + pOL0=nullptr; + nPos0 = SAL_MAX_SIZE; + for (size_t nm=nCount; !m_bToTopPossible && nm>0; ) { // check 'bring to front' + --nm; + SdrObject* pObj=GetMarkedObjectByIndex(nm); + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) { + nPos0=pOL->GetObjCount(); + pOL0=pOL; + } + const size_t nPos = pObj->GetOrdNum(); + m_bToTopPossible = nPos+1 < nPos0; + nPos0=nPos; + } + } +} + + +// Combine + + +void SdrEditView::ImpCopyAttributes(const SdrObject* pSource, SdrObject* pDest) const +{ + if (pSource!=nullptr) { + SdrObjList* pOL=pSource->GetSubList(); + if (pOL!=nullptr && !pSource->Is3DObj()) { // get first non-group object from group + SdrObjListIter aIter(pOL,SdrIterMode::DeepNoGroups); + pSource=aIter.Next(); + } + } + + if(!(pSource && pDest)) + return; + + SfxItemSetFixed aSet(GetModel().GetItemPool()); + + aSet.Put(pSource->GetMergedItemSet()); + + pDest->ClearMergedItem(); + pDest->SetMergedItemSet(aSet); + + pDest->NbcSetLayer(pSource->GetLayer()); + pDest->NbcSetStyleSheet(pSource->GetStyleSheet(), true); +} + +bool SdrEditView::ImpCanConvertForCombine1(const SdrObject* pObj) +{ + // new condition IsLine() to be able to combine simple Lines + bool bIsLine(false); + + const SdrPathObj* pPath = dynamic_cast< const SdrPathObj*>( pObj ); + + if(pPath) + { + bIsLine = pPath->IsLine(); + } + + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + + return (aInfo.bCanConvToPath || aInfo.bCanConvToPoly || bIsLine); +} + +bool SdrEditView::ImpCanConvertForCombine(const SdrObject* pObj) +{ + SdrObjList* pOL = pObj->GetSubList(); + + if(pOL && !pObj->Is3DObj()) + { + SdrObjListIter aIter(pOL, SdrIterMode::DeepNoGroups); + + while(aIter.IsMore()) + { + SdrObject* pObj1 = aIter.Next(); + + // all members of a group have to be convertible + if(!ImpCanConvertForCombine1(pObj1)) + { + return false; + } + } + } + else + { + if(!ImpCanConvertForCombine1(pObj)) + { + return false; + } + } + + return true; +} + +basegfx::B2DPolyPolygon SdrEditView::ImpGetPolyPolygon1(const SdrObject* pObj) +{ + basegfx::B2DPolyPolygon aRetval; + const SdrPathObj* pPath = dynamic_cast( pObj ); + + if(pPath && !pObj->GetOutlinerParaObject()) + { + aRetval = pPath->GetPathPoly(); + } + else + { + rtl::Reference pConvObj = pObj->ConvertToPolyObj(true/*bCombine*/, false); + + if(pConvObj) + { + SdrObjList* pOL = pConvObj->GetSubList(); + + if(pOL) + { + SdrObjListIter aIter(pOL, SdrIterMode::DeepNoGroups); + + while(aIter.IsMore()) + { + SdrObject* pObj1 = aIter.Next(); + pPath = dynamic_cast( pObj1 ); + + if(pPath) + { + aRetval.append(pPath->GetPathPoly()); + } + } + } + else + { + pPath = dynamic_cast( pConvObj.get() ); + + if(pPath) + { + aRetval = pPath->GetPathPoly(); + } + } + } + } + + return aRetval; +} + +basegfx::B2DPolyPolygon SdrEditView::ImpGetPolyPolygon(const SdrObject* pObj) +{ + SdrObjList* pOL = pObj->GetSubList(); + + if(pOL && !pObj->Is3DObj()) + { + basegfx::B2DPolyPolygon aRetval; + SdrObjListIter aIter(pOL, SdrIterMode::DeepNoGroups); + + while(aIter.IsMore()) + { + SdrObject* pObj1 = aIter.Next(); + aRetval.append(ImpGetPolyPolygon1(pObj1)); + } + + return aRetval; + } + else + { + return ImpGetPolyPolygon1(pObj); + } +} + +basegfx::B2DPolygon SdrEditView::ImpCombineToSinglePolygon(const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + const sal_uInt32 nPolyCount(rPolyPolygon.count()); + + if(0 == nPolyCount) + { + return basegfx::B2DPolygon(); + } + else if(1 == nPolyCount) + { + return rPolyPolygon.getB2DPolygon(0); + } + else + { + basegfx::B2DPolygon aRetval(rPolyPolygon.getB2DPolygon(0)); + + for(sal_uInt32 a(1); a < nPolyCount; a++) + { + basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(a)); + + if(aRetval.count()) + { + if(aCandidate.count()) + { + const basegfx::B2DPoint aCA(aCandidate.getB2DPoint(0)); + const basegfx::B2DPoint aCB(aCandidate.getB2DPoint(aCandidate.count() - 1)); + const basegfx::B2DPoint aRA(aRetval.getB2DPoint(0)); + const basegfx::B2DPoint aRB(aRetval.getB2DPoint(aRetval.count() - 1)); + + const double fRACA(basegfx::B2DVector(aCA - aRA).getLength()); + const double fRACB(basegfx::B2DVector(aCB - aRA).getLength()); + const double fRBCA(basegfx::B2DVector(aCA - aRB).getLength()); + const double fRBCB(basegfx::B2DVector(aCB - aRB).getLength()); + + const double fSmallestRA(std::min(fRACA, fRACB)); + const double fSmallestRB(std::min(fRBCA, fRBCB)); + + if(fSmallestRA < fSmallestRB) + { + // flip result + aRetval.flip(); + } + + const double fSmallestCA(std::min(fRACA, fRBCA)); + const double fSmallestCB(std::min(fRACB, fRBCB)); + + if(fSmallestCB < fSmallestCA) + { + // flip candidate + aCandidate.flip(); + } + + // append candidate to retval + aRetval.append(aCandidate); + } + } + else + { + aRetval = aCandidate; + } + } + + return aRetval; + } +} + +namespace { + +// for distribution dialog function +struct ImpDistributeEntry +{ + SdrObject* mpObj; + sal_Int32 mnPos; + sal_Int32 mnLength; +}; + +} + +typedef std::vector ImpDistributeEntryList; + +void SdrEditView::DistributeMarkedObjects(sal_uInt16 SlotID) +{ + const size_t nMark(GetMarkedObjectCount()); + + if(nMark <= 2) + return; + + SvxDistributeHorizontal eHor = SvxDistributeHorizontal::NONE; + SvxDistributeVertical eVer = SvxDistributeVertical::NONE; + + switch (SlotID) + { + case SID_DISTRIBUTE_HLEFT: eHor = SvxDistributeHorizontal::Left; break; + case SID_DISTRIBUTE_HCENTER: eHor = SvxDistributeHorizontal::Center; break; + case SID_DISTRIBUTE_HDISTANCE: eHor = SvxDistributeHorizontal::Distance; break; + case SID_DISTRIBUTE_HRIGHT: eHor = SvxDistributeHorizontal::Right; break; + case SID_DISTRIBUTE_VTOP: eVer = SvxDistributeVertical::Top; break; + case SID_DISTRIBUTE_VCENTER: eVer = SvxDistributeVertical::Center; break; + case SID_DISTRIBUTE_VDISTANCE: eVer = SvxDistributeVertical::Distance; break; + case SID_DISTRIBUTE_VBOTTOM: eVer = SvxDistributeVertical::Bottom; break; + } + + ImpDistributeEntryList aEntryList; + ImpDistributeEntryList::iterator itEntryList; + sal_uInt32 nFullLength; + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(); + + if(eHor != SvxDistributeHorizontal::NONE) + { + // build sorted entry list + nFullLength = 0; + + for( size_t a = 0; a < nMark; ++a ) + { + SdrMark* pMark = GetSdrMarkByIndex(a); + ImpDistributeEntry aNew; + + aNew.mpObj = pMark->GetMarkedSdrObj(); + + switch(eHor) + { + case SvxDistributeHorizontal::Left: + { + aNew.mnPos = aNew.mpObj->GetSnapRect().Left(); + break; + } + case SvxDistributeHorizontal::Center: + { + aNew.mnPos = (aNew.mpObj->GetSnapRect().Right() + aNew.mpObj->GetSnapRect().Left()) / 2; + break; + } + case SvxDistributeHorizontal::Distance: + { + aNew.mnLength = aNew.mpObj->GetSnapRect().GetWidth() + 1; + nFullLength += aNew.mnLength; + aNew.mnPos = (aNew.mpObj->GetSnapRect().Right() + aNew.mpObj->GetSnapRect().Left()) / 2; + break; + } + case SvxDistributeHorizontal::Right: + { + aNew.mnPos = aNew.mpObj->GetSnapRect().Right(); + break; + } + default: break; + } + + itEntryList = std::find_if(aEntryList.begin(), aEntryList.end(), + [&aNew](const ImpDistributeEntry& rEntry) { return rEntry.mnPos >= aNew.mnPos; }); + if ( itEntryList < aEntryList.end() ) + aEntryList.insert( itEntryList, aNew ); + else + aEntryList.push_back( aNew ); + } + + if(eHor == SvxDistributeHorizontal::Distance) + { + // calculate room in-between + sal_Int32 nWidth = GetAllMarkedBoundRect().GetWidth() + 1; + double fStepWidth = (static_cast(nWidth) - static_cast(nFullLength)) / static_cast(aEntryList.size() - 1); + double fStepStart = static_cast(aEntryList[ 0 ].mnPos); + fStepStart += fStepWidth + static_cast((aEntryList[ 0 ].mnLength + aEntryList[ 1 ].mnLength) / 2); + + // move entries 1..n-1 + for( size_t i = 1, n = aEntryList.size()-1; i < n; ++i ) + { + ImpDistributeEntry& rCurr = aEntryList[ i ]; + ImpDistributeEntry& rNext = aEntryList[ i + 1]; + sal_Int32 nDelta = static_cast(fStepStart + 0.5) - rCurr.mnPos; + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*rCurr.mpObj)); + rCurr.mpObj->Move(Size(nDelta, 0)); + fStepStart += fStepWidth + static_cast((rCurr.mnLength + rNext.mnLength) / 2); + } + } + else + { + // calculate distances + sal_Int32 nWidth = aEntryList[ aEntryList.size() - 1 ].mnPos - aEntryList[ 0 ].mnPos; + double fStepWidth = static_cast(nWidth) / static_cast(aEntryList.size() - 1); + double fStepStart = static_cast(aEntryList[ 0 ].mnPos); + fStepStart += fStepWidth; + + // move entries 1..n-1 + for( size_t i = 1 ; i < aEntryList.size()-1 ; ++i ) + { + ImpDistributeEntry& rCurr = aEntryList[ i ]; + sal_Int32 nDelta = static_cast(fStepStart + 0.5) - rCurr.mnPos; + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*rCurr.mpObj)); + rCurr.mpObj->Move(Size(nDelta, 0)); + fStepStart += fStepWidth; + } + } + + // clear list + aEntryList.clear(); + } + + if(eVer != SvxDistributeVertical::NONE) + { + // build sorted entry list + nFullLength = 0; + + for( size_t a = 0; a < nMark; ++a ) + { + SdrMark* pMark = GetSdrMarkByIndex(a); + ImpDistributeEntry aNew; + + aNew.mpObj = pMark->GetMarkedSdrObj(); + + switch(eVer) + { + case SvxDistributeVertical::Top: + { + aNew.mnPos = aNew.mpObj->GetSnapRect().Top(); + break; + } + case SvxDistributeVertical::Center: + { + aNew.mnPos = (aNew.mpObj->GetSnapRect().Bottom() + aNew.mpObj->GetSnapRect().Top()) / 2; + break; + } + case SvxDistributeVertical::Distance: + { + aNew.mnLength = aNew.mpObj->GetSnapRect().GetHeight() + 1; + nFullLength += aNew.mnLength; + aNew.mnPos = (aNew.mpObj->GetSnapRect().Bottom() + aNew.mpObj->GetSnapRect().Top()) / 2; + break; + } + case SvxDistributeVertical::Bottom: + { + aNew.mnPos = aNew.mpObj->GetSnapRect().Bottom(); + break; + } + default: break; + } + + itEntryList = std::find_if(aEntryList.begin(), aEntryList.end(), + [&aNew](const ImpDistributeEntry& rEntry) { return rEntry.mnPos >= aNew.mnPos; }); + if ( itEntryList < aEntryList.end() ) + aEntryList.insert( itEntryList, aNew ); + else + aEntryList.push_back( aNew ); + } + + if(eVer == SvxDistributeVertical::Distance) + { + // calculate room in-between + sal_Int32 nHeight = GetAllMarkedBoundRect().GetHeight() + 1; + double fStepWidth = (static_cast(nHeight) - static_cast(nFullLength)) / static_cast(aEntryList.size() - 1); + double fStepStart = static_cast(aEntryList[ 0 ].mnPos); + fStepStart += fStepWidth + static_cast((aEntryList[ 0 ].mnLength + aEntryList[ 1 ].mnLength) / 2); + + // move entries 1..n-1 + for( size_t i = 1, n = aEntryList.size()-1; i < n; ++i) + { + ImpDistributeEntry& rCurr = aEntryList[ i ]; + ImpDistributeEntry& rNext = aEntryList[ i + 1 ]; + sal_Int32 nDelta = static_cast(fStepStart + 0.5) - rCurr.mnPos; + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*rCurr.mpObj)); + rCurr.mpObj->Move(Size(0, nDelta)); + fStepStart += fStepWidth + static_cast((rCurr.mnLength + rNext.mnLength) / 2); + } + } + else + { + // calculate distances + sal_Int32 nHeight = aEntryList[ aEntryList.size() - 1 ].mnPos - aEntryList[ 0 ].mnPos; + double fStepWidth = static_cast(nHeight) / static_cast(aEntryList.size() - 1); + double fStepStart = static_cast(aEntryList[ 0 ].mnPos); + fStepStart += fStepWidth; + + // move entries 1..n-1 + for(size_t i = 1, n = aEntryList.size()-1; i < n; ++i) + { + ImpDistributeEntry& rCurr = aEntryList[ i ]; + sal_Int32 nDelta = static_cast(fStepStart + 0.5) - rCurr.mnPos; + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*rCurr.mpObj)); + rCurr.mpObj->Move(Size(0, nDelta)); + fStepStart += fStepWidth; + } + } + + // clear list + aEntryList.clear(); + } + + // UNDO-Comment and end of UNDO + GetModel().SetUndoComment(SvxResId(STR_DistributeMarkedObjects)); + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::MergeMarkedObjects(SdrMergeMode eMode) +{ + // #i73441# check content + if(!AreObjectsMarked()) + return; + + SdrMarkList aRemove; + SortMarkedObjects(); + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(); + + size_t nInsPos = SAL_MAX_SIZE; + const SdrObject* pAttrObj = nullptr; + basegfx::B2DPolyPolygon aMergePolyPolygonA; + basegfx::B2DPolyPolygon aMergePolyPolygonB; + + SdrObjList* pInsOL = nullptr; + SdrPageView* pInsPV = nullptr; + bool bFirstObjectComplete(false); + + // make sure selected objects are contour objects + // since now basegfx::utils::adaptiveSubdivide() is used, it is no longer + // necessary to use ConvertMarkedToPolyObj which will subdivide curves using the old + // mechanisms. In a next step the polygon clipper will even be able to clip curves... + // ConvertMarkedToPolyObj(true); + ConvertMarkedToPathObj(true); + OSL_ENSURE(AreObjectsMarked(), "no more objects selected after preparations (!)"); + + for(size_t a=0; aGetMarkedSdrObj(); + + if(ImpCanConvertForCombine(pObj)) + { + if(!pAttrObj) + pAttrObj = pObj; + + nInsPos = pObj->GetOrdNum() + 1; + pInsPV = pM->GetPageView(); + pInsOL = pObj->getParentSdrObjListFromSdrObject(); + + // #i76891# use single iteration from SJ here which works on SdrObjects and takes + // groups into account by itself + SdrObjListIter aIter(*pObj, SdrIterMode::DeepWithGroups); + + while(aIter.IsMore()) + { + SdrObject* pCandidate = aIter.Next(); + SdrPathObj* pPathObj = dynamic_cast( pCandidate ); + if(pPathObj) + { + basegfx::B2DPolyPolygon aTmpPoly(pPathObj->GetPathPoly()); + + // #i76891# unfortunately ConvertMarkedToPathObj has converted all + // involved polygon data to curve segments, even if not necessary. + // It is better to try to reduce to more simple polygons. + aTmpPoly = basegfx::utils::simplifyCurveSegments(aTmpPoly); + + // for each part polygon as preparation, remove self-intersections + // correct orientations and get rid of possible neutral polygons. + aTmpPoly = basegfx::utils::prepareForPolygonOperation(aTmpPoly); + + if(!bFirstObjectComplete) + { + // #i111987# Also need to collect ORed source shape when more than + // a single polygon is involved + if(aMergePolyPolygonA.count()) + { + aMergePolyPolygonA = basegfx::utils::solvePolygonOperationOr(aMergePolyPolygonA, aTmpPoly); + } + else + { + aMergePolyPolygonA = aTmpPoly; + } + } + else + { + if(aMergePolyPolygonB.count()) + { + // to topologically correctly collect the 2nd polygon + // group it is necessary to OR the parts (each is seen as + // XOR-FillRule polygon and they are drawn over each-other) + aMergePolyPolygonB = basegfx::utils::solvePolygonOperationOr(aMergePolyPolygonB, aTmpPoly); + } + else + { + aMergePolyPolygonB = aTmpPoly; + } + } + } + } + + // was there something added to the first polygon? + if(!bFirstObjectComplete && aMergePolyPolygonA.count()) + { + bFirstObjectComplete = true; + } + + // move object to temporary delete list + aRemove.InsertEntry(SdrMark(pObj, pM->GetPageView())); + } + } + + switch(eMode) + { + case SdrMergeMode::Merge: + { + // merge all contained parts (OR) + aMergePolyPolygonA = basegfx::utils::solvePolygonOperationOr(aMergePolyPolygonA, aMergePolyPolygonB); + break; + } + case SdrMergeMode::Subtract: + { + // Subtract B from A + aMergePolyPolygonA = basegfx::utils::solvePolygonOperationDiff(aMergePolyPolygonA, aMergePolyPolygonB); + break; + } + case SdrMergeMode::Intersect: + { + // AND B and A + aMergePolyPolygonA = basegfx::utils::solvePolygonOperationAnd(aMergePolyPolygonA, aMergePolyPolygonB); + break; + } + } + + // #i73441# check insert list before taking actions + if(pInsOL) + { + rtl::Reference pPath = new SdrPathObj(pAttrObj->getSdrModelFromSdrObject(), SdrObjKind::PathFill, std::move(aMergePolyPolygonA)); + ImpCopyAttributes(pAttrObj, pPath.get()); + pInsOL->InsertObject(pPath.get(), nInsPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pPath)); + + // #i124760# To have a correct selection with only the new object it is necessary to + // unmark all objects first. If not doing so, there may remain invalid pointers to objects + // TTTT:Not needed for aw080 (!) + UnmarkAllObj(pInsPV); + + MarkObj(pPath.get(), pInsPV, false, true); + } + + aRemove.ForceSort(); + switch(eMode) + { + case SdrMergeMode::Merge: + { + SetUndoComment( + SvxResId(STR_EditMergeMergePoly), + aRemove.GetMarkDescription()); + break; + } + case SdrMergeMode::Subtract: + { + SetUndoComment( + SvxResId(STR_EditMergeSubstractPoly), + aRemove.GetMarkDescription()); + break; + } + case SdrMergeMode::Intersect: + { + SetUndoComment( + SvxResId(STR_EditMergeIntersectPoly), + aRemove.GetMarkDescription()); + break; + } + } + DeleteMarkedList(aRemove); + + if( bUndo ) + EndUndo(); +} + +void SdrEditView::EqualizeMarkedObjects(bool bWidth) +{ + const SdrMarkList& rMarkList = GetMarkedObjectList(); + size_t nMarked = rMarkList.GetMarkCount(); + + if (nMarked < 2) + return; + + size_t nLastSelected = 0; + sal_Int64 nLastSelectedTime = rMarkList.GetMark(0)->getTimeStamp(); + for (size_t a = 1; a < nMarked; ++a) + { + sal_Int64 nCandidateTime = rMarkList.GetMark(a)->getTimeStamp(); + if (nCandidateTime > nLastSelectedTime) + { + nLastSelectedTime = nCandidateTime; + nLastSelected = a; + } + } + + SdrObject* pLastSelectedObj = rMarkList.GetMark(nLastSelected)->GetMarkedSdrObj(); + Size aLastRectSize(pLastSelectedObj->GetLogicRect().GetSize()); + + const bool bUndo = IsUndoEnabled(); + + if (bUndo) + BegUndo(); + + for (size_t a = 0; a < nMarked; ++a) + { + if (a == nLastSelected) + continue; + SdrMark* pM = rMarkList.GetMark(a); + SdrObject* pObj = pM->GetMarkedSdrObj(); + tools::Rectangle aLogicRect(pObj->GetLogicRect()); + Size aLogicRectSize(aLogicRect.GetSize()); + if (bWidth) + aLogicRectSize.setWidth( aLastRectSize.Width() ); + else + aLogicRectSize.setHeight( aLastRectSize.Height() ); + aLogicRect.SetSize(aLogicRectSize); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + pObj->SetLogicRect(aLogicRect); + } + + SetUndoComment( + SvxResId(bWidth ? STR_EqualizeWidthMarkedObjects : STR_EqualizeHeightMarkedObjects), + rMarkList.GetMarkDescription()); + + if (bUndo) + EndUndo(); +} + +void SdrEditView::CombineMarkedTextObjects() +{ + SdrPageView* pPageView = GetSdrPageView(); + if ( !pPageView || pPageView->IsLayerLocked( GetActiveLayer() ) ) + return; + + bool bUndo = IsUndoEnabled(); + + // Undo-String will be set later + if ( bUndo ) + BegUndo(); + + SdrOutliner& rDrawOutliner = getSdrModelFromSdrView().GetDrawOutliner(); + + SdrObjListIter aIter( GetMarkedObjectList(), SdrIterMode::Flat); + while ( aIter.IsMore() ) + { + SdrObject* pObj = aIter.Next(); + SdrTextObj* pTextObj = DynCastSdrTextObj( pObj ); + const OutlinerParaObject* pOPO = pTextObj ? pTextObj->GetOutlinerParaObject() : nullptr; + if ( pOPO && pTextObj->IsTextFrame() + && pTextObj->GetObjIdentifier() == SdrObjKind::Text // not callouts (OBJ_CAPTION) + && !pTextObj->IsOutlText() // not impress presentation objects + && pTextObj->GetMergedItem(XATTR_FORMTXTSTYLE).GetValue() == XFormTextStyle::NONE // not Fontwork + ) + { + // if the last paragraph does not end in paragraph-end punctuation (ignoring whitespace), + // assume this text should be added to the end of the last paragraph, instead of starting a new paragraph. + const sal_Int32 nPara = rDrawOutliner.GetParagraphCount(); + const OUString sLastPara = nPara ? rDrawOutliner.GetText( rDrawOutliner.GetParagraph( nPara - 1 ) ) : ""; + sal_Int32 n = sLastPara.getLength(); + while ( n && unicode::isWhiteSpace( sLastPara[--n] ) ) + ; + //TODO: find way to use Locale to identify sentence final punctuation. Copied IsSentenceAtEnd() from autofmt.cxx + const bool bAppend = !n || ( sLastPara[n] != '.' && sLastPara[n] != '?' && sLastPara[n] != '!' ); + rDrawOutliner.AddText( *pOPO, bAppend ); + } + else + { + // Unmark non-textboxes, because all marked objects are deleted at the end. AdjustMarkHdl later. + MarkObj(pObj, pPageView, /*bUnmark=*/true, /*bImpNoSetMarkHdl=*/true); + } + } + + MarkListHasChanged(); + AdjustMarkHdl(); + + if ( GetMarkedObjectCount() > 1 ) + { + rtl::Reference pReplacement = new SdrRectObj( getSdrModelFromSdrView(), SdrObjKind::Text ); + pReplacement->SetOutlinerParaObject( rDrawOutliner.CreateParaObject() ); + pReplacement->SetSnapRect( GetMarkedObjRect() ); + + const SdrInsertFlags nFlags = SdrInsertFlags::DONTMARK | SdrInsertFlags::SETDEFLAYER; + if ( InsertObjectAtView( pReplacement.get(), *pPageView, nFlags ) ) + DeleteMarkedObj(); + } + + if ( bUndo ) + EndUndo(); + + return; +} + +void SdrEditView::CombineMarkedObjects(bool bNoPolyPoly) +{ + // #105899# Start of Combine-Undo put to front, else ConvertMarkedToPolyObj would + // create a 2nd Undo-action and Undo-Comment. + + bool bUndo = IsUndoEnabled(); + + // Undo-String will be set later + if( bUndo ) + BegUndo("", "", bNoPolyPoly ? SdrRepeatFunc::CombineOnePoly : SdrRepeatFunc::CombinePolyPoly); + + // #105899# First, guarantee that all objects are converted to polyobjects, + // especially for SdrGrafObj with bitmap filling this is necessary to not + // lose the bitmap filling. + + // #i12392# + // ConvertMarkedToPolyObj was too strong here, it will lose quality and + // information when curve objects are combined. This can be replaced by + // using ConvertMarkedToPathObj without changing the previous fix. + + // #i21250# + // Instead of simply passing true as LineToArea, use bNoPolyPoly as info + // if this command is a 'Combine' or a 'Connect' command. On Connect it's true. + // To not concert line segments with a set line width to polygons in that case, + // use this info. Do not convert LineToArea on Connect commands. + // ConvertMarkedToPathObj(!bNoPolyPoly); + + // This is used for Combine and Connect. In no case it is necessary to force + // the content to curve, but it is also not good to force to polygons. Thus, + // curve is the less information losing one. Remember: This place is not + // used for merge. + // LineToArea is never necessary, both commands are able to take over the + // set line style and to display it correctly. Thus, i will use a + // ConvertMarkedToPathObj with a false in any case. Only drawback is that + // simple polygons will be changed to curves, but with no information loss. + ConvertMarkedToPathObj(false /* bLineToArea */); + + // continue as before + basegfx::B2DPolyPolygon aPolyPolygon; + SdrObjList* pCurrentOL = nullptr; + SdrMarkList aRemoveBuffer; + + SortMarkedObjects(); + size_t nInsPos = SAL_MAX_SIZE; + SdrObjList* pInsOL = nullptr; + SdrPageView* pInsPV = nullptr; + const SdrObject* pAttrObj = nullptr; + + for(size_t a = GetMarkedObjectCount(); a; ) + { + --a; + SdrMark* pM = GetSdrMarkByIndex(a); + SdrObject* pObj = pM->GetMarkedSdrObj(); + SdrObjList* pThisOL = pObj->getParentSdrObjListFromSdrObject(); + + if(pCurrentOL != pThisOL) + { + pCurrentOL = pThisOL; + } + + if(ImpCanConvertForCombine(pObj)) + { + // remember objects to be able to copy attributes + pAttrObj = pObj; + + // unfortunately ConvertMarkedToPathObj has converted all + // involved polygon data to curve segments, even if not necessary. + // It is better to try to reduce to more simple polygons. + basegfx::B2DPolyPolygon aTmpPoly(basegfx::utils::simplifyCurveSegments(ImpGetPolyPolygon(pObj))); + aPolyPolygon.insert(0, aTmpPoly); + + if(!pInsOL) + { + nInsPos = pObj->GetOrdNum() + 1; + pInsPV = pM->GetPageView(); + pInsOL = pObj->getParentSdrObjListFromSdrObject(); + } + + aRemoveBuffer.InsertEntry(SdrMark(pObj, pM->GetPageView())); + } + } + + if(bNoPolyPoly) + { + basegfx::B2DPolygon aCombinedPolygon(ImpCombineToSinglePolygon(aPolyPolygon)); + aPolyPolygon.clear(); + aPolyPolygon.append(aCombinedPolygon); + } + + const sal_uInt32 nPolyCount(aPolyPolygon.count()); + + if (nPolyCount && pAttrObj) + { + SdrObjKind eKind = SdrObjKind::PathFill; + + if(nPolyCount > 1) + { + aPolyPolygon.setClosed(true); + } + else + { + // check for Polyline + const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(0)); + const sal_uInt32 nPointCount(aPolygon.count()); + + if(nPointCount <= 2) + { + eKind = SdrObjKind::PathLine; + } + else + { + if(!aPolygon.isClosed()) + { + const basegfx::B2DPoint aPointA(aPolygon.getB2DPoint(0)); + const basegfx::B2DPoint aPointB(aPolygon.getB2DPoint(nPointCount - 1)); + const double fDistance(basegfx::B2DVector(aPointB - aPointA).getLength()); + const double fJoinTolerance(10.0); + + if(fDistance < fJoinTolerance) + { + aPolyPolygon.setClosed(true); + } + else + { + eKind = SdrObjKind::PathLine; + } + } + } + } + + rtl::Reference pPath = new SdrPathObj(pAttrObj->getSdrModelFromSdrObject(), eKind, std::move(aPolyPolygon)); + + // attributes of the lowest object + ImpCopyAttributes(pAttrObj, pPath.get()); + + // If LineStyle of pAttrObj is drawing::LineStyle_NONE force to drawing::LineStyle_SOLID to make visible. + const drawing::LineStyle eLineStyle = pAttrObj->GetMergedItem(XATTR_LINESTYLE).GetValue(); + const drawing::FillStyle eFillStyle = pAttrObj->GetMergedItem(XATTR_FILLSTYLE).GetValue(); + + // Take fill style/closed state of pAttrObj in account when deciding to change the line style + bool bIsClosedPathObj = false; + if (auto pPathObj = dynamic_cast(pAttrObj)) + if (pPathObj->IsClosed()) + bIsClosedPathObj = true; + + if(drawing::LineStyle_NONE == eLineStyle && (drawing::FillStyle_NONE == eFillStyle || !bIsClosedPathObj)) + { + pPath->SetMergedItem(XLineStyleItem(drawing::LineStyle_SOLID)); + } + + pInsOL->InsertObject(pPath.get(),nInsPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pPath)); + + // Here was a severe error: Without UnmarkAllObj, the new object was marked + // additionally to the two ones which are deleted below. As long as those are + // in the UNDO there is no problem, but as soon as they get deleted, the + // MarkList will contain deleted objects -> GPF. + UnmarkAllObj(pInsPV); + MarkObj(pPath.get(), pInsPV, false, true); + } + + // build an UndoComment from the objects actually used + aRemoveBuffer.ForceSort(); // important for remove (see below) + if( bUndo ) + SetUndoComment(SvxResId(bNoPolyPoly?STR_EditCombine_OnePoly:STR_EditCombine_PolyPoly),aRemoveBuffer.GetMarkDescription()); + + // remove objects actually used from the list + DeleteMarkedList(aRemoveBuffer); + if( bUndo ) + EndUndo(); +} + + +// Dismantle + + +bool SdrEditView::ImpCanDismantle(const basegfx::B2DPolyPolygon& rPpolyPolygon, bool bMakeLines) +{ + bool bCan(false); + const sal_uInt32 nPolygonCount(rPpolyPolygon.count()); + + if(nPolygonCount >= 2) + { + // #i69172# dismantle makes sense with 2 or more polygons in a polyPolygon + bCan = true; + } + else if(bMakeLines && 1 == nPolygonCount) + { + // #i69172# ..or with at least 2 edges (curves or lines) + const basegfx::B2DPolygon& aPolygon(rPpolyPolygon.getB2DPolygon(0)); + const sal_uInt32 nPointCount(aPolygon.count()); + + if(nPointCount > 2) + { + bCan = true; + } + } + + return bCan; +} + +bool SdrEditView::ImpCanDismantle(const SdrObject* pObj, bool bMakeLines) +{ + bool bOtherObjs(false); // true=objects other than PathObj's existent + bool bMin1PolyPoly(false); // true=at least 1 tools::PolyPolygon with more than one Polygon existent + SdrObjList* pOL = pObj->GetSubList(); + + if(pOL) + { + // group object -- check all members if they're PathObjs + SdrObjListIter aIter(pOL, SdrIterMode::DeepNoGroups); + + while(aIter.IsMore() && !bOtherObjs) + { + const SdrObject* pObj1 = aIter.Next(); + const SdrPathObj* pPath = dynamic_cast( pObj1 ); + + if(pPath) + { + if(ImpCanDismantle(pPath->GetPathPoly(), bMakeLines)) + { + bMin1PolyPoly = true; + } + + SdrObjTransformInfoRec aInfo; + pObj1->TakeObjInfo(aInfo); + + if(!aInfo.bCanConvToPath) + { + // happens e. g. in the case of FontWork + bOtherObjs = true; + } + } + else + { + bOtherObjs = true; + } + } + } + else + { + const SdrPathObj* pPath = dynamic_cast(pObj); + const SdrObjCustomShape* pCustomShape = dynamic_cast(pObj); + + // #i37011# + if(pPath) + { + if(ImpCanDismantle(pPath->GetPathPoly(),bMakeLines)) + { + bMin1PolyPoly = true; + } + + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + + // new condition IsLine() to be able to break simple Lines + if(!(aInfo.bCanConvToPath || aInfo.bCanConvToPoly) && !pPath->IsLine()) + { + // happens e. g. in the case of FontWork + bOtherObjs = true; + } + } + else if(pCustomShape) + { + if(bMakeLines) + { + // allow break command + bMin1PolyPoly = true; + } + } + else + { + bOtherObjs = true; + } + } + return bMin1PolyPoly && !bOtherObjs; +} + +void SdrEditView::ImpDismantleOneObject(const SdrObject* pObj, SdrObjList& rOL, size_t& rPos, SdrPageView* pPV, bool bMakeLines) +{ + const SdrPathObj* pSrcPath = dynamic_cast( pObj ); + const SdrObjCustomShape* pCustomShape = dynamic_cast( pObj ); + + const bool bUndo = IsUndoEnabled(); + + if(pSrcPath) + { + // #i74631# redesigned due to XpolyPolygon removal and explicit constructors + SdrObject* pLast = nullptr; // to be able to apply OutlinerParaObject + const basegfx::B2DPolyPolygon& rPolyPolygon(pSrcPath->GetPathPoly()); + const sal_uInt32 nPolyCount(rPolyPolygon.count()); + + for(sal_uInt32 a(0); a < nPolyCount; a++) + { + const basegfx::B2DPolygon& rCandidate(rPolyPolygon.getB2DPolygon(a)); + const sal_uInt32 nPointCount(rCandidate.count()); + + if(!bMakeLines || nPointCount < 2) + { + rtl::Reference pPath = new SdrPathObj( + pSrcPath->getSdrModelFromSdrObject(), + pSrcPath->GetObjIdentifier(), + basegfx::B2DPolyPolygon(rCandidate)); + ImpCopyAttributes(pSrcPath, pPath.get()); + pLast = pPath.get(); + rOL.InsertObject(pPath.get(), rPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pPath, true)); + MarkObj(pPath.get(), pPV, false, true); + rPos++; + } + else + { + const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1); + + for(sal_uInt32 b(0); b < nLoopCount; b++) + { + SdrObjKind eKind(SdrObjKind::PolyLine); + basegfx::B2DPolygon aNewPolygon; + const sal_uInt32 nNextIndex((b + 1) % nPointCount); + + aNewPolygon.append(rCandidate.getB2DPoint(b)); + + if(rCandidate.areControlPointsUsed()) + { + aNewPolygon.appendBezierSegment( + rCandidate.getNextControlPoint(b), + rCandidate.getPrevControlPoint(nNextIndex), + rCandidate.getB2DPoint(nNextIndex)); + eKind = SdrObjKind::PathLine; + } + else + { + aNewPolygon.append(rCandidate.getB2DPoint(nNextIndex)); + } + + rtl::Reference pPath = new SdrPathObj( + pSrcPath->getSdrModelFromSdrObject(), + eKind, + basegfx::B2DPolyPolygon(aNewPolygon)); + ImpCopyAttributes(pSrcPath, pPath.get()); + pLast = pPath.get(); + rOL.InsertObject(pPath.get(), rPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pPath, true)); + MarkObj(pPath.get(), pPV, false, true); + rPos++; + } + } + } + + if(pLast && pSrcPath->GetOutlinerParaObject()) + { + pLast->SetOutlinerParaObject(*pSrcPath->GetOutlinerParaObject()); + } + } + else if(pCustomShape) + { + if(bMakeLines) + { + // break up custom shape + const SdrObject* pReplacement = pCustomShape->GetSdrObjectFromCustomShape(); + + if(pReplacement) + { + rtl::Reference pCandidate(pReplacement->CloneSdrObject(pReplacement->getSdrModelFromSdrObject())); + DBG_ASSERT(pCandidate, "SdrEditView::ImpDismantleOneObject: Could not clone SdrObject (!)"); + + if(pCustomShape->GetMergedItem(SDRATTR_SHADOW).GetValue()) + { + if(dynamic_cast( pReplacement) != nullptr) + { + pCandidate->SetMergedItem(makeSdrShadowItem(true)); + } + } + + rOL.InsertObject(pCandidate.get(), rPos); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pCandidate, true)); + MarkObj(pCandidate.get(), pPV, false, true); + + if(pCustomShape->HasText() && !pCustomShape->IsTextPath()) + { + // #i37011# also create a text object and add at rPos + 1 + rtl::Reference pTextObj = SdrObjFactory::MakeNewObject( + pCustomShape->getSdrModelFromSdrObject(), + pCustomShape->GetObjInventor(), + SdrObjKind::Text); + + // Copy text content + OutlinerParaObject* pParaObj = pCustomShape->GetOutlinerParaObject(); + if(pParaObj) + { + pTextObj->NbcSetOutlinerParaObject(*pParaObj); + } + + // copy all attributes + SfxItemSet aTargetItemSet(pCustomShape->GetMergedItemSet()); + + // clear fill and line style + aTargetItemSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + aTargetItemSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + + // get the text bounds and set at text object + tools::Rectangle aTextBounds = pCustomShape->GetSnapRect(); + if(pCustomShape->GetTextBounds(aTextBounds)) + { + pTextObj->SetSnapRect(aTextBounds); + } + + // if rotated, copy GeoStat, too. + const GeoStat& rSourceGeo = pCustomShape->GetGeoStat(); + if(rSourceGeo.m_nRotationAngle) + { + pTextObj->NbcRotate( + pCustomShape->GetSnapRect().Center(), rSourceGeo.m_nRotationAngle, + rSourceGeo.mfSinRotationAngle, rSourceGeo.mfCosRotationAngle); + } + + // set modified ItemSet at text object + pTextObj->SetMergedItemSet(aTargetItemSet); + + // insert object + rOL.InsertObject(pTextObj.get(), rPos + 1); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pTextObj, true)); + MarkObj(pTextObj.get(), pPV, false, true); + } + } + } + } +} + +void SdrEditView::DismantleMarkedObjects(bool bMakeLines) +{ + // temporary MarkList + SdrMarkList aRemoveBuffer; + + SortMarkedObjects(); + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + { + // comment is constructed later + BegUndo("", "", bMakeLines ? SdrRepeatFunc::DismantleLines : SdrRepeatFunc::DismantlePolys); + } + + SdrObjList* pOL0=nullptr; + const bool bWasLocked = GetModel().isLocked(); + GetModel().setLock(true); + for (size_t nm=GetMarkedObjectCount(); nm>0;) { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrPageView* pPV=pM->GetPageView(); + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + if (pOL!=pOL0) { pOL0=pOL; pObj->GetOrdNum(); } // make sure OrdNums are correct! + if (ImpCanDismantle(pObj,bMakeLines)) { + aRemoveBuffer.InsertEntry(SdrMark(pObj,pM->GetPageView())); + const size_t nPos0=pObj->GetOrdNumDirect(); + size_t nPos=nPos0+1; + SdrObjList* pSubList=pObj->GetSubList(); + if (pSubList!=nullptr && !pObj->Is3DObj()) { + SdrObjListIter aIter(pSubList,SdrIterMode::DeepNoGroups); + while (aIter.IsMore()) { + const SdrObject* pObj1=aIter.Next(); + ImpDismantleOneObject(pObj1,*pOL,nPos,pPV,bMakeLines); + } + } else { + ImpDismantleOneObject(pObj,*pOL,nPos,pPV,bMakeLines); + } + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj,true)); + pOL->RemoveObject(nPos0); + } + } + GetModel().setLock(bWasLocked); + + if( bUndo ) + { + // construct UndoComment from objects actually used + SetUndoComment(SvxResId(bMakeLines?STR_EditDismantle_Lines:STR_EditDismantle_Polys),aRemoveBuffer.GetMarkDescription()); + // remove objects actually used from the list + EndUndo(); + } +} + + +// Group + + +void SdrEditView::GroupMarked() +{ + if (!AreObjectsMarked()) + return; + + SortMarkedObjects(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + BegUndo(SvxResId(STR_EditGroup),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::Group); + + for(size_t nm = GetMarkedObjectCount(); nm>0; ) + { + // add UndoActions for all affected objects + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj = pM->GetMarkedSdrObj(); + AddUndoActions( CreateConnectorUndo( *pObj ) ); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoRemoveObject( *pObj )); + } + } + + SdrMarkList aNewMark; + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + SdrObjList* pCurrentLst=pPV->GetObjList(); + SdrObjList* pSrcLst=pCurrentLst; + SdrObjList* pSrcLst0=pSrcLst; + // make sure OrdNums are correct + if (pSrcLst->IsObjOrdNumsDirty()) + pSrcLst->RecalcObjOrdNums(); + rtl::Reference pGrp; + SdrObjList* pDstLst=nullptr; + // if all selected objects come from foreign object lists. + // the group object is the last one in the list. + size_t nInsPos=pSrcLst->GetObjCount(); + bool bNeedInsPos=true; + for (size_t nm=GetMarkedObjectCount(); nm>0;) + { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + if (pM->GetPageView()==pPV) + { + SdrObject* pObj=pM->GetMarkedSdrObj(); + if (!pGrp) + { + pGrp = new SdrObjGroup(pObj->getSdrModelFromSdrObject()); + pDstLst=pGrp->GetSubList(); + assert(pDstLst && "Alleged group object doesn't return object list."); + } + pSrcLst=pObj->getParentSdrObjListFromSdrObject(); + if (pSrcLst!=pSrcLst0) + { + if (pSrcLst->IsObjOrdNumsDirty()) + pSrcLst->RecalcObjOrdNums(); + } + bool bForeignList=pSrcLst!=pCurrentLst; + if (!bForeignList && bNeedInsPos) + { + nInsPos=pObj->GetOrdNum(); // this way, all ObjOrdNum of the page are set + nInsPos++; + bNeedInsPos=false; + } + pSrcLst->RemoveObject(pObj->GetOrdNumDirect()); + if (!bForeignList) + nInsPos--; // correct InsertPos + pDstLst->InsertObject(pObj,0); + GetMarkedObjectListWriteAccess().DeleteMark(nm); + pSrcLst0=pSrcLst; + } + } + if (pGrp!=nullptr) + { + assert(pDstLst); // keep coverity happy + aNewMark.InsertEntry(SdrMark(pGrp.get(),pPV)); + const size_t nCount=pDstLst->GetObjCount(); + pCurrentLst->InsertObject(pGrp.get(),nInsPos); + if( bUndo ) + { + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pGrp,true)); // no recalculation! + for (size_t no=0; noGetObj(no))); + } + } + } + } + GetMarkedObjectListWriteAccess().Merge(aNewMark); + MarkListHasChanged(); + + if( bUndo ) + EndUndo(); +} + + +// Ungroup + + +void SdrEditView::UnGroupMarked() +{ + SdrMarkList aNewMark; + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo("", "", SdrRepeatFunc::Ungroup); + + size_t nCount=0; + OUString aName1; + OUString aName; + bool bNameOk=false; + for (size_t nm=GetMarkedObjectCount(); nm>0;) { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pGrp=pM->GetMarkedSdrObj(); + SdrObjList* pSrcLst=pGrp->GetSubList(); + if (pSrcLst!=nullptr) { + nCount++; + if (nCount==1) { + aName = pGrp->TakeObjNameSingul(); // retrieve name of group + aName1 = pGrp->TakeObjNamePlural(); // retrieve name of group + bNameOk=true; + } else { + if (nCount==2) aName=aName1; // set plural name + if (bNameOk) { + OUString aStr(pGrp->TakeObjNamePlural()); // retrieve name of group + + if (aStr != aName) + bNameOk = false; + } + } + size_t nDstCnt=pGrp->GetOrdNum(); + SdrObjList* pDstLst=pM->GetPageView()->GetObjList(); + size_t nObjCount=pSrcLst->GetObjCount(); + const bool bIsDiagram(pGrp->isDiagram()); + + // If the Group is a Diagram, it has a filler BG object to guarantee + // the Diagam's dimensions. Identify that shape + if(bIsDiagram && nObjCount) + { + SdrObject* pObj(pSrcLst->GetObj(0)); + + if(nullptr != pObj && !pObj->IsGroupObject() && + !pObj->HasLineStyle() && + pObj->IsMoveProtect() && pObj->IsResizeProtect()) + { + if(pObj->HasFillStyle()) + { + // If it has FillStyle it is a useful object representing that possible + // defined fill from oox import. In this case, we should remove the + // Move/Resize protection to allow seamless further processing. + + // Undo of these is handled by SdrUndoGeoObj which holds a SdrObjGeoData, + // create one + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + pObj->SetMoveProtect(false); + pObj->SetResizeProtect(false); + } + else + { + // If it has no FillStyle it is not useful for any further processing + // but only was used as a placeholder, get directly rid of it + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); + + pSrcLst->RemoveObject(0); + + nObjCount = pSrcLst->GetObjCount(); + } + } + } + + // FIRST move contained objects to parent of group, so that + // the contained objects are NOT migrated to the UNDO-ItemPool + // when AddUndo(new SdrUndoDelObj(*pGrp)) is called. + if( bUndo ) + { + for (size_t no=nObjCount; no>0;) + { + no--; + SdrObject* pObj=pSrcLst->GetObj(no); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoRemoveObject(*pObj)); + } + } + + for (size_t no=0; no pObj=pSrcLst->RemoveObject(0); + pDstLst->InsertObject(pObj.get(),nDstCnt); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoInsertObject(*pObj,true)); + nDstCnt++; + // No SortCheck when inserting into MarkList, because that would + // provoke a RecalcOrdNums() each time because of pObj->GetOrdNum(): + aNewMark.InsertEntry(SdrMark(pObj.get(),pM->GetPageView()),false); + } + + if( bUndo ) + { + // Now it is safe to add the delete-UNDO which triggers the + // MigrateItemPool now only for itself, not for the sub-objects. + // nDstCnt is right, because previous inserts move group + // object deeper and increase nDstCnt. + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pGrp)); + } + pDstLst->RemoveObject(nDstCnt); + + GetMarkedObjectListWriteAccess().DeleteMark(nm); + } + } + if (nCount!=0) + { + if (!bNameOk) + aName=SvxResId(STR_ObjNamePluralGRUP); // Use the term "Group Objects," if different objects are grouped. + SetUndoComment(SvxResId(STR_EditUngroup),aName); + } + + if( bUndo ) + EndUndo(); + + if (nCount!=0) + { + GetMarkedObjectListWriteAccess().Merge(aNewMark,true); // Because of the sorting above, aNewMark is reversed + MarkListHasChanged(); + } +} + + +// ConvertToPoly + + +rtl::Reference SdrEditView::ImpConvertOneObj(SdrObject* pObj, bool bPath, bool bLineToArea) +{ + rtl::Reference pNewObj = pObj->ConvertToPolyObj(bPath, bLineToArea); + if (pNewObj) + { + SdrObjList* pOL = pObj->getParentSdrObjListFromSdrObject(); + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoReplaceObject(*pObj,*pNewObj)); + + pOL->ReplaceObject(pNewObj.get(), pObj->GetOrdNum()); + } + return pNewObj; +} + +void SdrEditView::ImpConvertTo(bool bPath, bool bLineToArea) +{ + if (!AreObjectsMarked()) return; + + bool bMrkChg = false; + const size_t nMarkCount=GetMarkedObjectCount(); + TranslateId pDscrID; + if(bLineToArea) + { + if(nMarkCount == 1) + pDscrID = STR_EditConvToContour; + else + pDscrID = STR_EditConvToContours; + + BegUndo(SvxResId(pDscrID), GetDescriptionOfMarkedObjects()); + } + else + { + if (bPath) { + if (nMarkCount==1) pDscrID=STR_EditConvToCurve; + else pDscrID=STR_EditConvToCurves; + BegUndo(SvxResId(pDscrID),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::ConvertToPath); + } else { + if (nMarkCount==1) pDscrID=STR_EditConvToPoly; + else pDscrID=STR_EditConvToPolys; + BegUndo(SvxResId(pDscrID),GetDescriptionOfMarkedObjects(),SdrRepeatFunc::ConvertToPoly); + } + } + for (size_t nm=nMarkCount; nm>0;) { + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrPageView* pPV=pM->GetPageView(); + if (pObj->IsGroupObject() && !pObj->Is3DObj()) { + SdrObject* pGrp=pObj; + SdrObjListIter aIter(*pGrp, SdrIterMode::DeepNoGroups); + while (aIter.IsMore()) { + pObj=aIter.Next(); + ImpConvertOneObj(pObj,bPath,bLineToArea); + } + } else { + rtl::Reference pNewObj=ImpConvertOneObj(pObj,bPath,bLineToArea); + if (pNewObj) { + bMrkChg=true; + GetMarkedObjectListWriteAccess().ReplaceMark(SdrMark(pNewObj.get(),pPV),nm); + } + } + } + EndUndo(); + if (bMrkChg) + { + AdjustMarkHdl(); + MarkListHasChanged(); + } +} + +void SdrEditView::ConvertMarkedToPathObj(bool bLineToArea) +{ + ImpConvertTo(true, bLineToArea); +} + +void SdrEditView::ConvertMarkedToPolyObj() +{ + ImpConvertTo(false, false/*bLineToArea*/); +} + +namespace +{ + GDIMetaFile GetMetaFile(SdrGrafObj const * pGraf) + { + if (pGraf->HasGDIMetaFile()) + return pGraf->GetTransformedGraphic(SdrGrafObjTransformsAttrs::MIRROR).GetGDIMetaFile(); + assert(pGraf->isEmbeddedVectorGraphicData()); + return pGraf->getMetafileFromEmbeddedVectorGraphicData(); + } +} + +// Metafile Import +void SdrEditView::DoImportMarkedMtf(SvdProgressInfo *pProgrInfo) +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo("", "", SdrRepeatFunc::ImportMtf); + + SortMarkedObjects(); + SdrMarkList aForTheDescription; + SdrMarkList aNewMarked; + for (size_t nm =GetMarkedObjectCount(); nm > 0; ) + { + // create Undo objects for all new objects + // check for cancellation between the metafiles + if (pProgrInfo != nullptr) + { + pProgrInfo->SetNextObject(); + if (!pProgrInfo->ReportActions(0)) + break; + } + + --nm; + SdrMark* pM=GetSdrMarkByIndex(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrPageView* pPV=pM->GetPageView(); + SdrObjList* pOL=pObj->getParentSdrObjListFromSdrObject(); + const size_t nInsPos=pObj->GetOrdNum()+1; + size_t nInsCnt=0; + tools::Rectangle aLogicRect; + + SdrGrafObj* pGraf = dynamic_cast( pObj ); + if (pGraf != nullptr) + { + Graphic aGraphic = pGraf->GetGraphic(); + auto const & pVectorGraphicData = aGraphic.getVectorGraphicData(); + + if (pVectorGraphicData && pVectorGraphicData->getType() == VectorGraphicDataType::Pdf) + { + auto pPdfium = vcl::pdf::PDFiumLibrary::get(); + if (pPdfium) + { + aLogicRect = pGraf->GetLogicRect(); + ImpSdrPdfImport aFilter(GetModel(), pObj->GetLayer(), aLogicRect, aGraphic); + if (aGraphic.getPageNumber() < aFilter.GetPageCount()) + { + nInsCnt = aFilter.DoImport(*pOL, nInsPos, aGraphic.getPageNumber(), pProgrInfo); + } + } + } + else if (pGraf->HasGDIMetaFile() || pGraf->isEmbeddedVectorGraphicData() ) + { + GDIMetaFile aMetaFile(GetMetaFile(pGraf)); + if (aMetaFile.GetActionSize()) + { + aLogicRect = pGraf->GetLogicRect(); + ImpSdrGDIMetaFileImport aFilter(GetModel(), pObj->GetLayer(), aLogicRect); + nInsCnt = aFilter.DoImport(aMetaFile, *pOL, nInsPos, pProgrInfo); + } + } + } + + SdrOle2Obj* pOle2 = dynamic_cast(pObj); + if (pOle2 != nullptr && pOle2->GetGraphic()) + { + aLogicRect = pOle2->GetLogicRect(); + ImpSdrGDIMetaFileImport aFilter(GetModel(), pObj->GetLayer(), aLogicRect); + nInsCnt = aFilter.DoImport(pOle2->GetGraphic()->GetGDIMetaFile(), *pOL, nInsPos, pProgrInfo); + } + + if (nInsCnt != 0) + { + // transformation + GeoStat aGeoStat(pGraf ? pGraf->GetGeoStat() : pOle2->GetGeoStat()); + size_t nObj = nInsPos; + + if (aGeoStat.m_nShearAngle) + aGeoStat.RecalcTan(); + + if (aGeoStat.m_nRotationAngle) + aGeoStat.RecalcSinCos(); + + for (size_t i = 0; i < nInsCnt; i++) + { + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pOL->GetObj(nObj))); + + // update new MarkList + SdrObject* pCandidate = pOL->GetObj(nObj); + + // apply original transformation + if (aGeoStat.m_nShearAngle) + pCandidate->NbcShear(aLogicRect.TopLeft(), aGeoStat.m_nShearAngle, aGeoStat.mfTanShearAngle, false); + + if (aGeoStat.m_nRotationAngle) + pCandidate->NbcRotate(aLogicRect.TopLeft(), aGeoStat.m_nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle); + + SdrMark aNewMark(pCandidate, pPV); + aNewMarked.InsertEntry(aNewMark); + + nObj++; + } + + aForTheDescription.InsertEntry(*pM); + + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pObj)); + + // remove object from selection and delete + GetMarkedObjectListWriteAccess().DeleteMark(TryToFindMarkedObject(pObj)); + pOL->RemoveObject(nInsPos-1); + } + } + + if (aNewMarked.GetMarkCount()) + { + // create new selection + for (size_t a = 0; a < aNewMarked.GetMarkCount(); ++a) + { + GetMarkedObjectListWriteAccess().InsertEntry(*aNewMarked.GetMark(a)); + } + + SortMarkedObjects(); + } + + if (bUndo) + { + SetUndoComment(SvxResId(STR_EditImportMtf),aForTheDescription.GetMarkDescription()); + EndUndo(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdedxv.cxx b/svx/source/svdraw/svdedxv.cxx new file mode 100644 index 0000000000..c2d35cc75b --- /dev/null +++ b/svx/source/svdraw/svdedxv.cxx @@ -0,0 +1,3002 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +SdrObjEditView::SdrObjEditView(SdrModel& rSdrModel, OutputDevice* pOut) + : SdrGlueEditView(rSdrModel, pOut) + , mpTextEditPV(nullptr) + , mpTextEditOutlinerView(nullptr) + , mpTextEditWin(nullptr) + , pTextEditCursorBuffer(nullptr) + , pMacroObj(nullptr) + , pMacroPV(nullptr) + , pMacroWin(nullptr) + , nMacroTol(0) + , mbTextEditDontDelete(false) + , mbTextEditOnlyOneView(false) + , mbTextEditNewObj(false) + , mbQuickTextEditMode(true) + , mbMacroDown(false) + , mpOldTextEditUndoManager(nullptr) +{ +} + +SdrObjEditView::~SdrObjEditView() +{ + mpTextEditWin = nullptr; // so there's no ShowCursor in SdrEndTextEdit + assert(!IsTextEdit()); + if (IsTextEdit()) + suppress_fun_call_w_exception(SdrEndTextEdit()); + mpTextEditOutliner.reset(); + assert(nullptr == mpOldTextEditUndoManager); // should have been reset +} + +bool SdrObjEditView::IsAction() const { return IsMacroObj() || SdrGlueEditView::IsAction(); } + +void SdrObjEditView::MovAction(const Point& rPnt) +{ + if (IsMacroObj()) + MovMacroObj(rPnt); + SdrGlueEditView::MovAction(rPnt); +} + +void SdrObjEditView::EndAction() +{ + if (IsMacroObj()) + EndMacroObj(); + SdrGlueEditView::EndAction(); +} + +void SdrObjEditView::BckAction() +{ + BrkMacroObj(); + SdrGlueEditView::BckAction(); +} + +void SdrObjEditView::BrkAction() +{ + BrkMacroObj(); + SdrGlueEditView::BrkAction(); +} + +SdrPageView* SdrObjEditView::ShowSdrPage(SdrPage* pPage) +{ + SdrPageView* pPageView = SdrGlueEditView::ShowSdrPage(pPage); + + if (comphelper::LibreOfficeKit::isActive() && pPageView) + { + // Check if other views have an active text edit on the same page as + // this one. + SdrViewIter::ForAllViews(pPageView->GetPage(), [this](SdrView* pView) { + if (pView == this || !pView->IsTextEdit()) + return; + + OutputDevice* pOutDev = GetFirstOutputDevice(); + if (!pOutDev || pOutDev->GetOutDevType() != OUTDEV_WINDOW) + return; + + // Found one, so create an outliner view, to get invalidations when + // the text edit changes. + // Call GetSfxViewShell() to make sure ImpMakeOutlinerView() + // registers the view shell of this draw view, and not the view + // shell of pView. + OutlinerView* pOutlinerView + = pView->ImpMakeOutlinerView(pOutDev->GetOwnerWindow(), nullptr, GetSfxViewShell()); + pOutlinerView->HideCursor(); + pView->GetTextEditOutliner()->InsertView(pOutlinerView); + }); + } + + return pPageView; +} + +namespace +{ +/// Removes outliner views registered in other draw views that use pOutputDevice. +void lcl_RemoveTextEditOutlinerViews(SdrObjEditView const* pThis, SdrPageView const* pPageView, + OutputDevice const* pOutputDevice) +{ + if (!comphelper::LibreOfficeKit::isActive()) + return; + + if (!pPageView) + return; + + if (!pOutputDevice || pOutputDevice->GetOutDevType() != OUTDEV_WINDOW) + return; + + SdrViewIter::ForAllViews(pPageView->GetPage(), [&pThis, &pOutputDevice](SdrView* pView) { + if (pView == pThis || !pView->IsTextEdit()) + return; + + SdrOutliner* pOutliner = pView->GetTextEditOutliner(); + for (size_t nView = 0; nView < pOutliner->GetViewCount(); ++nView) + { + OutlinerView* pOutlinerView = pOutliner->GetView(nView); + if (pOutlinerView->GetWindow()->GetOutDev() != pOutputDevice) + continue; + + pOutliner->RemoveView(pOutlinerView); + delete pOutlinerView; + } + }); +} +} + +void SdrObjEditView::HideSdrPage() +{ + lcl_RemoveTextEditOutlinerViews(this, GetSdrPageView(), GetFirstOutputDevice()); + + if (mpTextEditPV == GetSdrPageView()) + { + // HideSdrPage() will clear mpPageView, avoid a dangling pointer. + mpTextEditPV = nullptr; + } + + SdrGlueEditView::HideSdrPage(); +} + +void SdrObjEditView::TakeActionRect(tools::Rectangle& rRect) const +{ + if (IsMacroObj()) + { + rRect = pMacroObj->GetCurrentBoundRect(); + } + else + { + SdrGlueEditView::TakeActionRect(rRect); + } +} + +void SdrObjEditView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + SdrGlueEditView::Notify(rBC, rHint); + if (mpTextEditOutliner == nullptr) + return; + + // change of printer while editing + if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint) + return; + + const SdrHint* pSdrHint = static_cast(&rHint); + SdrHintKind eKind = pSdrHint->GetKind(); + if (eKind == SdrHintKind::RefDeviceChange) + { + mpTextEditOutliner->SetRefDevice(GetModel().GetRefDevice()); + } + if (eKind == SdrHintKind::DefaultTabChange) + { + mpTextEditOutliner->SetDefTab(GetModel().GetDefaultTabulator()); + } +} + +void SdrObjEditView::ModelHasChanged() +{ + SdrGlueEditView::ModelHasChanged(); + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + if (pTextObj && !pTextObj->IsInserted()) + SdrEndTextEdit(); // object deleted + // TextEditObj changed? + if (!IsTextEdit()) + return; + + if (pTextObj != nullptr) + { + size_t nOutlViewCnt = mpTextEditOutliner->GetViewCount(); + bool bAreaChg = false; + bool bAnchorChg = false; + bool bColorChg = false; + bool bContourFrame = pTextObj->IsContourTextFrame(); + EEAnchorMode eNewAnchor(EEAnchorMode::VCenterHCenter); + tools::Rectangle aOldArea(aMinTextEditArea); + aOldArea.Union(aTextEditArea); + Color aNewColor; + { // check area + Size aPaperMin1; + Size aPaperMax1; + tools::Rectangle aEditArea1; + tools::Rectangle aMinArea1; + pTextObj->TakeTextEditArea(&aPaperMin1, &aPaperMax1, &aEditArea1, &aMinArea1); + Point aPvOfs(pTextObj->GetTextEditOffset()); + + // add possible GridOffset to up-to-now view-independent EditAreas + basegfx::B2DVector aGridOffset(0.0, 0.0); + if (getPossibleGridOffsetForSdrObject(aGridOffset, pTextObj.get(), GetSdrPageView())) + { + const Point aOffset(basegfx::fround(aGridOffset.getX()), + basegfx::fround(aGridOffset.getY())); + + aEditArea1 += aOffset; + aMinArea1 += aOffset; + } + + aEditArea1.Move(aPvOfs.X(), aPvOfs.Y()); + aMinArea1.Move(aPvOfs.X(), aPvOfs.Y()); + tools::Rectangle aNewArea(aMinArea1); + aNewArea.Union(aEditArea1); + + if (aNewArea != aOldArea || aEditArea1 != aTextEditArea || aMinArea1 != aMinTextEditArea + || mpTextEditOutliner->GetMinAutoPaperSize() != aPaperMin1 + || mpTextEditOutliner->GetMaxAutoPaperSize() != aPaperMax1) + { + aTextEditArea = aEditArea1; + aMinTextEditArea = aMinArea1; + + const bool bPrevUpdateLayout = mpTextEditOutliner->SetUpdateLayout(false); + mpTextEditOutliner->SetMinAutoPaperSize(aPaperMin1); + mpTextEditOutliner->SetMaxAutoPaperSize(aPaperMax1); + mpTextEditOutliner->SetPaperSize(Size(0, 0)); // re-format Outliner + + if (!bContourFrame) + { + mpTextEditOutliner->ClearPolygon(); + EEControlBits nStat = mpTextEditOutliner->GetControlWord(); + nStat |= EEControlBits::AUTOPAGESIZE; + mpTextEditOutliner->SetControlWord(nStat); + } + else + { + EEControlBits nStat = mpTextEditOutliner->GetControlWord(); + nStat &= ~EEControlBits::AUTOPAGESIZE; + mpTextEditOutliner->SetControlWord(nStat); + tools::Rectangle aAnchorRect; + pTextObj->TakeTextAnchorRect(aAnchorRect); + pTextObj->ImpSetContourPolygon(*mpTextEditOutliner, aAnchorRect, true); + } + for (size_t nOV = 0; nOV < nOutlViewCnt; nOV++) + { + OutlinerView* pOLV = mpTextEditOutliner->GetView(nOV); + EVControlBits nStat0 = pOLV->GetControlWord(); + EVControlBits nStat = nStat0; + // AutoViewSize only if not ContourFrame. + if (!bContourFrame) + nStat |= EVControlBits::AUTOSIZE; + else + nStat &= ~EVControlBits::AUTOSIZE; + if (nStat != nStat0) + pOLV->SetControlWord(nStat); + } + + mpTextEditOutliner->SetUpdateLayout(bPrevUpdateLayout); + bAreaChg = true; + } + } + if (mpTextEditOutlinerView != nullptr) + { // check fill and anchor + EEAnchorMode eOldAnchor = mpTextEditOutlinerView->GetAnchorMode(); + eNewAnchor = pTextObj->GetOutlinerViewAnchorMode(); + bAnchorChg = eOldAnchor != eNewAnchor; + Color aOldColor(mpTextEditOutlinerView->GetBackgroundColor()); + aNewColor = GetTextEditBackgroundColor(*this); + bColorChg = aOldColor != aNewColor; + } + // refresh always when it's a contour frame. That + // refresh is necessary since it triggers the repaint + // which makes the Handles visible. Changes at TakeTextRect() + // seem to have resulted in a case where no refresh is executed. + // Before that, a refresh must have been always executed + // (else this error would have happened earlier), thus I + // even think here a refresh should be done always. + // Since follow-up problems cannot even be guessed I only + // add this one more case to the if below. + // BTW: It's VERY bad style that here, inside ModelHasChanged() + // the outliner is again massively changed for the text object + // in text edit mode. Normally, all necessary data should be + // set at SdrBeginTextEdit(). Some changes and value assigns in + // SdrBeginTextEdit() are completely useless since they are set here + // again on ModelHasChanged(). + if (bContourFrame || bAreaChg || bAnchorChg || bColorChg) + { + for (size_t nOV = 0; nOV < nOutlViewCnt; nOV++) + { + OutlinerView* pOLV = mpTextEditOutliner->GetView(nOV); + { // invalidate old OutlinerView area + vcl::Window* pWin = pOLV->GetWindow(); + tools::Rectangle aTmpRect(aOldArea); + sal_uInt16 nPixSiz = pOLV->GetInvalidateMore() + 1; + Size aMore(pWin->PixelToLogic(Size(nPixSiz, nPixSiz))); + aTmpRect.AdjustLeft(-(aMore.Width())); + aTmpRect.AdjustRight(aMore.Width()); + aTmpRect.AdjustTop(-(aMore.Height())); + aTmpRect.AdjustBottom(aMore.Height()); + InvalidateOneWin(*pWin->GetOutDev(), aTmpRect); + } + if (bAnchorChg) + pOLV->SetAnchorMode(eNewAnchor); + if (bColorChg) + pOLV->SetBackgroundColor(aNewColor); + + pOLV->SetOutputArea( + aTextEditArea); // because otherwise, we're not re-anchoring correctly + ImpInvalidateOutlinerView(*pOLV); + } + mpTextEditOutlinerView->ShowCursor(); + } + } + ImpMakeTextCursorAreaVisible(); +} + +namespace +{ +class TextEditFrameOverlayObject; +class TextEditHighContrastOverlaySelection; + +/** + Helper class to visualize the content of an active EditView as an + OverlayObject. These objects work with Primitives and are handled + from the OverlayManager(s) in place as needed. + + It allows complete visualization of the content of the active + EditView without the need of Invalidates triggered by the EditView + and thus avoiding potentially expensive repaints by using the + automatically buffered Overlay mechanism. + + It buffers as much as possible locally and *only* triggers a real + change (see call to objectChange()) when really needed. + */ +class TextEditOverlayObject : public sdr::overlay::OverlayObject +{ +protected: + /// local access to associated sdr::overlay::OverlaySelection + std::unique_ptr mxOverlayTransparentSelection; + std::unique_ptr mxOverlayHighContrastSelection; + std::unique_ptr mxOverlayFrame; + + /// local definition depends on active OutlinerView + OutlinerView& mrOutlinerView; + + /// geometry definitions with buffering + basegfx::B2DRange maLastRange; + basegfx::B2DRange maRange; + + /// text content definitions with buffering + drawinglayer::primitive2d::Primitive2DContainer maTextPrimitives; + drawinglayer::primitive2d::Primitive2DContainer maLastTextPrimitives; + + // geometry creation for OverlayObject, can use local *Last* values + virtual drawinglayer::primitive2d::Primitive2DContainer + createOverlayObjectPrimitive2DSequence() override; + +public: + TextEditOverlayObject(const Color& rColor, OutlinerView& rOutlinerView); + virtual ~TextEditOverlayObject() override; + + sdr::overlay::OverlayObject* getOverlaySelection(); + sdr::overlay::OverlayObject* getOverlayFrame(); + + const OutlinerView& getOutlinerView() const { return mrOutlinerView; } + + /// override to check conditions for last createOverlayObjectPrimitive2DSequence + virtual drawinglayer::primitive2d::Primitive2DContainer + getOverlayObjectPrimitive2DSequence() const override; + + // data write access. In this OverlayObject we only have the + // callback that triggers detecting if something *has* changed + void checkDataChange(const basegfx::B2DRange& rMinTextEditArea); + void checkSelectionChange(); + + const basegfx::B2DRange& getRange() const { return maRange; } + const drawinglayer::primitive2d::Primitive2DContainer& getTextPrimitives() const + { + return maTextPrimitives; + } +}; + +class TextEditFrameOverlayObject : public sdr::overlay::OverlayObject +{ +private: + const TextEditOverlayObject& mrTextEditOverlayObject; + + // geometry creation for OverlayObject, can use local *Last* values + virtual drawinglayer::primitive2d::Primitive2DContainer + createOverlayObjectPrimitive2DSequence() override; + +public: + TextEditFrameOverlayObject(const TextEditOverlayObject& rTextEditOverlayObject); + using sdr::overlay::OverlayObject::objectChange; + virtual ~TextEditFrameOverlayObject() override; +}; + +class TextEditHighContrastOverlaySelection : public sdr::overlay::OverlayObject +{ +private: + const TextEditOverlayObject& mrTextEditOverlayObject; + std::vector maRanges; + + // geometry creation for OverlayObject, can use local *Last* values + virtual drawinglayer::primitive2d::Primitive2DContainer + createOverlayObjectPrimitive2DSequence() override; + +public: + TextEditHighContrastOverlaySelection(const TextEditOverlayObject& rTextEditOverlayObject); + void setRanges(std::vector&& rNew); + virtual ~TextEditHighContrastOverlaySelection() override; +}; + +TextEditHighContrastOverlaySelection::TextEditHighContrastOverlaySelection( + const TextEditOverlayObject& rTextEditOverlayObject) + : OverlayObject(rTextEditOverlayObject.getBaseColor()) + , mrTextEditOverlayObject(rTextEditOverlayObject) +{ + allowAntiAliase(rTextEditOverlayObject.allowsAntiAliase()); + // use selection colors in HighContrast mode + mbHighContrastSelection = true; +} + +void TextEditHighContrastOverlaySelection::setRanges(std::vector&& rNew) +{ + if (rNew != maRanges) + { + maRanges = std::move(rNew); + objectChange(); + } +} + +drawinglayer::primitive2d::Primitive2DContainer +TextEditHighContrastOverlaySelection::createOverlayObjectPrimitive2DSequence() +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + size_t nCount = maRanges.size(); + + if (nCount) + { + basegfx::B2DPolyPolygon aClipPolyPolygon; + + basegfx::BColor aRGBColor(getBaseColor().getBColor()); + + for (size_t a = 0; a < nCount; ++a) + aClipPolyPolygon.append(basegfx::utils::createPolygonFromRect(maRanges[a])); + + // This is used in high contrast mode, we will render the selection + // with the bg forced to the selection Highlight color and the fg color + // forced to the HighlightText color + aRetval.append(drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( + basegfx::B2DPolyPolygon( + basegfx::utils::createPolygonFromRect(aClipPolyPolygon.getB2DRange())), + aRGBColor))); + aRetval.append(mrTextEditOverlayObject.getTextPrimitives()); + aRetval.append(drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::MaskPrimitive2D(aClipPolyPolygon, std::move(aRetval)))); + } + + return aRetval; +} + +TextEditHighContrastOverlaySelection::~TextEditHighContrastOverlaySelection() +{ + if (getOverlayManager()) + { + getOverlayManager()->remove(*this); + } +} + +sdr::overlay::OverlayObject* TextEditOverlayObject::getOverlaySelection() +{ + if (mxOverlayTransparentSelection) + return mxOverlayTransparentSelection.get(); + return mxOverlayHighContrastSelection.get(); +} + +sdr::overlay::OverlayObject* TextEditOverlayObject::getOverlayFrame() +{ + if (!mxOverlayFrame) + mxOverlayFrame.reset(new TextEditFrameOverlayObject(*this)); + return mxOverlayFrame.get(); +} + +drawinglayer::primitive2d::Primitive2DContainer +TextEditOverlayObject::createOverlayObjectPrimitive2DSequence() +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + // add buffered TextPrimitives + aRetval.append(maTextPrimitives); + + return aRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer +TextEditFrameOverlayObject::createOverlayObjectPrimitive2DSequence() +{ + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + /// outer frame visualization + const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01); + const sal_uInt16 nPixSiz(mrTextEditOverlayObject.getOutlinerView().GetInvalidateMore() - 1); + + aRetval.push_back(new drawinglayer::primitive2d::OverlayRectanglePrimitive( + mrTextEditOverlayObject.getRange(), getBaseColor().getBColor(), fTransparence, + std::max(6, nPixSiz - 2), // grow + 0.0, // shrink + 0.0)); + + return aRetval; +} + +TextEditOverlayObject::TextEditOverlayObject(const Color& rColor, OutlinerView& rOutlinerView) + : OverlayObject(rColor) + , mrOutlinerView(rOutlinerView) +{ + // no AA for TextEdit overlay + allowAntiAliase(false); + + // create local OverlaySelection - this is an integral part of EditText + // visualization + if (Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + mxOverlayHighContrastSelection.reset(new TextEditHighContrastOverlaySelection(*this)); + } + else + { + std::vector aEmptySelection{}; + mxOverlayTransparentSelection.reset(new sdr::overlay::OverlaySelection( + sdr::overlay::OverlayType::Transparent, rColor, std::move(aEmptySelection), true)); + } +} + +TextEditOverlayObject::~TextEditOverlayObject() +{ + mxOverlayTransparentSelection.reset(); + mxOverlayHighContrastSelection.reset(); + + if (getOverlayManager()) + { + getOverlayManager()->remove(*this); + } +} + +TextEditFrameOverlayObject::TextEditFrameOverlayObject( + const TextEditOverlayObject& rTextEditOverlayObject) + : OverlayObject(rTextEditOverlayObject.getBaseColor()) + , mrTextEditOverlayObject(rTextEditOverlayObject) +{ + allowAntiAliase(rTextEditOverlayObject.allowsAntiAliase()); + // use selection colors in HighContrast mode + mbHighContrastSelection = true; +} + +TextEditFrameOverlayObject::~TextEditFrameOverlayObject() +{ + if (getOverlayManager()) + { + getOverlayManager()->remove(*this); + } +} + +drawinglayer::primitive2d::Primitive2DContainer +TextEditOverlayObject::getOverlayObjectPrimitive2DSequence() const +{ + if (!getPrimitive2DSequence().empty()) + { + if (!maRange.equal(maLastRange) || maLastTextPrimitives != maTextPrimitives) + { + // conditions of last local decomposition have changed, delete to force new evaluation + const_cast(this)->resetPrimitive2DSequence(); + } + } + + if (getPrimitive2DSequence().empty()) + { + // remember new buffered values + const_cast(this)->maLastRange = maRange; + const_cast(this)->maLastTextPrimitives = maTextPrimitives; + } + + // call base implementation + return OverlayObject::getOverlayObjectPrimitive2DSequence(); +} + +void TextEditOverlayObject::checkDataChange(const basegfx::B2DRange& rMinTextEditArea) +{ + bool bObjectChange(false); + + // check current range + const tools::Rectangle aOutArea(mrOutlinerView.GetOutputArea()); + basegfx::B2DRange aNewRange = vcl::unotools::b2DRectangleFromRectangle(aOutArea); + aNewRange.expand(rMinTextEditArea); + + if (aNewRange != maRange) + { + maRange = aNewRange; + bObjectChange = true; + } + + // check if text primitives did change + SdrOutliner* pSdrOutliner = dynamic_cast(getOutlinerView().GetOutliner()); + + if (pSdrOutliner) + { + // get TextPrimitives directly from active Outliner + basegfx::B2DHomMatrix aNewTransformA; + basegfx::B2DHomMatrix aNewTransformB; + basegfx::B2DRange aClipRange; + drawinglayer::primitive2d::Primitive2DContainer aNewTextPrimitives; + + // active Outliner is always in unified oriented coordinate system (currently) + // so just translate to TopLeft of visible Range. Keep in mind that top-left + // depends on vertical text and top-to-bottom text attributes + const tools::Rectangle aVisArea(mrOutlinerView.GetVisArea()); + const bool bVerticalWriting(pSdrOutliner->IsVertical()); + const bool bTopToBottom(pSdrOutliner->IsTopToBottom()); + const double fStartInX(bVerticalWriting && bTopToBottom + ? aOutArea.Right() - aVisArea.Left() + : aOutArea.Left() - aVisArea.Left()); + const double fStartInY(bVerticalWriting && !bTopToBottom + ? aOutArea.Bottom() - aVisArea.Top() + : aOutArea.Top() - aVisArea.Top()); + + aNewTransformB.translate(fStartInX, fStartInY); + + // get the current TextPrimitives. This is the most expensive part + // of this mechanism, it *may* be possible to buffer layouted + // primitives per ParaPortion with/in/dependent on the EditEngine + // content if needed. For now, get and compare + SdrTextObj::impDecomposeBlockTextPrimitiveDirect( + aNewTextPrimitives, *pSdrOutliner, aNewTransformA, aNewTransformB, aClipRange); + + if (aNewTextPrimitives != maTextPrimitives) + { + maTextPrimitives = std::move(aNewTextPrimitives); + bObjectChange = true; + } + } + + if (bObjectChange) + { + // if there really *was* a change signal the OverlayManager to + // refresh this object's visualization + objectChange(); + + if (mxOverlayFrame) + mxOverlayFrame->objectChange(); + + // on data change, always do a SelectionChange, too + // since the selection is an integral part of text visualization + checkSelectionChange(); + } +} + +void TextEditOverlayObject::checkSelectionChange() +{ + if (!(getOverlaySelection() && getOverlayManager())) + return; + + std::vector aLogicRects; + std::vector aLogicRanges; + const Size aLogicPixel(getOverlayManager()->getOutputDevice().PixelToLogic(Size(1, 1))); + + // get logic selection + getOutlinerView().GetSelectionRectangles(aLogicRects); + + aLogicRanges.reserve(aLogicRects.size()); + for (const auto& aRect : aLogicRects) + { + // convert from logic Rectangles to logic Ranges, do not forget to add + // one Unit (in this case logical units for one pixel, pre-calculated) + aLogicRanges.emplace_back( + aRect.Left() - aLogicPixel.Width(), aRect.Top() - aLogicPixel.Height(), + aRect.Right() + aLogicPixel.Width(), aRect.Bottom() + aLogicPixel.Height()); + } + + if (mxOverlayTransparentSelection) + mxOverlayTransparentSelection->setRanges(std::move(aLogicRanges)); + else + mxOverlayHighContrastSelection->setRanges(std::move(aLogicRanges)); +} +} // end of anonymous namespace + +// TextEdit + +// callback from the active EditView, forward to evtl. existing instances of the +// TextEditOverlayObject(s). This will additionally update the selection which +// is an integral part of the text visualization +void SdrObjEditView::EditViewInvalidate(const tools::Rectangle&) +{ + if (!IsTextEdit()) + return; + + // MinTextRange may have changed. Forward it, too + const basegfx::B2DRange aMinTextRange + = vcl::unotools::b2DRectangleFromRectangle(aMinTextEditArea); + + for (sal_uInt32 a(0); a < maTEOverlayGroup.count(); a++) + { + TextEditOverlayObject* pCandidate + = dynamic_cast(&maTEOverlayGroup.getOverlayObject(a)); + + if (pCandidate) + { + pCandidate->checkDataChange(aMinTextRange); + } + } +} + +// callback from the active EditView, forward to evtl. existing instances of the +// TextEditOverlayObject(s). This cvall *only* updates the selection visualization +// which is e.g. used when only the selection is changed, but not the text +void SdrObjEditView::EditViewSelectionChange() +{ + if (!IsTextEdit()) + return; + + for (sal_uInt32 a(0); a < maTEOverlayGroup.count(); a++) + { + TextEditOverlayObject* pCandidate + = dynamic_cast(&maTEOverlayGroup.getOverlayObject(a)); + + if (pCandidate) + { + pCandidate->checkSelectionChange(); + } + } +} + +OutputDevice& SdrObjEditView::EditViewOutputDevice() const { return *mpTextEditWin->GetOutDev(); } + +Point SdrObjEditView::EditViewPointerPosPixel() const +{ + return mpTextEditWin->GetPointerPosPixel(); +} + +css::uno::Reference SdrObjEditView::GetClipboard() const +{ + if (!mpTextEditWin) + return nullptr; + return mpTextEditWin->GetClipboard(); +} + +css::uno::Reference SdrObjEditView::GetDropTarget() +{ + if (!mpTextEditWin) + return nullptr; + return mpTextEditWin->GetDropTarget(); +} + +void SdrObjEditView::EditViewInputContext(const InputContext& rInputContext) +{ + if (!mpTextEditWin) + return; + mpTextEditWin->SetInputContext(rInputContext); +} + +void SdrObjEditView::EditViewCursorRect(const tools::Rectangle& rRect, int nExtTextInputWidth) +{ + if (!mpTextEditWin) + return; + mpTextEditWin->SetCursorRect(&rRect, nExtTextInputWidth); +} + +void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow) +{ + if (!comphelper::LibreOfficeKit::isActive()) + { + // adapt all TextEditOverlayObject(s), so call EditViewInvalidate() + // to update accordingly (will update selection, too). Suppress new + // stuff when LibreOfficeKit is active + EditViewInvalidate(tools::Rectangle()); + } + else + { + // draw old text edit stuff + if (IsTextEdit()) + { + const SdrOutliner* pActiveOutliner = GetTextEditOutliner(); + + if (pActiveOutliner) + { + const sal_uInt32 nViewCount(pActiveOutliner->GetViewCount()); + + if (nViewCount) + { + const vcl::Region& rRedrawRegion = rPaintWindow.GetRedrawRegion(); + const tools::Rectangle aCheckRect(rRedrawRegion.GetBoundRect()); + + for (sal_uInt32 i(0); i < nViewCount; i++) + { + OutlinerView* pOLV = pActiveOutliner->GetView(i); + + // If rPaintWindow knows that the output device is a render + // context and is aware of the underlying vcl::Window, + // compare against that; that's how double-buffering can + // still find the matching OutlinerView. + OutputDevice* pOutputDevice = rPaintWindow.GetWindow() + ? rPaintWindow.GetWindow()->GetOutDev() + : &rPaintWindow.GetOutputDevice(); + if (pOLV->GetWindow()->GetOutDev() == pOutputDevice + || comphelper::LibreOfficeKit::isActive()) + { + ImpPaintOutlinerView(*pOLV, aCheckRect, + rPaintWindow.GetTargetOutputDevice()); + return; + } + } + } + } + } + } +} + +void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const tools::Rectangle& rRect, + OutputDevice& rTargetDevice) const +{ + const SdrTextObj* pText = GetTextEditObject(); + bool bTextFrame(pText && pText->IsTextFrame()); + bool bFitToSize(mpTextEditOutliner->GetControlWord() & EEControlBits::STRETCHING); + bool bModified(mpTextEditOutliner->IsModified()); + tools::Rectangle aBlankRect(rOutlView.GetOutputArea()); + aBlankRect.Union(aMinTextEditArea); + tools::Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect)); + + // in the tiled rendering case, the setup is incomplete, and we very + // easily get an empty rRect on input - that will cause that everything is + // clipped; happens in case of editing text inside a shape in Calc. + // FIXME would be better to complete the setup so that we don't get an + // empty rRect here + if (!comphelper::LibreOfficeKit::isActive() || !rRect.IsEmpty()) + aBlankRect.Intersection(rRect); + + rOutlView.GetOutliner()->SetUpdateLayout(true); // Bugfix #22596# + rOutlView.Paint(aBlankRect, &rTargetDevice); + + if (!bModified) + { + mpTextEditOutliner->ClearModifyFlag(); + } + + if (bTextFrame && !bFitToSize) + { + // completely reworked to use primitives; this ensures same look and functionality + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + std::unique_ptr xProcessor( + drawinglayer::processor2d::createProcessor2DFromOutputDevice(rTargetDevice, + aViewInformation2D)); + + const bool bMapModeEnabled(rTargetDevice.IsMapModeEnabled()); + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aPixRect); + const Color aHilightColor(SvtOptionsDrawinglayer::getHilightColor()); + const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01); + const sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::OverlayRectanglePrimitive( + aRange, aHilightColor.getBColor(), fTransparence, std::max(6, nPixSiz - 2), // grow + 0.0, // shrink + 0.0)); + const drawinglayer::primitive2d::Primitive2DContainer aSequence{ xReference }; + + rTargetDevice.EnableMapMode(false); + xProcessor->process(aSequence); + rTargetDevice.EnableMapMode(bMapModeEnabled); + } + + rOutlView.ShowCursor(/*bGotoCursor=*/true, /*bActivate=*/true); +} + +void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView const& rOutlView) const +{ + vcl::Window* pWin = rOutlView.GetWindow(); + + if (!pWin) + return; + + const SdrTextObj* pText = GetTextEditObject(); + bool bTextFrame(pText && pText->IsTextFrame()); + bool bFitToSize(pText && pText->IsFitToSize()); + + if (!bTextFrame || bFitToSize) + return; + + tools::Rectangle aBlankRect(rOutlView.GetOutputArea()); + aBlankRect.Union(aMinTextEditArea); + tools::Rectangle aPixRect(pWin->LogicToPixel(aBlankRect)); + sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1); + + aPixRect.AdjustLeft(-1); + aPixRect.AdjustTop(-1); + aPixRect.AdjustRight(1); + aPixRect.AdjustBottom(1); + + { + // limit xPixRect because of driver problems when pixel coordinates are too far out + Size aMaxXY(pWin->GetOutputSizePixel()); + tools::Long a(2 * nPixSiz); + tools::Long nMaxX(aMaxXY.Width() + a); + tools::Long nMaxY(aMaxXY.Height() + a); + + if (aPixRect.Left() < -a) + aPixRect.SetLeft(-a); + if (aPixRect.Top() < -a) + aPixRect.SetTop(-a); + if (aPixRect.Right() > nMaxX) + aPixRect.SetRight(nMaxX); + if (aPixRect.Bottom() > nMaxY) + aPixRect.SetBottom(nMaxY); + } + + tools::Rectangle aOuterPix(aPixRect); + aOuterPix.AdjustLeft(-nPixSiz); + aOuterPix.AdjustTop(-nPixSiz); + aOuterPix.AdjustRight(nPixSiz); + aOuterPix.AdjustBottom(nPixSiz); + + bool bMapModeEnabled(pWin->IsMapModeEnabled()); + pWin->EnableMapMode(false); + pWin->Invalidate(aOuterPix); + pWin->EnableMapMode(bMapModeEnabled); +} + +OutlinerView* SdrObjEditView::ImpMakeOutlinerView(vcl::Window* pWin, OutlinerView* pGivenView, + SfxViewShell* pViewShell) const +{ + // background + Color aBackground(GetTextEditBackgroundColor(*this)); + rtl::Reference pText = mxWeakTextEditObj.get(); + bool bTextFrame = pText != nullptr && pText->IsTextFrame(); + bool bContourFrame = pText != nullptr && pText->IsContourTextFrame(); + // create OutlinerView + OutlinerView* pOutlView = pGivenView; + mpTextEditOutliner->SetUpdateLayout(false); + + if (pOutlView == nullptr) + { + pOutlView = new OutlinerView(mpTextEditOutliner.get(), pWin); + } + else + { + pOutlView->SetWindow(pWin); + } + + if (mbNegativeX) + pOutlView->GetEditView().SetNegativeX(mbNegativeX); + + // disallow scrolling + EVControlBits nStat = pOutlView->GetControlWord(); + nStat &= ~EVControlBits::AUTOSCROLL; + // AutoViewSize only if not ContourFrame. + if (!bContourFrame) + nStat |= EVControlBits::AUTOSIZE; + if (bTextFrame) + { + sal_uInt16 nPixSiz = maHdlList.GetHdlSize() * 2 + 1; + nStat |= EVControlBits::INVONEMORE; + pOutlView->SetInvalidateMore(nPixSiz); + } + pOutlView->SetControlWord(nStat); + pOutlView->SetBackgroundColor(aBackground); + + // In case we're in the process of constructing a new view shell, + // SfxViewShell::Current() may still point to the old one. So if possible, + // depend on the application owning this draw view to provide the view + // shell. + SfxViewShell* pSfxViewShell = pViewShell ? pViewShell : GetSfxViewShell(); + pOutlView->RegisterViewShell(pSfxViewShell ? pSfxViewShell : SfxViewShell::Current()); + + if (pText != nullptr) + { + pOutlView->SetAnchorMode(pText->GetOutlinerViewAnchorMode()); + mpTextEditOutliner->SetFixedCellHeight( + pText->GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + } + // do update before setting output area so that aTextEditArea can be recalculated + mpTextEditOutliner->SetUpdateLayout(true); + pOutlView->SetOutputArea(aTextEditArea); + ImpInvalidateOutlinerView(*pOutlView); + return pOutlView; +} + +IMPL_LINK(SdrObjEditView, ImpOutlinerStatusEventHdl, EditStatus&, rEditStat, void) +{ + if (mpTextEditOutliner) + { + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + if (pTextObj) + { + pTextObj->onEditOutlinerStatusEvent(&rEditStat); + } + } +} + +void SdrObjEditView::ImpChainingEventHdl() +{ + if (!mpTextEditOutliner) + return; + + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + OutlinerView* pOLV = GetTextEditOutlinerView(); + if (pTextObj && pOLV) + { + TextChain* pTextChain = pTextObj->GetTextChain(); + + // XXX: IsChainable and GetNilChainingEvent are a bit mixed up atm + if (!pTextObj->IsChainable()) + { + return; + } + // This is true during an underflow-caused overflow (with pEdtOutl->SetText()) + if (pTextChain->GetNilChainingEvent(pTextObj.get())) + { + return; + } + + // We prevent to trigger further handling of overflow/underflow for pTextObj + pTextChain->SetNilChainingEvent(pTextObj.get(), true); // XXX + + // Save previous selection pos // NOTE: It must be done to have the right CursorEvent in KeyInput + pTextChain->SetPreChainingSel(pTextObj.get(), pOLV->GetSelection()); + //maPreChainingSel = new ESelection(pOLV->GetSelection()); + + // Handling Undo + const int nText = 0; // XXX: hardcoded index (SdrTextObj::getText handles only 0) + + const bool bUndoEnabled = IsUndoEnabled(); + std::unique_ptr pTxtUndo; + if (bUndoEnabled) + pTxtUndo.reset( + dynamic_cast(GetModel() + .GetSdrUndoFactory() + .CreateUndoObjectSetText(*pTextObj, nText) + .release())); + + // trigger actual chaining + pTextObj->onChainingEvent(); + + if (pTxtUndo) + { + pTxtUndo->AfterSetText(); + if (!pTxtUndo->IsDifferent()) + { + pTxtUndo.reset(); + } + } + + if (pTxtUndo) + AddUndo(std::move(pTxtUndo)); + + //maCursorEvent = new CursorChainingEvent(pTextChain->GetCursorEvent(pTextObj)); + //SdrTextObj *pNextLink = pTextObj->GetNextLinkInChain(); + + // NOTE: Must be called. Don't let the function return if you set it to true and not reset it + pTextChain->SetNilChainingEvent(pTextObj.get(), false); + } + else + { + // XXX + SAL_INFO("svx.chaining", "[OnChaining] No Edit Outliner View"); + } +} + +IMPL_LINK_NOARG(SdrObjEditView, ImpAfterCutOrPasteChainingEventHdl, LinkParamNone*, void) +{ + SdrTextObj* pTextObj = GetTextEditObject(); + if (!pTextObj) + return; + ImpChainingEventHdl(); + TextChainCursorManager aCursorManager(this, pTextObj); + ImpMoveCursorAfterChainingEvent(&aCursorManager); +} + +void SdrObjEditView::ImpMoveCursorAfterChainingEvent(TextChainCursorManager* pCursorManager) +{ + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + + if (!pTextObj || !pCursorManager) + return; + + // Check if it has links to move it to + if (!pTextObj || !pTextObj->IsChainable()) + return; + + TextChain* pTextChain = pTextObj->GetTextChain(); + ESelection aNewSel = pTextChain->GetPostChainingSel(pTextObj.get()); + + pCursorManager->HandleCursorEventAfterChaining(pTextChain->GetCursorEvent(pTextObj.get()), + aNewSel); + + // Reset event + pTextChain->SetCursorEvent(pTextObj.get(), CursorChainingEvent::NULL_EVENT); +} + +IMPL_LINK(SdrObjEditView, ImpOutlinerCalcFieldValueHdl, EditFieldInfo*, pFI, void) +{ + bool bOk = false; + OUString& rStr = pFI->GetRepresentation(); + rStr.clear(); + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + if (pTextObj != nullptr) + { + std::optional pTxtCol; + std::optional pFldCol; + std::optional pFldLineStyle; + bOk = pTextObj->CalcFieldValue(pFI->GetField(), pFI->GetPara(), pFI->GetPos(), true, + pTxtCol, pFldCol, pFldLineStyle, rStr); + if (bOk) + { + if (pTxtCol) + { + pFI->SetTextColor(*pTxtCol); + } + if (pFldLineStyle) + { + pFI->SetFontLineStyle(*pFldLineStyle); + } + if (pFldCol) + { + pFI->SetFieldColor(*pFldCol); + } + else + { + pFI->SetFieldColor(COL_LIGHTGRAY); // TODO: remove this later on (357) + } + } + } + Outliner& rDrawOutl = GetModel().GetDrawOutliner(pTextObj.get()); + Link aDrawOutlLink = rDrawOutl.GetCalcFieldValueHdl(); + if (!bOk && aDrawOutlLink.IsSet()) + { + aDrawOutlLink.Call(pFI); + bOk = !rStr.isEmpty(); + } + if (!bOk) + { + aOldCalcFieldValueLink.Call(pFI); + } +} + +IMPL_LINK_NOARG(SdrObjEditView, EndTextEditHdl, SdrUndoManager*, void) { SdrEndTextEdit(); } + +// Default implementation - null UndoManager +std::unique_ptr SdrObjEditView::createLocalTextUndoManager() +{ + SAL_WARN("svx", "SdrObjEditView::createLocalTextUndoManager needs to be overridden"); + return std::unique_ptr(); +} + +bool SdrObjEditView::SdrBeginTextEdit(SdrObject* pObj_, SdrPageView* pPV, vcl::Window* pWin, + bool bIsNewObj, SdrOutliner* pGivenOutliner, + OutlinerView* pGivenOutlinerView, bool bDontDeleteOutliner, + bool bOnlyOneView, bool bGrabFocus) +{ + // FIXME cannot be an assert() yet, the code is not ready for that; + // eg. press F7 in Impress when you are inside a text object with spelling + // mistakes => boom; and it is unclear how to avoid that + SAL_WARN_IF(IsTextEdit(), "svx", "SdrBeginTextEdit called when IsTextEdit() is already true."); + // FIXME this encourages all sorts of bad habits and should be removed + SdrEndTextEdit(); + + SdrTextObj* pObj = DynCastSdrTextObj(pObj_); + if (!pObj) + return false; // currently only possible with text objects + + if (bGrabFocus && pWin) + { + // attention, this call may cause an EndTextEdit() call to this view + pWin->GrabFocus(); // to force the cursor into the edit view + } + + mbTextEditDontDelete = bDontDeleteOutliner && pGivenOutliner != nullptr; + mbTextEditOnlyOneView = bOnlyOneView; + mbTextEditNewObj = bIsNewObj; + const sal_uInt32 nWinCount(PaintWindowCount()); + + bool bBrk(false); + + if (!pWin) + { + for (sal_uInt32 i = 0; i < nWinCount && !pWin; i++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(i); + + if (OUTDEV_WINDOW == pPaintWindow->GetOutputDevice().GetOutDevType()) + { + pWin = pPaintWindow->GetOutputDevice().GetOwnerWindow(); + } + } + + // break, when no window exists + if (!pWin) + { + bBrk = true; + } + } + + if (!bBrk && !pPV) + { + pPV = GetSdrPageView(); + + // break, when no PageView for the object exists + if (!pPV) + { + bBrk = true; + } + } + + // no TextEdit on objects in locked Layer + if (pPV && pPV->GetLockedLayers().IsSet(pObj->GetLayer())) + { + bBrk = true; + } + + if (mpTextEditOutliner) + { + OSL_FAIL("SdrObjEditView::SdrBeginTextEdit(): Old Outliner still exists."); + mpTextEditOutliner.reset(); + } + + if (!bBrk) + { + mpTextEditWin = pWin; + mpTextEditPV = pPV; + mxWeakTextEditObj = pObj; + if (pGivenOutliner) + { + mpTextEditOutliner.reset(pGivenOutliner); + pGivenOutliner = nullptr; // so we don't delete it on the error path + } + else + mpTextEditOutliner + = SdrMakeOutliner(OutlinerMode::TextObject, pObj->getSdrModelFromSdrObject()); + + { + mpTextEditOutliner->ForceAutoColor(SvtAccessibilityOptions::GetIsAutomaticFontColor()); + } + + aOldCalcFieldValueLink = mpTextEditOutliner->GetCalcFieldValueHdl(); + // FieldHdl has to be set by SdrBeginTextEdit, because this call an UpdateFields + mpTextEditOutliner->SetCalcFieldValueHdl( + LINK(this, SdrObjEditView, ImpOutlinerCalcFieldValueHdl)); + mpTextEditOutliner->SetBeginPasteOrDropHdl(LINK(this, SdrObjEditView, BeginPasteOrDropHdl)); + mpTextEditOutliner->SetEndPasteOrDropHdl(LINK(this, SdrObjEditView, EndPasteOrDropHdl)); + + // It is just necessary to make the visualized page known. Set it. + mpTextEditOutliner->setVisualizedPage(pPV->GetPage()); + + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + mpTextEditOutliner->SetTextObjNoInit(pTextObj.get()); + + if (pTextObj->BegTextEdit(*mpTextEditOutliner)) + { + // switch off any running TextAnimations + pTextObj->SetTextAnimationAllowed(false); + + // remember old cursor + if (mpTextEditOutliner->GetViewCount() != 0) + { + mpTextEditOutliner->RemoveView(static_cast(0)); + } + + // Determine EditArea via TakeTextEditArea. + // TODO: This could theoretically be left out, because TakeTextRect() calculates the aTextEditArea, + // but aMinTextEditArea has to happen, too (therefore leaving this in right now) + pTextObj->TakeTextEditArea(nullptr, nullptr, &aTextEditArea, &aMinTextEditArea); + + tools::Rectangle aTextRect; + tools::Rectangle aAnchorRect; + pTextObj->TakeTextRect(*mpTextEditOutliner, aTextRect, true, + &aAnchorRect /* Give true here, not false */); + + if (!pTextObj->IsContourTextFrame()) + { + // FitToSize not together with ContourFrame, for now + if (pTextObj->IsFitToSize()) + aTextRect = aAnchorRect; + } + + aTextEditArea = aTextRect; + + // add possible GridOffset to up-to-now view-independent EditAreas + basegfx::B2DVector aGridOffset(0.0, 0.0); + if (getPossibleGridOffsetForSdrObject(aGridOffset, pTextObj.get(), pPV)) + { + const Point aOffset(basegfx::fround(aGridOffset.getX()), + basegfx::fround(aGridOffset.getY())); + + aTextEditArea += aOffset; + aMinTextEditArea += aOffset; + } + + Point aPvOfs(pTextObj->GetTextEditOffset()); + aTextEditArea.Move(aPvOfs.X(), aPvOfs.Y()); + aMinTextEditArea.Move(aPvOfs.X(), aPvOfs.Y()); + pTextEditCursorBuffer = pWin->GetCursor(); + + maHdlList.SetMoveOutside(true); + + // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary + // to call AdjustMarkHdl() always. + AdjustMarkHdl(); + + mpTextEditOutlinerView = ImpMakeOutlinerView(pWin, pGivenOutlinerView); + + if (!comphelper::LibreOfficeKit::isActive() && mpTextEditOutlinerView) + { + // activate visualization of EditView on Overlay, suppress when + // LibreOfficeKit is active + mpTextEditOutlinerView->GetEditView().setEditViewCallbacks(this); + + const Color aHilightColor(SvtOptionsDrawinglayer::getHilightColor()); + const SdrTextObj* pText = GetTextEditObject(); + // show for cases like tdf#94223 but not for table cells like tdf#151311 + const bool bVisualizeSurroundingFrame( + pText && pText->GetObjIdentifier() != SdrObjKind::Table); + SdrPageView* pPageView = GetSdrPageView(); + + if (pPageView) + { + for (sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if (rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference& xManager + = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + std::unique_ptr pNewTextEditOverlayObject( + new TextEditOverlayObject(aHilightColor, + *mpTextEditOutlinerView)); + + xManager->add(*pNewTextEditOverlayObject); + if (bVisualizeSurroundingFrame) + xManager->add(*pNewTextEditOverlayObject->getOverlayFrame()); + xManager->add(*pNewTextEditOverlayObject->getOverlaySelection()); + + maTEOverlayGroup.append(std::move(pNewTextEditOverlayObject)); + } + } + } + } + } + + // check if this view is already inserted + size_t i2, nCount = mpTextEditOutliner->GetViewCount(); + for (i2 = 0; i2 < nCount; i2++) + { + if (mpTextEditOutliner->GetView(i2) == mpTextEditOutlinerView) + break; + } + + if (i2 == nCount) + mpTextEditOutliner->InsertView(mpTextEditOutlinerView, 0); + + maHdlList.SetMoveOutside(false); + maHdlList.SetMoveOutside(true); + + // register all windows as OutlinerViews with the Outliner + if (!bOnlyOneView) + { + for (sal_uInt32 i = 0; i < nWinCount; i++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(i); + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + + if (&rOutDev != pWin->GetOutDev() && OUTDEV_WINDOW == rOutDev.GetOutDevType()) + { + OutlinerView* pOutlView + = ImpMakeOutlinerView(rOutDev.GetOwnerWindow(), nullptr); + mpTextEditOutliner->InsertView(pOutlView, static_cast(i)); + } + } + + if (comphelper::LibreOfficeKit::isActive()) + { + // Register an outliner view for all other sdr views that + // show the same page, so that when the text edit changes, + // all interested windows get an invalidation. + SdrViewIter::ForAllViews(pObj->getSdrPageFromSdrObject(), [this, &pWin]( + SdrView* pView) { + if (pView == this) + return; + + for (sal_uInt32 nViewPaintWindow = 0; + nViewPaintWindow < pView->PaintWindowCount(); ++nViewPaintWindow) + { + SdrPaintWindow* pPaintWindow = pView->GetPaintWindow(nViewPaintWindow); + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + + if (&rOutDev != pWin->GetOutDev() + && OUTDEV_WINDOW == rOutDev.GetOutDevType()) + { + OutlinerView* pOutlView + = ImpMakeOutlinerView(rOutDev.GetOwnerWindow(), nullptr); + pOutlView->HideCursor(); + rOutDev.GetOwnerWindow()->SetCursor(nullptr); + mpTextEditOutliner->InsertView(pOutlView); + } + } + }); + } + } + + mpTextEditOutlinerView->ShowCursor(); + mpTextEditOutliner->SetStatusEventHdl( + LINK(this, SdrObjEditView, ImpOutlinerStatusEventHdl)); + if (pTextObj->IsChainable()) + { + mpTextEditOutlinerView->SetEndCutPasteLinkHdl( + LINK(this, SdrObjEditView, ImpAfterCutOrPasteChainingEventHdl)); + } + + mpTextEditOutliner->ClearModifyFlag(); + + if (pTextObj->IsFitToSize()) + { + pWin->Invalidate(aTextEditArea); + } + + SdrHint aHint(SdrHintKind::BeginEdit, *pTextObj); + GetModel().Broadcast(aHint); + + mpTextEditOutliner->setVisualizedPage(nullptr); + + if (mxSelectionController.is()) + mxSelectionController->onSelectionHasChanged(); + + if (IsUndoEnabled() && !GetModel().GetDisableTextEditUsesCommonUndoManager()) + { + SdrUndoManager* pSdrUndoManager = nullptr; + mpLocalTextEditUndoManager = createLocalTextUndoManager(); + + if (mpLocalTextEditUndoManager) + pSdrUndoManager = mpLocalTextEditUndoManager.get(); + + if (pSdrUndoManager) + { + // we have an outliner, undo manager and it's an EditUndoManager, exchange + // the document undo manager and the default one from the outliner and tell + // it that text edit starts by setting a callback if it needs to end text edit mode. + assert(nullptr == mpOldTextEditUndoManager); + + mpOldTextEditUndoManager = mpTextEditOutliner->SetUndoManager(pSdrUndoManager); + pSdrUndoManager->SetEndTextEditHdl(LINK(this, SdrObjEditView, EndTextEditHdl)); + } + else + { + OSL_ENSURE(false, + "The document undo manager is not derived from SdrUndoManager (!)"); + } + } + + return true; // ran fine, let TextEdit run now + } + else + { + mpTextEditOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink); + mpTextEditOutliner->SetBeginPasteOrDropHdl(Link()); + mpTextEditOutliner->SetEndPasteOrDropHdl(Link()); + } + } + if (mpTextEditOutliner != nullptr) + { + mpTextEditOutliner->setVisualizedPage(nullptr); + } + + // something went wrong... + if (!bDontDeleteOutliner) + { + delete pGivenOutliner; + if (pGivenOutlinerView != nullptr) + { + delete pGivenOutlinerView; + pGivenOutlinerView = nullptr; + } + } + mpTextEditOutliner.reset(); + + mpTextEditOutlinerView = nullptr; + mxWeakTextEditObj.clear(); + mpTextEditPV = nullptr; + mpTextEditWin = nullptr; + maHdlList.SetMoveOutside(false); + + return false; +} + +SdrEndTextEditKind SdrObjEditView::SdrEndTextEdit(bool bDontDeleteReally) +{ + SdrEndTextEditKind eRet = SdrEndTextEditKind::Unchanged; + rtl::Reference pTEObj = mxWeakTextEditObj.get(); + vcl::Window* pTEWin = mpTextEditWin; + OutlinerView* pTEOutlinerView = mpTextEditOutlinerView; + vcl::Cursor* pTECursorBuffer = pTextEditCursorBuffer; + SdrUndoManager* pUndoEditUndoManager = nullptr; + bool bNeedToUndoSavedRedoTextEdit(false); + + if (IsUndoEnabled() && pTEObj && mpTextEditOutliner + && !GetModel().GetDisableTextEditUsesCommonUndoManager()) + { + // change back the UndoManager to the remembered original one + SfxUndoManager* pOriginal = mpTextEditOutliner->SetUndoManager(mpOldTextEditUndoManager); + mpOldTextEditUndoManager = nullptr; + + if (pOriginal) + { + // check if we got back our document undo manager + SdrUndoManager* pSdrUndoManager = mpLocalTextEditUndoManager.get(); + + if (pSdrUndoManager && dynamic_cast(pOriginal) == pSdrUndoManager) + { + if (pSdrUndoManager->isEndTextEditTriggeredFromUndo()) + { + // remember the UndoManager where missing Undos have to be triggered after end + // text edit. When the undo had triggered the end text edit, the original action + // which had to be undone originally is not yet undone. + pUndoEditUndoManager = pSdrUndoManager; + + // We are ending text edit; if text edit was triggered from undo, execute all redos + // to create a complete text change undo action for the redo buffer. Also mark this + // state when at least one redo was executed; the created extra TextChange needs to + // be undone in addition to the first real undo outside the text edit changes + while (pSdrUndoManager->GetRedoActionCount() + > pSdrUndoManager->GetRedoActionCountBeforeTextEdit()) + { + bNeedToUndoSavedRedoTextEdit = true; + pSdrUndoManager->Redo(); + } + } + + // reset the callback link and let the undo manager cleanup all text edit + // undo actions to get the stack back to the form before the text edit + pSdrUndoManager->SetEndTextEditHdl(Link()); + } + else + { + OSL_ENSURE(false, "Got UndoManager back in SdrEndTextEdit which is NOT the " + "expected document UndoManager (!)"); + delete pOriginal; + } + + // cid#1493241 - Wrapper object use after free + if (pUndoEditUndoManager == mpLocalTextEditUndoManager.get()) + pUndoEditUndoManager = nullptr; + mpLocalTextEditUndoManager.reset(); + } + } + else + { + assert(nullptr == mpOldTextEditUndoManager); // cannot be restored! + } + + if (auto pTextEditObj = mxWeakTextEditObj.get()) + { + SdrHint aHint(SdrHintKind::EndEdit, *pTextEditObj); + GetModel().Broadcast(aHint); + } + + // if new mechanism was used, clean it up. At cleanup no need to check + // for LibreOfficeKit + if (mpTextEditOutlinerView) + { + mpTextEditOutlinerView->GetEditView().setEditViewCallbacks(nullptr); + maTEOverlayGroup.clear(); + } + + mxWeakTextEditObj.clear(); + mpTextEditPV = nullptr; + mpTextEditWin = nullptr; + mpTextEditOutlinerView = nullptr; + pTextEditCursorBuffer = nullptr; + aTextEditArea = tools::Rectangle(); + + if (SdrOutliner* pTEOutliner = mpTextEditOutliner.release()) + { + bool bModified = pTEOutliner->IsModified(); + if (pTEOutlinerView != nullptr) + { + pTEOutlinerView->HideCursor(); + } + if (pTEObj != nullptr) + { + pTEOutliner->CompleteOnlineSpelling(); + + std::unique_ptr pTxtUndo; + + if (bModified) + { + sal_Int32 nText; + for (nText = 0; nText < pTEObj->getTextCount(); ++nText) + if (pTEObj->getText(nText) == pTEObj->getActiveText()) + break; + + pTxtUndo.reset( + dynamic_cast(GetModel() + .GetSdrUndoFactory() + .CreateUndoObjectSetText(*pTEObj, nText) + .release())); + } + DBG_ASSERT(!bModified || pTxtUndo, + "svx::SdrObjEditView::EndTextEdit(), could not create undo action!"); + // Set old CalcFieldValue-Handler again, this + // has to happen before Obj::EndTextEdit(), as this does UpdateFields(). + pTEOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink); + pTEOutliner->SetBeginPasteOrDropHdl(Link()); + pTEOutliner->SetEndPasteOrDropHdl(Link()); + + const bool bUndo = IsUndoEnabled(); + if (bUndo) + { + OUString aObjName(pTEObj->TakeObjNameSingul()); + BegUndo(SvxResId(STR_UndoObjSetText), aObjName); + } + + pTEObj->EndTextEdit(*pTEOutliner); + + if ((pTEObj->GetRotateAngle() != 0_deg100) || (pTEObj && pTEObj->IsFontwork())) + { + pTEObj->ActionChanged(); + } + + if (pTxtUndo != nullptr) + { + pTxtUndo->AfterSetText(); + if (!pTxtUndo->IsDifferent()) + { + pTxtUndo.reset(); + } + } + // check deletion of entire TextObj + std::unique_ptr pDelUndo; + bool bDelObj = false; + if (mbTextEditNewObj) + { + bDelObj = pTEObj->IsTextFrame() && !pTEObj->HasText() && !pTEObj->IsEmptyPresObj() + && !pTEObj->HasFill() && !pTEObj->HasLine(); + + if (pTEObj->IsInserted() && bDelObj + && pTEObj->GetObjInventor() == SdrInventor::Default && !bDontDeleteReally) + { + SdrObjKind eIdent = pTEObj->GetObjIdentifier(); + if (eIdent == SdrObjKind::Text) + { + pDelUndo = GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pTEObj); + } + } + } + if (pTxtUndo) + { + if (bUndo) + AddUndo(std::move(pTxtUndo)); + eRet = SdrEndTextEditKind::Changed; + } + if (pDelUndo != nullptr) + { + if (bUndo) + { + AddUndo(std::move(pDelUndo)); + } + eRet = SdrEndTextEditKind::Deleted; + DBG_ASSERT(pTEObj->getParentSdrObjListFromSdrObject() != nullptr, + "SdrObjEditView::SdrEndTextEdit(): Fatal: Object edited doesn't have an " + "ObjList!"); + if (pTEObj->getParentSdrObjListFromSdrObject() != nullptr) + { + pTEObj->getParentSdrObjListFromSdrObject()->RemoveObject(pTEObj->GetOrdNum()); + CheckMarked(); // remove selection immediately... + } + } + else if (bDelObj) + { // for Writer: the app has to do the deletion itself. + eRet = SdrEndTextEditKind::ShouldBeDeleted; + } + + if (bUndo) + EndUndo(); // EndUndo after Remove, in case UndoStack is deleted immediately + + // Switch on any TextAnimation again after TextEdit + if (pTEObj) + { + pTEObj->SetTextAnimationAllowed(true); + } + + // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary + // to call AdjustMarkHdl() always. + AdjustMarkHdl(); + } + // delete all OutlinerViews + for (size_t i = pTEOutliner->GetViewCount(); i > 0;) + { + i--; + OutlinerView* pOLV = pTEOutliner->GetView(i); + sal_uInt16 nMorePix = pOLV->GetInvalidateMore() + 10; + vcl::Window* pWin = pOLV->GetWindow(); + tools::Rectangle aRect(pOLV->GetOutputArea()); + pTEOutliner->RemoveView(i); + if (!mbTextEditDontDelete || i != 0) + { + // may not own the zeroth one + delete pOLV; + } + aRect.Union(aTextEditArea); + aRect.Union(aMinTextEditArea); + aRect = pWin->LogicToPixel(aRect); + aRect.AdjustLeft(-nMorePix); + aRect.AdjustTop(-nMorePix); + aRect.AdjustRight(nMorePix); + aRect.AdjustBottom(nMorePix); + aRect = pWin->PixelToLogic(aRect); + InvalidateOneWin(*pWin->GetOutDev(), aRect); + pWin->GetOutDev()->SetFillColor(); + pWin->GetOutDev()->SetLineColor(COL_BLACK); + } + // and now the Outliner itself + if (!mbTextEditDontDelete) + delete pTEOutliner; + else + pTEOutliner->Clear(); + if (pTEWin != nullptr) + { + pTEWin->SetCursor(pTECursorBuffer); + } + maHdlList.SetMoveOutside(false); + if (eRet != SdrEndTextEditKind::Unchanged) + { + GetMarkedObjectListWriteAccess().SetNameDirty(); + } + // coverity[leaked_storage] - if pTEOutliner wasn't deleted it didn't really belong to us + } + + if (pTEObj && !pTEObj->getSdrModelFromSdrObject().isLocked() && pTEObj->GetBroadcaster()) + { + SdrHint aHint(SdrHintKind::EndEdit, *pTEObj); + const_cast(pTEObj->GetBroadcaster())->Broadcast(aHint); + } + + if (pUndoEditUndoManager) + { + if (bNeedToUndoSavedRedoTextEdit) + { + // undo the text edit action since it was created as part of an EndTextEdit + // callback from undo itself. This needs to be done after the call to + // FmFormView::SdrEndTextEdit since it gets created there + pUndoEditUndoManager->Undo(); + } + + // trigger the Undo which was not executed, but lead to this + // end text edit + pUndoEditUndoManager->Undo(); + } + + return eRet; +} + +// info about TextEdit. Default is false. +bool SdrObjEditView::IsTextEdit() const { return mxWeakTextEditObj.get().is(); } + +// info about TextEditPageView. Default is 0L. +SdrPageView* SdrObjEditView::GetTextEditPageView() const { return mpTextEditPV; } + +OutlinerView* SdrObjEditView::ImpFindOutlinerView(vcl::Window const* pWin) const +{ + if (pWin == nullptr) + return nullptr; + if (mpTextEditOutliner == nullptr) + return nullptr; + OutlinerView* pNewView = nullptr; + size_t nWinCount = mpTextEditOutliner->GetViewCount(); + for (size_t i = 0; i < nWinCount && pNewView == nullptr; i++) + { + OutlinerView* pView = mpTextEditOutliner->GetView(i); + if (pView->GetWindow() == pWin) + pNewView = pView; + } + return pNewView; +} + +void SdrObjEditView::SetTextEditWin(vcl::Window* pWin) +{ + if (!(mxWeakTextEditObj.get() && pWin != nullptr && pWin != mpTextEditWin)) + return; + + OutlinerView* pNewView = ImpFindOutlinerView(pWin); + if (pNewView != nullptr && pNewView != mpTextEditOutlinerView) + { + if (mpTextEditOutlinerView != nullptr) + { + mpTextEditOutlinerView->HideCursor(); + } + mpTextEditOutlinerView = pNewView; + mpTextEditWin = pWin; + pWin->GrabFocus(); // Make the cursor blink here as well + pNewView->ShowCursor(); + ImpMakeTextCursorAreaVisible(); + } +} + +bool SdrObjEditView::IsTextEditHit(const Point& rHit) const +{ + bool bOk = false; + if (mxWeakTextEditObj.get()) + { + tools::Rectangle aEditArea; + if (OutlinerView* pOLV = mpTextEditOutliner->GetView(0)) + aEditArea.Union(pOLV->GetOutputArea()); + + if (aEditArea.Contains(rHit)) + { // check if any characters were actually hit + const Point aPnt(rHit - aEditArea.TopLeft()); + tools::Long nHitTol = 2000; + if (OutputDevice* pRef = mpTextEditOutliner->GetRefDevice()) + nHitTol = OutputDevice::LogicToLogic(nHitTol, MapUnit::Map100thMM, + pRef->GetMapMode().GetMapUnit()); + + bOk = mpTextEditOutliner->IsTextPos(aPnt, static_cast(nHitTol)); + } + } + return bOk; +} + +bool SdrObjEditView::IsTextEditFrameHit(const Point& rHit) const +{ + bool bOk = false; + if (rtl::Reference pText = mxWeakTextEditObj.get()) + { + OutlinerView* pOLV = mpTextEditOutliner->GetView(0); + if (pOLV) + { + vcl::Window* pWin = pOLV->GetWindow(); + if (pText != nullptr && pText->IsTextFrame() && pWin != nullptr) + { + sal_uInt16 nPixSiz = pOLV->GetInvalidateMore(); + tools::Rectangle aEditArea(aMinTextEditArea); + aEditArea.Union(pOLV->GetOutputArea()); + if (!aEditArea.Contains(rHit)) + { + Size aSiz(pWin->PixelToLogic(Size(nPixSiz, nPixSiz))); + aEditArea.AdjustLeft(-(aSiz.Width())); + aEditArea.AdjustTop(-(aSiz.Height())); + aEditArea.AdjustRight(aSiz.Width()); + aEditArea.AdjustBottom(aSiz.Height()); + bOk = aEditArea.Contains(rHit); + } + } + } + } + return bOk; +} + +std::unique_ptr +SdrObjEditView::ImpHandleMotionThroughBoxesKeyInput(const KeyEvent& rKEvt, bool* bOutHandled) +{ + *bOutHandled = false; + + rtl::Reference pTextObj = mxWeakTextEditObj.get(); + if (!pTextObj) + return nullptr; + + if (!pTextObj->GetNextLinkInChain() && !pTextObj->GetPrevLinkInChain()) + return nullptr; + + std::unique_ptr pCursorManager( + new TextChainCursorManager(this, pTextObj.get())); + if (pCursorManager->HandleKeyEvent(rKEvt)) + { + // Possibly do other stuff here if necessary... + // XXX: Careful with the checks below (in KeyInput) for pWin and co. You should do them here I guess. + *bOutHandled = true; + } + + return pCursorManager; +} + +bool SdrObjEditView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin) +{ + if (mpTextEditOutlinerView) + { + /* Start special handling of keys within a chain */ + // We possibly move to another box before any handling + bool bHandled = false; + std::unique_ptr xCursorManager( + ImpHandleMotionThroughBoxesKeyInput(rKEvt, &bHandled)); + if (bHandled) + return true; + /* End special handling of keys within a chain */ + + if (mpTextEditOutlinerView->PostKeyEvent(rKEvt, pWin)) + { + if (mpTextEditOutliner && mpTextEditOutliner->IsModified()) + GetModel().SetChanged(); + + /* Start chaining processing */ + ImpChainingEventHdl(); + ImpMoveCursorAfterChainingEvent(xCursorManager.get()); + /* End chaining processing */ + + if (pWin != nullptr && pWin != mpTextEditWin) + SetTextEditWin(pWin); + ImpMakeTextCursorAreaVisible(); + return true; + } + } + return SdrGlueEditView::KeyInput(rKEvt, pWin); +} + +bool SdrObjEditView::MouseButtonDown(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + if (mpTextEditOutlinerView != nullptr) + { + bool bPostIt = mpTextEditOutliner->IsInSelectionMode(); + if (!bPostIt) + { + Point aPt(rMEvt.GetPosPixel()); + if (pWin != nullptr) + aPt = pWin->PixelToLogic(aPt); + else if (mpTextEditWin != nullptr) + aPt = mpTextEditWin->PixelToLogic(aPt); + bPostIt = IsTextEditHit(aPt); + } + if (bPostIt) + { + Point aPixPos(rMEvt.GetPosPixel()); + if (pWin) + { + tools::Rectangle aR(pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea())); + if (aPixPos.X() < aR.Left()) + aPixPos.setX(aR.Left()); + if (aPixPos.X() > aR.Right()) + aPixPos.setX(aR.Right()); + if (aPixPos.Y() < aR.Top()) + aPixPos.setY(aR.Top()); + if (aPixPos.Y() > aR.Bottom()) + aPixPos.setY(aR.Bottom()); + } + MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), + rMEvt.GetModifier()); + if (mpTextEditOutlinerView->MouseButtonDown(aMEvt)) + { + if (pWin != nullptr && pWin != mpTextEditWin->GetOutDev() + && pWin->GetOutDevType() == OUTDEV_WINDOW) + SetTextEditWin(pWin->GetOwnerWindow()); + ImpMakeTextCursorAreaVisible(); + return true; + } + } + } + return SdrGlueEditView::MouseButtonDown(rMEvt, pWin); +} + +bool SdrObjEditView::MouseButtonUp(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + if (mpTextEditOutlinerView != nullptr) + { + bool bPostIt = mpTextEditOutliner->IsInSelectionMode(); + if (!bPostIt) + { + Point aPt(rMEvt.GetPosPixel()); + if (pWin != nullptr) + aPt = pWin->PixelToLogic(aPt); + else if (mpTextEditWin != nullptr) + aPt = mpTextEditWin->PixelToLogic(aPt); + bPostIt = IsTextEditHit(aPt); + } + if (bPostIt && pWin) + { + Point aPixPos(rMEvt.GetPosPixel()); + tools::Rectangle aR(pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea())); + if (aPixPos.X() < aR.Left()) + aPixPos.setX(aR.Left()); + if (aPixPos.X() > aR.Right()) + aPixPos.setX(aR.Right()); + if (aPixPos.Y() < aR.Top()) + aPixPos.setY(aR.Top()); + if (aPixPos.Y() > aR.Bottom()) + aPixPos.setY(aR.Bottom()); + MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), + rMEvt.GetModifier()); + if (mpTextEditOutlinerView->MouseButtonUp(aMEvt)) + { + ImpMakeTextCursorAreaVisible(); + return true; + } + } + } + return SdrGlueEditView::MouseButtonUp(rMEvt, pWin); +} + +bool SdrObjEditView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + if (mpTextEditOutlinerView != nullptr) + { + bool bSelMode = mpTextEditOutliner->IsInSelectionMode(); + bool bPostIt = bSelMode; + if (!bPostIt) + { + Point aPt(rMEvt.GetPosPixel()); + if (pWin) + aPt = pWin->PixelToLogic(aPt); + else if (mpTextEditWin) + aPt = mpTextEditWin->PixelToLogic(aPt); + bPostIt = IsTextEditHit(aPt); + } + if (bPostIt) + { + Point aPixPos(rMEvt.GetPosPixel()); + tools::Rectangle aR(mpTextEditOutlinerView->GetOutputArea()); + if (pWin) + aR = pWin->LogicToPixel(aR); + else if (mpTextEditWin) + aR = mpTextEditWin->LogicToPixel(aR); + if (aPixPos.X() < aR.Left()) + aPixPos.setX(aR.Left()); + if (aPixPos.X() > aR.Right()) + aPixPos.setX(aR.Right()); + if (aPixPos.Y() < aR.Top()) + aPixPos.setY(aR.Top()); + if (aPixPos.Y() > aR.Bottom()) + aPixPos.setY(aR.Bottom()); + MouseEvent aMEvt(aPixPos, rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), + rMEvt.GetModifier()); + if (mpTextEditOutlinerView->MouseMove(aMEvt) && bSelMode) + { + ImpMakeTextCursorAreaVisible(); + return true; + } + } + } + return SdrGlueEditView::MouseMove(rMEvt, pWin); +} + +bool SdrObjEditView::Command(const CommandEvent& rCEvt, vcl::Window* pWin) +{ + // as long as OutlinerView returns a sal_Bool, it only gets CommandEventId::StartDrag + if (mpTextEditOutlinerView != nullptr) + { + if (rCEvt.GetCommand() == CommandEventId::StartDrag) + { + bool bPostIt = mpTextEditOutliner->IsInSelectionMode() || !rCEvt.IsMouseEvent(); + if (!bPostIt && rCEvt.IsMouseEvent()) + { + Point aPt(rCEvt.GetMousePosPixel()); + if (pWin != nullptr) + aPt = pWin->PixelToLogic(aPt); + else if (mpTextEditWin != nullptr) + aPt = mpTextEditWin->PixelToLogic(aPt); + bPostIt = IsTextEditHit(aPt); + } + if (bPostIt) + { + Point aPixPos(rCEvt.GetMousePosPixel()); + if (rCEvt.IsMouseEvent() && pWin) + { + tools::Rectangle aR( + pWin->LogicToPixel(mpTextEditOutlinerView->GetOutputArea())); + if (aPixPos.X() < aR.Left()) + aPixPos.setX(aR.Left()); + if (aPixPos.X() > aR.Right()) + aPixPos.setX(aR.Right()); + if (aPixPos.Y() < aR.Top()) + aPixPos.setY(aR.Top()); + if (aPixPos.Y() > aR.Bottom()) + aPixPos.setY(aR.Bottom()); + } + CommandEvent aCEvt(aPixPos, rCEvt.GetCommand(), rCEvt.IsMouseEvent()); + // Command is void at the OutlinerView, sadly + mpTextEditOutlinerView->Command(aCEvt); + if (pWin != nullptr && pWin != mpTextEditWin) + SetTextEditWin(pWin); + ImpMakeTextCursorAreaVisible(); + return true; + } + } + else + { + mpTextEditOutlinerView->Command(rCEvt); + if (comphelper::LibreOfficeKit::isActive()) + { + // It could execute CommandEventId::ExtTextInput, while SdrObjEditView::KeyInput + // isn't called + if (mpTextEditOutliner && mpTextEditOutliner->IsModified()) + GetModel().SetChanged(); + } + return true; + } + } + return SdrGlueEditView::Command(rCEvt, pWin); +} + +bool SdrObjEditView::ImpIsTextEditAllSelected() const +{ + bool bRet = false; + if (mpTextEditOutliner != nullptr && mpTextEditOutlinerView != nullptr) + { + if (SdrTextObj::HasTextImpl(mpTextEditOutliner.get())) + { + const sal_Int32 nParaCnt = mpTextEditOutliner->GetParagraphCount(); + Paragraph* pLastPara + = mpTextEditOutliner->GetParagraph(nParaCnt > 1 ? nParaCnt - 1 : 0); + + ESelection aESel(mpTextEditOutlinerView->GetSelection()); + if (aESel.nStartPara == 0 && aESel.nStartPos == 0 && aESel.nEndPara == (nParaCnt - 1)) + { + if (mpTextEditOutliner->GetText(pLastPara).getLength() == aESel.nEndPos) + bRet = true; + } + // in case the selection was done backwards + if (!bRet && aESel.nEndPara == 0 && aESel.nEndPos == 0 + && aESel.nStartPara == (nParaCnt - 1)) + { + if (mpTextEditOutliner->GetText(pLastPara).getLength() == aESel.nStartPos) + bRet = true; + } + } + else + { + bRet = true; + } + } + return bRet; +} + +void SdrObjEditView::ImpMakeTextCursorAreaVisible() +{ + if (mpTextEditOutlinerView != nullptr && mpTextEditWin != nullptr) + { + vcl::Cursor* pCsr = mpTextEditWin->GetCursor(); + if (pCsr != nullptr) + { + Size aSiz(pCsr->GetSize()); + if (!aSiz.IsEmpty()) + { + MakeVisible(tools::Rectangle(pCsr->GetPos(), aSiz), *mpTextEditWin); + } + } + } +} + +SvtScriptType SdrObjEditView::GetScriptType() const +{ + SvtScriptType nScriptType = SvtScriptType::NONE; + + if (IsTextEdit()) + { + auto pText = mxWeakTextEditObj.get(); + if (pText->GetOutlinerParaObject()) + nScriptType = pText->GetOutlinerParaObject()->GetTextObject().GetScriptType(); + + if (mpTextEditOutlinerView) + nScriptType = mpTextEditOutlinerView->GetSelectedScriptType(); + } + else + { + const size_t nMarkCount(GetMarkedObjectCount()); + + for (size_t i = 0; i < nMarkCount; ++i) + { + OutlinerParaObject* pParaObj = GetMarkedObjectByIndex(i)->GetOutlinerParaObject(); + + if (pParaObj) + { + nScriptType |= pParaObj->GetTextObject().GetScriptType(); + } + } + } + + if (nScriptType == SvtScriptType::NONE) + nScriptType = SvtScriptType::LATIN; + + return nScriptType; +} + +void SdrObjEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const +{ + if (mxSelectionController.is()) + if (mxSelectionController->GetAttributes(rTargetSet, bOnlyHardAttr)) + return; + + if (IsTextEdit()) + { + DBG_ASSERT(mpTextEditOutlinerView != nullptr, + "SdrObjEditView::GetAttributes(): mpTextEditOutlinerView=NULL"); + DBG_ASSERT(mpTextEditOutliner != nullptr, + "SdrObjEditView::GetAttributes(): mpTextEditOutliner=NULL"); + + auto pText = mxWeakTextEditObj.get(); + // take care of bOnlyHardAttr(!) + if (!bOnlyHardAttr && pText->GetStyleSheet()) + rTargetSet.Put(pText->GetStyleSheet()->GetItemSet()); + + // add object attributes + rTargetSet.Put(pText->GetMergedItemSet()); + + if (mpTextEditOutlinerView) + { + // FALSE= regard InvalidItems as "holes," not as Default + rTargetSet.Put(mpTextEditOutlinerView->GetAttribs(), false); + } + + if (GetMarkedObjectCount() == 1 && GetMarkedObjectByIndex(0) == pText.get()) + { + MergeNotPersistAttrFromMarked(rTargetSet); + } + } + else + { + SdrGlueEditView::GetAttributes(rTargetSet, bOnlyHardAttr); + } +} + +bool SdrObjEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll) +{ + bool bRet = false; + rtl::Reference pTextEditObj = mxWeakTextEditObj.get(); + bool bTextEdit = mpTextEditOutlinerView != nullptr && pTextEditObj != nullptr; + bool bAllTextSelected = ImpIsTextEditAllSelected(); + const SfxItemSet* pSet = &rSet; + + if (!bTextEdit) + { + // no TextEdit active -> all Items to drawing object + if (mxSelectionController.is()) + bRet = mxSelectionController->SetAttributes(*pSet, bReplaceAll); + + if (!bRet) + { + SdrGlueEditView::SetAttributes(*pSet, bReplaceAll); + bRet = true; + } + } + else + { +#ifdef DBG_UTIL + { + bool bHasEEFeatureItems = false; + SfxItemIter aIter(rSet); + for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem; + pItem = aIter.NextItem()) + { + if (!IsInvalidItem(pItem)) + { + sal_uInt16 nW = pItem->Which(); + if (nW >= EE_FEATURE_START && nW <= EE_FEATURE_END) + bHasEEFeatureItems = true; + } + } + + if (bHasEEFeatureItems) + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog( + nullptr, VclMessageType::Info, VclButtonsType::Ok, + "SdrObjEditView::SetAttributes(): Setting EE_FEATURE items " + "at the SdrView does not make sense! It only leads to " + "overhead and unreadable documents.")); + xInfoBox->run(); + } + } +#endif + + bool bOnlyEEItems; + bool bNoEEItems = !SearchOutlinerItems(*pSet, bReplaceAll, &bOnlyEEItems); + // everything selected? -> attributes to the border, too + // if no EEItems, attributes to the border only + if (bAllTextSelected || bNoEEItems) + { + if (mxSelectionController.is()) + bRet = mxSelectionController->SetAttributes(*pSet, bReplaceAll); + + if (!bRet) + { + const bool bUndo = IsUndoEnabled(); + + if (bUndo) + { + BegUndo(ImpGetDescriptionString(STR_EditSetAttributes)); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pTextEditObj)); + + // If this is a text object also rescue the OutlinerParaObject since + // applying attributes to the object may change text layout when + // multiple portions exist with multiple formats. If an OutlinerParaObject + // really exists and needs to be rescued is evaluated in the undo + // implementation itself. + bool bRescueText(pTextEditObj); + + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject( + *pTextEditObj, false, !bNoEEItems || bRescueText)); + EndUndo(); + } + + pTextEditObj->SetMergedItemSetAndBroadcast(*pSet, bReplaceAll); + + FlushComeBackTimer(); // to set ModeHasChanged immediately + } + } + else if (!bOnlyEEItems) + { + // Otherwise split Set, if necessary. + // Now we build an ItemSet aSet that doesn't contain EE_Items from + // *pSet (otherwise it would be a copy). + WhichRangesContainer pNewWhichTable + = RemoveWhichRange(pSet->GetRanges(), EE_ITEMS_START, EE_ITEMS_END); + SfxItemSet aSet(GetModel().GetItemPool(), std::move(pNewWhichTable)); + SfxWhichIter aIter(aSet); + sal_uInt16 nWhich = aIter.FirstWhich(); + while (nWhich != 0) + { + const SfxPoolItem* pItem; + SfxItemState eState = pSet->GetItemState(nWhich, false, &pItem); + if (eState == SfxItemState::SET) + aSet.Put(*pItem); + nWhich = aIter.NextWhich(); + } + + if (mxSelectionController.is()) + bRet = mxSelectionController->SetAttributes(aSet, bReplaceAll); + + if (!bRet) + { + if (IsUndoEnabled()) + { + BegUndo(ImpGetDescriptionString(STR_EditSetAttributes)); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pTextEditObj)); + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoAttrObject(*pTextEditObj)); + EndUndo(); + } + + pTextEditObj->SetMergedItemSetAndBroadcast(aSet, bReplaceAll); + + if (GetMarkedObjectCount() == 1 && GetMarkedObjectByIndex(0) == pTextEditObj.get()) + { + SetNotPersistAttrToMarked(aSet); + } + } + FlushComeBackTimer(); + } + if (!bNoEEItems) + { + // and now the attributes to the EditEngine + if (bReplaceAll) + { + mpTextEditOutlinerView->RemoveAttribs(true); + } + mpTextEditOutlinerView->SetAttribs(rSet); + + Outliner* pTEOutliner = mpTextEditOutlinerView->GetOutliner(); + if (pTEOutliner && pTEOutliner->IsModified()) + GetModel().SetChanged(); + + ImpMakeTextCursorAreaVisible(); + } + bRet = true; + } + return bRet; +} + +SfxStyleSheet* SdrObjEditView::GetStyleSheet() const +{ + SfxStyleSheet* pSheet = nullptr; + + if (mxSelectionController.is()) + { + if (mxSelectionController->GetStyleSheet(pSheet)) + return pSheet; + } + + if (mpTextEditOutlinerView) + { + pSheet = mpTextEditOutlinerView->GetStyleSheet(); + } + else + { + pSheet = SdrGlueEditView::GetStyleSheet(); + } + return pSheet; +} + +void SdrObjEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + if (mxSelectionController.is()) + { + if (mxSelectionController->SetStyleSheet(pStyleSheet, bDontRemoveHardAttr)) + return; + } + + // if we are currently in edit mode we must also set the stylesheet + // on all paragraphs in the Outliner for the edit view + if (nullptr != mpTextEditOutlinerView) + { + Outliner* pOutliner = mpTextEditOutlinerView->GetOutliner(); + + const sal_Int32 nParaCount = pOutliner->GetParagraphCount(); + for (sal_Int32 nPara = 0; nPara < nParaCount; nPara++) + { + pOutliner->SetStyleSheet(nPara, pStyleSheet); + } + } + + SdrGlueEditView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr); +} + +void SdrObjEditView::AddDeviceToPaintView(OutputDevice& rNewDev, vcl::Window* pWindow) +{ + SdrGlueEditView::AddDeviceToPaintView(rNewDev, pWindow); + + if (mxWeakTextEditObj.get() && !mbTextEditOnlyOneView + && rNewDev.GetOutDevType() == OUTDEV_WINDOW) + { + OutlinerView* pOutlView = ImpMakeOutlinerView(rNewDev.GetOwnerWindow(), nullptr); + mpTextEditOutliner->InsertView(pOutlView); + } +} + +void SdrObjEditView::DeleteDeviceFromPaintView(OutputDevice& rOldDev) +{ + SdrGlueEditView::DeleteDeviceFromPaintView(rOldDev); + + if (mxWeakTextEditObj.get() && !mbTextEditOnlyOneView + && rOldDev.GetOutDevType() == OUTDEV_WINDOW) + { + for (size_t i = mpTextEditOutliner->GetViewCount(); i > 0;) + { + i--; + OutlinerView* pOLV = mpTextEditOutliner->GetView(i); + if (pOLV && pOLV->GetWindow() == rOldDev.GetOwnerWindow()) + { + mpTextEditOutliner->RemoveView(i); + } + } + } + + lcl_RemoveTextEditOutlinerViews(this, GetSdrPageView(), &rOldDev); +} + +bool SdrObjEditView::IsTextEditInSelectionMode() const +{ + return mpTextEditOutliner != nullptr && mpTextEditOutliner->IsInSelectionMode(); +} + +// MacroMode + +void SdrObjEditView::BegMacroObj(const Point& rPnt, short nTol, SdrObject* pObj, SdrPageView* pPV, + vcl::Window* pWin) +{ + BrkMacroObj(); + if (pObj != nullptr && pPV != nullptr && pWin != nullptr && pObj->HasMacro()) + { + nTol = ImpGetHitTolLogic(nTol, nullptr); + pMacroObj = pObj; + pMacroPV = pPV; + pMacroWin = pWin; + mbMacroDown = false; + nMacroTol = sal_uInt16(nTol); + aMacroDownPos = rPnt; + MovMacroObj(rPnt); + } +} + +void SdrObjEditView::ImpMacroUp(const Point& rUpPos) +{ + if (pMacroObj != nullptr && mbMacroDown) + { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos = rUpPos; + aHitRec.nTol = nMacroTol; + aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers(); + aHitRec.pPageView = pMacroPV; + pMacroObj->PaintMacro(*pMacroWin->GetOutDev(), tools::Rectangle(), aHitRec); + mbMacroDown = false; + } +} + +void SdrObjEditView::ImpMacroDown(const Point& rDownPos) +{ + if (pMacroObj != nullptr && !mbMacroDown) + { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos = rDownPos; + aHitRec.nTol = nMacroTol; + aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers(); + aHitRec.pPageView = pMacroPV; + pMacroObj->PaintMacro(*pMacroWin->GetOutDev(), tools::Rectangle(), aHitRec); + mbMacroDown = true; + } +} + +void SdrObjEditView::MovMacroObj(const Point& rPnt) +{ + if (pMacroObj == nullptr) + return; + + SdrObjMacroHitRec aHitRec; + aHitRec.aPos = rPnt; + aHitRec.nTol = nMacroTol; + aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers(); + aHitRec.pPageView = pMacroPV; + bool bDown = pMacroObj->IsMacroHit(aHitRec); + if (bDown) + ImpMacroDown(rPnt); + else + ImpMacroUp(rPnt); +} + +void SdrObjEditView::BrkMacroObj() +{ + if (pMacroObj != nullptr) + { + ImpMacroUp(aMacroDownPos); + pMacroObj = nullptr; + pMacroPV = nullptr; + pMacroWin = nullptr; + } +} + +bool SdrObjEditView::EndMacroObj() +{ + if (pMacroObj != nullptr && mbMacroDown) + { + ImpMacroUp(aMacroDownPos); + SdrObjMacroHitRec aHitRec; + aHitRec.aPos = aMacroDownPos; + aHitRec.nTol = nMacroTol; + aHitRec.pVisiLayer = &pMacroPV->GetVisibleLayers(); + aHitRec.pPageView = pMacroPV; + bool bRet = pMacroObj->DoMacro(aHitRec); + pMacroObj = nullptr; + pMacroPV = nullptr; + pMacroWin = nullptr; + return bRet; + } + else + { + BrkMacroObj(); + return false; + } +} + +/** fills the given any with a XTextCursor for the current text selection. + Leaves the any untouched if there currently is no text selected */ +void SdrObjEditView::getTextSelection(css::uno::Any& rSelection) +{ + if (!IsTextEdit()) + return; + + OutlinerView* pOutlinerView = GetTextEditOutlinerView(); + if (!(pOutlinerView && pOutlinerView->HasSelection())) + return; + + SdrObject* pObj = GetTextEditObject(); + + if (!pObj) + return; + + css::uno::Reference xText(pObj->getUnoShape(), css::uno::UNO_QUERY); + if (xText.is()) + { + SvxUnoTextBase* pRange = comphelper::getFromUnoTunnel(xText); + if (pRange) + { + rSelection <<= pRange->createTextCursorBySelection(pOutlinerView->GetSelection()); + } + } +} + +/* check if we have a single selection and that single object likes + to handle the mouse and keyboard events itself + + TODO: the selection controller should be queried from the + object specific view contact. Currently this method only + works for tables. +*/ +void SdrObjEditView::MarkListHasChanged() +{ + SdrGlueEditView::MarkListHasChanged(); + + if (mxSelectionController.is()) + { + mxLastSelectionController = mxSelectionController; + mxSelectionController->onSelectionHasChanged(); + } + + mxSelectionController.clear(); + + const SdrMarkList& rMarkList = GetMarkedObjectList(); + if (rMarkList.GetMarkCount() != 1) + return; + + const SdrObject* pObj(rMarkList.GetMark(0)->GetMarkedSdrObj()); + SdrView* pView(dynamic_cast(this)); + + // check for table + if (pObj && pView && (pObj->GetObjInventor() == SdrInventor::Default) + && (pObj->GetObjIdentifier() == SdrObjKind::Table)) + { + mxSelectionController = sdr::table::CreateTableController( + *pView, static_cast(*pObj), mxLastSelectionController); + + if (mxSelectionController.is()) + { + mxLastSelectionController.clear(); + mxSelectionController->onSelectionHasChanged(); + } + } +} + +IMPL_LINK(SdrObjEditView, EndPasteOrDropHdl, PasteOrDropInfos*, pInfo, void) +{ + OnEndPasteOrDrop(pInfo); +} + +IMPL_LINK(SdrObjEditView, BeginPasteOrDropHdl, PasteOrDropInfos*, pInfo, void) +{ + OnBeginPasteOrDrop(pInfo); +} + +void SdrObjEditView::OnBeginPasteOrDrop(PasteOrDropInfos*) +{ + // applications can derive from these virtual methods to do something before a drop or paste operation +} + +void SdrObjEditView::OnEndPasteOrDrop(PasteOrDropInfos*) +{ + // applications can derive from these virtual methods to do something before a drop or paste operation +} + +sal_uInt16 SdrObjEditView::GetSelectionLevel() const +{ + sal_uInt16 nLevel = 0xFFFF; + if (IsTextEdit()) + { + DBG_ASSERT(mpTextEditOutlinerView != nullptr, + "SdrObjEditView::GetAttributes(): mpTextEditOutlinerView=NULL"); + DBG_ASSERT(mpTextEditOutliner != nullptr, + "SdrObjEditView::GetAttributes(): mpTextEditOutliner=NULL"); + if (mpTextEditOutlinerView) + { + //start and end position + ESelection aSelect = mpTextEditOutlinerView->GetSelection(); + sal_uInt16 nStartPara = ::std::min(aSelect.nStartPara, aSelect.nEndPara); + sal_uInt16 nEndPara = ::std::max(aSelect.nStartPara, aSelect.nEndPara); + //get level from each paragraph + nLevel = 0; + for (sal_uInt16 nPara = nStartPara; nPara <= nEndPara; nPara++) + { + sal_uInt16 nParaDepth + = 1 << static_cast(mpTextEditOutliner->GetDepth(nPara)); + if (!(nLevel & nParaDepth)) + nLevel += nParaDepth; + } + //reduce one level for Outliner Object + //if( nLevel > 0 && GetTextEditObject()->GetObjIdentifier() == OBJ_OUTLINETEXT ) + // nLevel = nLevel >> 1; + //no bullet paragraph selected + if (nLevel == 0) + nLevel = 0xFFFF; + } + } + return nLevel; +} + +bool SdrObjEditView::SupportsFormatPaintbrush(SdrInventor nObjectInventor, + SdrObjKind nObjectIdentifier) +{ + if (nObjectInventor != SdrInventor::Default && nObjectInventor != SdrInventor::E3d) + return false; + switch (nObjectIdentifier) + { + case SdrObjKind::NONE: + case SdrObjKind::Group: + return false; + case SdrObjKind::Line: + case SdrObjKind::Rectangle: + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::CircleSection: + case SdrObjKind::CircleArc: + case SdrObjKind::CircleCut: + case SdrObjKind::Polygon: + case SdrObjKind::PolyLine: + case SdrObjKind::PathLine: + case SdrObjKind::PathFill: + case SdrObjKind::FreehandLine: + case SdrObjKind::FreehandFill: + case SdrObjKind::Text: + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + case SdrObjKind::Graphic: + case SdrObjKind::OLE2: + case SdrObjKind::Table: + return true; + case SdrObjKind::Caption: + return false; + case SdrObjKind::Edge: + case SdrObjKind::PathPoly: + case SdrObjKind::PathPolyLine: + return true; + case SdrObjKind::Page: + case SdrObjKind::Measure: + case SdrObjKind::OLEPluginFrame: + case SdrObjKind::UNO: + return false; + case SdrObjKind::CustomShape: + return true; + default: + return false; + } +} + +static const WhichRangesContainer& GetFormatRangeImpl(bool bTextOnly) +{ + static const WhichRangesContainer gFull( + svl::Items); + + static const WhichRangesContainer gTextOnly( + svl::Items); + + return bTextOnly ? gTextOnly : gFull; +} + +void SdrObjEditView::TakeFormatPaintBrush(std::shared_ptr& rFormatSet) +{ + const SdrMarkList& rMarkList = GetMarkedObjectList(); + if (rMarkList.GetMarkCount() <= 0) + return; + + OutlinerView* pOLV = GetTextEditOutlinerView(); + + rFormatSet = std::make_shared(GetModel().GetItemPool(), + GetFormatRangeImpl(pOLV != nullptr)); + if (pOLV) + { + rFormatSet->Put(pOLV->GetAttribs()); + } + else + { + const bool bOnlyHardAttr = false; + rFormatSet->Put(GetAttrFromMarked(bOnlyHardAttr)); + } + + // check for cloning from table cell, in which case we need to copy cell-specific formatting attributes + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + if (pObj && (pObj->GetObjInventor() == SdrInventor::Default) + && (pObj->GetObjIdentifier() == SdrObjKind::Table)) + { + auto pTable = static_cast(pObj); + if (mxSelectionController.is() && pTable->getActiveCell().is()) + { + mxSelectionController->GetAttributes(*rFormatSet, false); + } + } +} + +static SfxItemSet CreatePaintSet(const WhichRangesContainer& pRanges, SfxItemPool& rPool, + const SfxItemSet& rSourceSet, const SfxItemSet& rTargetSet, + bool bNoCharacterFormats, bool bNoParagraphFormats) +{ + SfxItemSet aPaintSet(rPool, pRanges); + + for (const auto& pRange : pRanges) + { + sal_uInt16 nWhich = pRange.first; + const sal_uInt16 nLastWhich = pRange.second; + + if (bNoCharacterFormats && (nWhich == EE_CHAR_START)) + continue; + + if (bNoParagraphFormats && (nWhich == EE_PARA_START)) + continue; + + for (; nWhich <= nLastWhich; nWhich++) + { + const SfxPoolItem* pSourceItem = rSourceSet.GetItem(nWhich); + const SfxPoolItem* pTargetItem = rTargetSet.GetItem(nWhich); + + if ((pSourceItem && !pTargetItem) + || (pSourceItem && pTargetItem && *pSourceItem != *pTargetItem)) + { + aPaintSet.Put(*pSourceItem); + } + } + } + return aPaintSet; +} + +void SdrObjEditView::ApplyFormatPaintBrushToText(SfxItemSet const& rFormatSet, SdrTextObj& rTextObj, + SdrText* pText, bool bNoCharacterFormats, + bool bNoParagraphFormats) +{ + OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr; + if (!pParaObj) + return; + + SdrOutliner& rOutliner = rTextObj.ImpGetDrawOutliner(); + rOutliner.SetText(*pParaObj); + + sal_Int32 nParaCount(rOutliner.GetParagraphCount()); + + if (!nParaCount) + return; + + for (sal_Int32 nPara = 0; nPara < nParaCount; nPara++) + { + if (!bNoCharacterFormats) + rOutliner.RemoveCharAttribs(nPara); + + SfxItemSet aSet(rOutliner.GetParaAttribs(nPara)); + aSet.Put(CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet, + bNoCharacterFormats, bNoParagraphFormats)); + rOutliner.SetParaAttribs(nPara, aSet); + } + + std::optional pTemp = rOutliner.CreateParaObject(0, nParaCount); + rOutliner.Clear(); + + rTextObj.NbcSetOutlinerParaObjectForText(std::move(pTemp), pText); +} + +void SdrObjEditView::DisposeUndoManager() +{ + if (mpTextEditOutliner) + { + if (typeid(mpTextEditOutliner->GetUndoManager()) != typeid(EditUndoManager)) + { + // Non-owning pointer, clear it. + mpTextEditOutliner->SetUndoManager(nullptr); + } + } + + mpOldTextEditUndoManager = nullptr; +} + +void SdrObjEditView::ApplyFormatPaintBrush(SfxItemSet& rFormatSet, bool bNoCharacterFormats, + bool bNoParagraphFormats) +{ + if (mxSelectionController.is() + && mxSelectionController->ApplyFormatPaintBrush(rFormatSet, bNoCharacterFormats, + bNoParagraphFormats)) + { + return; + } + + OutlinerView* pOLV = GetTextEditOutlinerView(); + const SdrMarkList& rMarkList = GetMarkedObjectList(); + if (!pOLV) + { + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + const SfxItemSet& rShapeSet = pObj->GetMergedItemSet(); + + // if not in text edit mode (aka the user selected text or clicked on a word) + // apply formatting attributes to selected shape + // All formatting items (see ranges above) that are unequal in selected shape and + // the format paintbrush are hard set on the selected shape. + + const WhichRangesContainer& pRanges = rFormatSet.GetRanges(); + bool bTextOnly = true; + + for (const auto& pRange : pRanges) + { + if ((pRange.first != EE_PARA_START) && (pRange.first != EE_CHAR_START)) + { + bTextOnly = false; + break; + } + } + + if (!bTextOnly) + { + SfxItemSet aPaintSet(CreatePaintSet(GetFormatRangeImpl(false), *rShapeSet.GetPool(), + rFormatSet, rShapeSet, bNoCharacterFormats, + bNoParagraphFormats)); + SetAttrToMarked(aPaintSet, false /*bReplaceAll*/); + } + + // now apply character and paragraph formatting to text, if the shape has any + SdrTextObj* pTextObj = DynCastSdrTextObj(pObj); + if (pTextObj) + { + sal_Int32 nText = pTextObj->getTextCount(); + + while (--nText >= 0) + { + SdrText* pText = pTextObj->getText(nText); + ApplyFormatPaintBrushToText(rFormatSet, *pTextObj, pText, bNoCharacterFormats, + bNoParagraphFormats); + } + } + } + else + { + ::Outliner* pOutliner = pOLV->GetOutliner(); + if (pOutliner) + { + const EditEngine& rEditEngine = pOutliner->GetEditEngine(); + + ESelection aSel(pOLV->GetSelection()); + if (!aSel.HasRange()) + pOLV->SetSelection(rEditEngine.GetWord(aSel, css::i18n::WordType::DICTIONARY_WORD)); + + const bool bRemoveParaAttribs = !bNoParagraphFormats; + pOLV->RemoveAttribsKeepLanguages(bRemoveParaAttribs); + SfxItemSet aSet(pOLV->GetAttribs()); + SfxItemSet aPaintSet(CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(), + rFormatSet, aSet, bNoCharacterFormats, + bNoParagraphFormats)); + pOLV->SetAttribs(aPaintSet); + } + } + + // check for cloning to table cell, in which case we need to copy cell-specific formatting attributes + SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + if (pObj && (pObj->GetObjInventor() == SdrInventor::Default) + && (pObj->GetObjIdentifier() == SdrObjKind::Table)) + { + auto pTable = static_cast(pObj); + if (pTable->getActiveCell().is() && mxSelectionController.is()) + { + mxSelectionController->SetAttributes(rFormatSet, false); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdetc.cxx b/svx/source/svdraw/svdetc.cxx new file mode 100644 index 0000000000..e5f99a8f8f --- /dev/null +++ b/svx/source/svdraw/svdetc.cxx @@ -0,0 +1,704 @@ +/* -*- 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 + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +using namespace ::com::sun::star; + +// Global data of the DrawingEngine +SdrGlobalData::SdrGlobalData() +{ + if (!utl::ConfigManager::IsFuzzing()) + { + svx::ExtrusionBar::RegisterInterface(); + svx::FontworkBar::RegisterInterface(); + } +} + +const LocaleDataWrapper& SdrGlobalData::GetLocaleData() +{ + return GetSysLocale().GetLocaleData(); +} + +namespace { + +struct TheSdrGlobalData: public rtl::Static {}; + +} + +SdrGlobalData & GetSdrGlobalData() { + return TheSdrGlobalData::get(); +} + +OLEObjCache::OLEObjCache() +{ + if (!utl::ConfigManager::IsFuzzing()) + { +// This limit is only useful on 32-bit windows, where we can run out of virtual memory (see tdf#95579) +// For everything else, we are better off keeping it in main memory rather than using our hacky page-out thing +#if defined _WIN32 && !defined _WIN64 + nSize = officecfg::Office::Common::Cache::DrawingEngine::OLE_Objects::get(); +#else + nSize = SAL_MAX_INT32; // effectively disable the page-out mechanism +#endif + } + else + nSize = 100; + pTimer.reset( new AutoTimer( "svx OLEObjCache pTimer UnloadCheck" ) ); + pTimer->SetInvokeHandler( LINK(this, OLEObjCache, UnloadCheckHdl) ); + pTimer->SetTimeout(20000); + pTimer->SetStatic(); +} + +OLEObjCache::~OLEObjCache() +{ + pTimer->Stop(); +} + +IMPL_LINK_NOARG(OLEObjCache, UnloadCheckHdl, Timer*, void) +{ + if (nSize >= maObjs.size()) + return; + + // more objects than configured cache size try to remove objects + // of course not the freshly inserted one at nIndex=0 + size_t nCount2 = maObjs.size(); + size_t nIndex = nCount2-1; + while( nIndex && nCount2 > nSize ) + { + SdrOle2Obj* pUnloadObj = maObjs[nIndex--]; + if (!pUnloadObj) + continue; + + try + { + // it is important to get object without reinitialization to avoid reentrance + const uno::Reference< embed::XEmbeddedObject > & xUnloadObj = pUnloadObj->GetObjRef_NoInit(); + + bool bUnload = !xUnloadObj || SdrOle2Obj::CanUnloadRunningObj( xUnloadObj, pUnloadObj->GetAspect() ); + + // check whether the object can be unloaded before looking for the parent objects + if ( xUnloadObj.is() && bUnload ) + { + uno::Reference< frame::XModel > xUnloadModel( xUnloadObj->getComponent(), uno::UNO_QUERY ); + if ( xUnloadModel.is() ) + { + for (SdrOle2Obj* pCacheObj : maObjs) + { + if ( pCacheObj && pCacheObj != pUnloadObj ) + { + uno::Reference< frame::XModel > xParentModel = pCacheObj->GetParentXModel(); + if ( xUnloadModel == xParentModel ) + { + bUnload = false; // the object has running embedded objects + break; + } + } + } + } + } + + if (bUnload && UnloadObj(*pUnloadObj)) + { + // object was successfully unloaded + RemoveObj(pUnloadObj); + nCount2 = std::min(nCount2 - 1, maObjs.size()); + if (nIndex >= nCount2) + nIndex = nCount2 - 1; + } + } + catch( uno::Exception& ) + {} + } +} + +void OLEObjCache::InsertObj(SdrOle2Obj* pObj) +{ + if (!maObjs.empty()) + { + SdrOle2Obj* pExistingObj = maObjs.front(); + if ( pObj == pExistingObj ) + // the object is already on the top, nothing has to be changed + return; + } + + // get the old position of the object to know whether it is already in container + std::vector::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj); + bool bFound = it != maObjs.end(); + + if (bFound) + maObjs.erase(it); + // insert object into first position + maObjs.insert(maObjs.begin(), pObj); + + // if a new object was inserted, recalculate the cache + if (!bFound) + pTimer->Invoke(); + + if (!bFound || !pTimer->IsActive()) + pTimer->Start(); +} + +void OLEObjCache::RemoveObj(SdrOle2Obj* pObj) +{ + std::vector::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj); + if (it != maObjs.end()) + maObjs.erase(it); + if (maObjs.empty()) + pTimer->Stop(); +} + +size_t OLEObjCache::size() const +{ + return maObjs.size(); +} + +SdrOle2Obj* OLEObjCache::operator[](size_t nPos) +{ + return maObjs[nPos]; +} + +const SdrOle2Obj* OLEObjCache::operator[](size_t nPos) const +{ + return maObjs[nPos]; +} + +bool OLEObjCache::UnloadObj(SdrOle2Obj& rObj) +{ + bool bUnloaded = false; + + //#i80528# The old mechanism is completely useless, only taking into account if + // in all views the GrafDraft feature is used. This will nearly never have been the + // case since no one ever used this option. + + // A much better (and working) criteria would be the VOC contact count. + // The question is what will happen when i make it work now suddenly? I + // will try it for 2.4. + const sdr::contact::ViewContact& rViewContact = rObj.GetViewContact(); + const bool bVisible(rViewContact.HasViewObjectContacts()); + + if(!bVisible) + { + bUnloaded = rObj.Unload(); + } + + return bUnloaded; +} + +std::optional GetDraftFillColor(const SfxItemSet& rSet) +{ + drawing::FillStyle eFill=rSet.Get(XATTR_FILLSTYLE).GetValue(); + + switch(eFill) + { + case drawing::FillStyle_SOLID: + { + return rSet.Get(XATTR_FILLCOLOR).GetColorValue(); + } + case drawing::FillStyle_HATCH: + { + Color aCol1(rSet.Get(XATTR_FILLHATCH).GetHatchValue().GetColor()); + Color aCol2(COL_WHITE); + + // when hatched background is activated, use object fill color as hatch color + bool bFillHatchBackground = rSet.Get(XATTR_FILLBACKGROUND).GetValue(); + if(bFillHatchBackground) + { + aCol2 = rSet.Get(XATTR_FILLCOLOR).GetColorValue(); + } + + const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor())); + return Color(aAverageColor); + } + case drawing::FillStyle_GRADIENT: { + const basegfx::BGradient& rGrad=rSet.Get(XATTR_FILLGRADIENT).GetGradientValue(); + Color aCol1(Color(rGrad.GetColorStops().front().getStopColor())); + Color aCol2(Color(rGrad.GetColorStops().back().getStopColor())); + const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor())); + return Color(aAverageColor); + } + case drawing::FillStyle_BITMAP: + { + Bitmap aBitmap(rSet.Get(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic().GetBitmapEx().GetBitmap()); + const Size aSize(aBitmap.GetSizePixel()); + const sal_uInt32 nWidth = aSize.Width(); + const sal_uInt32 nHeight = aSize.Height(); + if (nWidth <= 0 || nHeight <= 0) + return {}; + + BitmapScopedReadAccess pAccess(aBitmap); + + if (pAccess) + { + sal_uInt32 nRt(0); + sal_uInt32 nGn(0); + sal_uInt32 nBl(0); + const sal_uInt32 nMaxSteps(8); + const sal_uInt32 nXStep((nWidth > nMaxSteps) ? nWidth / nMaxSteps : 1); + const sal_uInt32 nYStep((nHeight > nMaxSteps) ? nHeight / nMaxSteps : 1); + sal_uInt32 nCount(0); + + for(sal_uInt32 nY(0); nY < nHeight; nY += nYStep) + { + for(sal_uInt32 nX(0); nX < nWidth; nX += nXStep) + { + const BitmapColor& rCol2 = pAccess->GetColor(nY, nX); + + nRt += rCol2.GetRed(); + nGn += rCol2.GetGreen(); + nBl += rCol2.GetBlue(); + nCount++; + } + } + + nRt /= nCount; + nGn /= nCount; + nBl /= nCount; + + return Color(sal_uInt8(nRt), sal_uInt8(nGn), sal_uInt8(nBl)); + } + break; + } + default: break; + } + + return {}; +} + +std::unique_ptr SdrMakeOutliner(OutlinerMode nOutlinerMode, SdrModel& rModel) +{ + SfxItemPool* pPool = &rModel.GetItemPool(); + std::unique_ptr pOutl(new SdrOutliner( pPool, nOutlinerMode )); + pOutl->SetEditTextObjectPool( pPool ); + pOutl->SetStyleSheetPool( static_cast(rModel.GetStyleSheetPool())); + pOutl->SetDefTab(rModel.GetDefaultTabulator()); + Outliner::SetForbiddenCharsTable(rModel.GetForbiddenCharsTable()); + pOutl->SetAsianCompressionMode(rModel.GetCharCompressType()); + pOutl->SetKernAsianPunctuation(rModel.IsKernAsianPunctuation()); + pOutl->SetAddExtLeading(rModel.IsAddExtLeading()); + return pOutl; +} + +std::vector>>& ImpGetUserMakeObjHdl() +{ + SdrGlobalData& rGlobalData=GetSdrGlobalData(); + return rGlobalData.aUserMakeObjHdl; +} + +bool SearchOutlinerItems(const SfxItemSet& rSet, bool bInklDefaults, bool* pbOnlyEE) +{ + bool bHas=false; + bool bOnly=true; + bool bLookOnly=pbOnlyEE!=nullptr; + SfxWhichIter aIter(rSet); + sal_uInt16 nWhich=aIter.FirstWhich(); + while (((bLookOnly && bOnly) || !bHas) && nWhich!=0) { + // For bInklDefaults, the entire Which range is decisive, + // in other cases only the set items are. + // Disabled and DontCare are regarded as holes in the Which range. + SfxItemState eState=aIter.GetItemState(); + if ((eState==SfxItemState::DEFAULT && bInklDefaults) || eState==SfxItemState::SET) { + if (nWhichEE_ITEMS_END) bOnly=false; + else bHas=true; + } + nWhich=aIter.NextWhich(); + } + if (!bHas) bOnly=false; + if (pbOnlyEE!=nullptr) *pbOnlyEE=bOnly; + return bHas; +} + +WhichRangesContainer RemoveWhichRange(const WhichRangesContainer& pOldWhichTable, sal_uInt16 nRangeBeg, sal_uInt16 nRangeEnd) +{ + // Six possible cases (per range): + // [Beg..End] [nRangeBeg, nRangeEnd], to delete + // [b..e] [b..e] [b..e] Cases 1,3,2: doesn't matter, delete, doesn't matter + Ranges + // [b........e] [b........e] Cases 4,5 : shrink range | in + // [b......................e] Case 6 : splitting + pOldWhichTable + std::vector buf; + for (const auto & rPair : pOldWhichTable) { + auto const begin = rPair.first; + auto const end = rPair.second; + if (end < nRangeBeg || begin > nRangeEnd) { // cases 1, 2 + buf.push_back({begin, end}); + } else if (begin >= nRangeBeg && end <= nRangeEnd) { // case 3 + // drop + } else if (end <= nRangeEnd) { // case 4 + buf.push_back({begin, nRangeBeg - 1}); + } else if (begin >= nRangeBeg) { // case 5 + buf.push_back({nRangeEnd + 1, end}); + } else { // case 6 + buf.push_back({begin, nRangeBeg - 1}); + buf.push_back({nRangeEnd + 1, end}); + } + } + std::unique_ptr pNewWhichTable(new WhichPair[buf.size()]); + std::copy(buf.begin(), buf.end(), pNewWhichTable.get()); + return WhichRangesContainer(std::move(pNewWhichTable), buf.size()); +} + + +SvdProgressInfo::SvdProgressInfo( const Link&_rLink ) +{ + maLink = _rLink; + m_nSumCurAction = 0; + + m_nObjCount = 0; + m_nCurObj = 0; + + m_nActionCount = 0; + m_nCurAction = 0; + + m_nInsertCount = 0; + m_nCurInsert = 0; +} + +void SvdProgressInfo::Init( size_t nObjCount ) +{ + m_nObjCount = nObjCount; +} + +bool SvdProgressInfo::ReportActions( size_t nActionCount ) +{ + m_nSumCurAction += nActionCount; + m_nCurAction += nActionCount; + if(m_nCurAction > m_nActionCount) + m_nCurAction = m_nActionCount; + + return maLink.Call(nullptr); +} + +void SvdProgressInfo::ReportInserts( size_t nInsertCount ) +{ + m_nSumCurAction += nInsertCount; + m_nCurInsert += nInsertCount; + + maLink.Call(nullptr); +} + +void SvdProgressInfo::ReportRescales( size_t nRescaleCount ) +{ + m_nSumCurAction += nRescaleCount; + maLink.Call(nullptr); +} + +void SvdProgressInfo::SetActionCount( size_t nActionCount ) +{ + m_nActionCount = nActionCount; +} + +void SvdProgressInfo::SetInsertCount( size_t nInsertCount ) +{ + m_nInsertCount = nInsertCount; +} + +void SvdProgressInfo::SetNextObject() +{ + m_nActionCount = 0; + m_nCurAction = 0; + + m_nInsertCount = 0; + m_nCurInsert = 0; + + m_nCurObj++; + ReportActions(0); +} + +// #i101872# isolate GetTextEditBackgroundColor to tooling; it will anyways only be used as long +// as text edit is not running on overlay + +namespace +{ + std::optional impGetSdrObjListFillColor( + const SdrObjList& rList, + const Point& rPnt, + const SdrPageView& rTextEditPV, + const SdrLayerIDSet& rVisLayers) + { + bool bMaster(rList.getSdrPageFromSdrObjList() && rList.getSdrPageFromSdrObjList()->IsMasterPage()); + + for(size_t no(rList.GetObjCount()); no > 0; ) + { + no--; + SdrObject* pObj = rList.GetObj(no); + SdrObjList* pOL = pObj->GetSubList(); + + if(pOL) + { + // group object + if (auto oColor = impGetSdrObjListFillColor(*pOL, rPnt, rTextEditPV, rVisLayers)) + return oColor; + } + else + { + SdrTextObj* pText = DynCastSdrTextObj(pObj); + + // Exclude zero master page object (i.e. background shape) from color query + if(pText + && pObj->IsClosedObj() + && (!bMaster || (!pObj->IsNotVisibleAsMaster() && 0 != no)) + && pObj->GetCurrentBoundRect().Contains(rPnt) + && !pText->IsHideContour() + && SdrObjectPrimitiveHit(*pObj, rPnt, {0, 0}, rTextEditPV, &rVisLayers, false)) + { + if (auto oColor = GetDraftFillColor(pObj->GetMergedItemSet())) + return oColor; + } + } + } + + return {}; + } + + std::optional impGetSdrPageFillColor( + const SdrPage& rPage, + const Point& rPnt, + const SdrPageView& rTextEditPV, + const SdrLayerIDSet& rVisLayers, + bool bSkipBackgroundShape) + { + if (auto oColor = impGetSdrObjListFillColor(rPage, rPnt, rTextEditPV, rVisLayers)) + return oColor; + + if(!rPage.IsMasterPage()) + { + if(rPage.TRG_HasMasterPage()) + { + SdrLayerIDSet aSet(rVisLayers); + aSet &= rPage.TRG_GetMasterPageVisibleLayers(); + SdrPage& rMasterPage = rPage.TRG_GetMasterPage(); + + // Don't fall back to background shape on + // master pages. This is later handled by + // GetBackgroundColor, and is necessary to cater for + // the silly ordering: 1. shapes, 2. master page + // shapes, 3. page background, 4. master page + // background. + if (auto oColor = impGetSdrPageFillColor(rMasterPage, rPnt, rTextEditPV, aSet, true)) + return oColor; + } + } + + // Only now determine background color from background shapes + if(!bSkipBackgroundShape) + { + return rPage.GetPageBackgroundColor(); + } + + return {}; + } + + Color impCalcBackgroundColor( + const tools::Rectangle& rArea, + const SdrPageView& rTextEditPV, + const SdrPage& rPage) + { + svtools::ColorConfig aColorConfig; + Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor); + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + if(!rStyleSettings.GetHighContrastMode()) + { + // search in page + const sal_uInt16 SPOTCOUNT(5); + Point aSpotPos[SPOTCOUNT]; + Color aSpotColor[SPOTCOUNT]; + sal_uInt32 nHeight( rArea.GetSize().Height() ); + sal_uInt32 nWidth( rArea.GetSize().Width() ); + sal_uInt32 nWidth14 = nWidth / 4; + sal_uInt32 nHeight14 = nHeight / 4; + sal_uInt32 nWidth34 = ( 3 * nWidth ) / 4; + sal_uInt32 nHeight34 = ( 3 * nHeight ) / 4; + + sal_uInt16 i; + for ( i = 0; i < SPOTCOUNT; i++ ) + { + // five spots are used + switch ( i ) + { + case 0 : + { + // Center-Spot + aSpotPos[i] = rArea.Center(); + } + break; + + case 1 : + { + // TopLeft-Spot + aSpotPos[i] = rArea.TopLeft(); + aSpotPos[i].AdjustX(nWidth14 ); + aSpotPos[i].AdjustY(nHeight14 ); + } + break; + + case 2 : + { + // TopRight-Spot + aSpotPos[i] = rArea.TopLeft(); + aSpotPos[i].AdjustX(nWidth34 ); + aSpotPos[i].AdjustY(nHeight14 ); + } + break; + + case 3 : + { + // BottomLeft-Spot + aSpotPos[i] = rArea.TopLeft(); + aSpotPos[i].AdjustX(nWidth14 ); + aSpotPos[i].AdjustY(nHeight34 ); + } + break; + + case 4 : + { + // BottomRight-Spot + aSpotPos[i] = rArea.TopLeft(); + aSpotPos[i].AdjustX(nWidth34 ); + aSpotPos[i].AdjustY(nHeight34 ); + } + break; + + } + + aSpotColor[i] = + impGetSdrPageFillColor(rPage, aSpotPos[i], rTextEditPV, rTextEditPV.GetVisibleLayers(), false).value_or(COL_WHITE); + } + + sal_uInt16 aMatch[SPOTCOUNT]; + + for ( i = 0; i < SPOTCOUNT; i++ ) + { + // were same spot colors found? + aMatch[i] = 0; + + for ( sal_uInt16 j = 0; j < SPOTCOUNT; j++ ) + { + if( j != i ) + { + if( aSpotColor[i] == aSpotColor[j] ) + { + aMatch[i]++; + } + } + } + } + + // highest weight to center spot + aBackground = aSpotColor[0]; + + for ( sal_uInt16 nMatchCount = SPOTCOUNT - 1; nMatchCount > 1; nMatchCount-- ) + { + // which spot color was found most? + for ( i = 0; i < SPOTCOUNT; i++ ) + { + if( aMatch[i] == nMatchCount ) + { + aBackground = aSpotColor[i]; + nMatchCount = 1; // break outer for-loop + break; + } + } + } + } + + return aBackground; + } +} // end of anonymous namespace + +Color GetTextEditBackgroundColor(const SdrObjEditView& rView) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + if(!rStyleSettings.GetHighContrastMode()) + { + SdrTextObj* pText = rView.GetTextEditObject(); + + if(pText && pText->IsClosedObj()) + { + sdr::table::SdrTableObj* pTable = dynamic_cast< sdr::table::SdrTableObj * >( pText ); + + if( pTable ) + if (auto oColor = GetDraftFillColor(pTable->GetActiveCellItemSet())) + return *oColor; + + if (auto oColor = GetDraftFillColor(pText->GetMergedItemSet())) + return *oColor; + } + + if (pText) + { + SdrPageView* pTextEditPV = rView.GetTextEditPageView(); + + if(pTextEditPV) + { + Point aPvOfs(pText->GetTextEditOffset()); + const SdrPage* pPg = pTextEditPV->GetPage(); + + if(pPg) + { + tools::Rectangle aSnapRect( pText->GetSnapRect() ); + aSnapRect.Move(aPvOfs.X(), aPvOfs.Y()); + + return impCalcBackgroundColor(aSnapRect, *pTextEditPV, *pPg); + } + } + } + } + + return svtools::ColorConfig().GetColorValue(svtools::DOCCOLOR).nColor; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdfmtf.cxx b/svx/source/svdraw/svdfmtf.cxx new file mode 100644 index 0000000000..923c40a550 --- /dev/null +++ b/svx/source/svdraw/svdfmtf.cxx @@ -0,0 +1,1608 @@ +/* -*- 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 "svdfmtf.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +ImpSdrGDIMetaFileImport::ImpSdrGDIMetaFileImport( + SdrModel& rModel, + SdrLayerID nLay, + const tools::Rectangle& rRect) +: mpVD(VclPtr::Create()), + maScaleRect(rRect), + mnMapScalingOfs(0), + mpModel(&rModel), + mnLayer(nLay), + mnLineWidth(0), + maLineJoin(basegfx::B2DLineJoin::NONE), + maLineCap(css::drawing::LineCap_BUTT), + maDash(css::drawing::DashStyle_RECT, 0, 0, 0, 0, 0), + mbMov(false), + mbSize(false), + maOfs(0, 0), + mfScaleX(1.0), + mfScaleY(1.0), + maScaleX(1.0), + maScaleY(1.0), + mbFntDirty(true), + mbLastObjWasPolyWithoutLine(false), + mbNoLine(false), + mbNoFill(false), + mbLastObjWasLine(false) +{ + mpVD->EnableOutput(false); + mpVD->SetLineColor(); + mpVD->SetFillColor(); + maOldLineColor.SetRed( mpVD->GetLineColor().GetRed() + 1 ); + mpLineAttr = std::make_unique>(rModel.GetItemPool()); + mpFillAttr = std::make_unique>(rModel.GetItemPool()); + mpTextAttr = std::make_unique>(rModel.GetItemPool()); + checkClip(); +} + +void ImpSdrGDIMetaFileImport::DoLoopActions(GDIMetaFile const & rMtf, SvdProgressInfo* pProgrInfo, sal_uInt32* pActionsToReport) +{ + const sal_uLong nCount(rMtf.GetActionSize()); + + for(sal_uLong a(0); a < nCount; a++) + { + MetaAction* pAct = rMtf.GetAction(a); + + if(!pAct) + { + OSL_ENSURE(false, "OOps, no action at valid position (!)"); + pAct = rMtf.GetAction(0); + } + + switch (pAct->GetType()) + { + case MetaActionType::PIXEL : break; + case MetaActionType::POINT : break; + case MetaActionType::LINE : DoAction(static_cast(*pAct)); break; + case MetaActionType::RECT : DoAction(static_cast(*pAct)); break; + case MetaActionType::ROUNDRECT : DoAction(static_cast(*pAct)); break; + case MetaActionType::ELLIPSE : DoAction(static_cast(*pAct)); break; + case MetaActionType::ARC : DoAction(static_cast(*pAct)); break; + case MetaActionType::PIE : DoAction(static_cast(*pAct)); break; + case MetaActionType::CHORD : DoAction(static_cast(*pAct)); break; + case MetaActionType::POLYLINE : DoAction(static_cast(*pAct)); break; + case MetaActionType::POLYGON : DoAction(static_cast(*pAct)); break; + case MetaActionType::POLYPOLYGON : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXT : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTARRAY : DoAction(static_cast(*pAct)); break; + case MetaActionType::STRETCHTEXT : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMP : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMPSCALE : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMPEX : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMPEXSCALE : DoAction(static_cast(*pAct)); break; + case MetaActionType::LINECOLOR : DoAction(static_cast(*pAct)); break; + case MetaActionType::FILLCOLOR : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTCOLOR : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTFILLCOLOR : DoAction(static_cast(*pAct)); break; + case MetaActionType::FONT : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTALIGN : DoAction(static_cast(*pAct)); break; + case MetaActionType::MAPMODE : DoAction(static_cast(*pAct)); break; + case MetaActionType::CLIPREGION : DoAction(static_cast(*pAct)); break; + case MetaActionType::MOVECLIPREGION : DoAction(static_cast(*pAct)); break; + case MetaActionType::ISECTRECTCLIPREGION: DoAction(static_cast(*pAct)); break; + case MetaActionType::ISECTREGIONCLIPREGION: DoAction(static_cast(*pAct)); break; + case MetaActionType::RASTEROP : DoAction(static_cast(*pAct)); break; + case MetaActionType::PUSH : DoAction(static_cast(*pAct)); break; + case MetaActionType::POP : DoAction(static_cast(*pAct)); break; + case MetaActionType::HATCH : DoAction(static_cast(*pAct)); break; + + // #i125211# MetaCommentAction may change index, thus hand it over + case MetaActionType::COMMENT : DoAction(static_cast(*pAct), rMtf, a); + break; + + // missing actions added + case MetaActionType::TEXTRECT : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMPSCALEPART : DoAction(static_cast(*pAct)); break; + case MetaActionType::BMPEXSCALEPART : DoAction(static_cast(*pAct)); break; + case MetaActionType::MASK : DoAction(static_cast(*pAct)); break; + case MetaActionType::MASKSCALE : DoAction(static_cast(*pAct)); break; + case MetaActionType::MASKSCALEPART : DoAction(static_cast(*pAct)); break; + case MetaActionType::GRADIENT : DoAction(static_cast(*pAct)); break; + case MetaActionType::WALLPAPER : OSL_ENSURE(false, "Tried to construct SdrObject from MetaWallpaperAction: not supported (!)"); break; + case MetaActionType::Transparent : DoAction(static_cast(*pAct)); break; + case MetaActionType::EPS : OSL_ENSURE(false, "Tried to construct SdrObject from MetaEPSAction: not supported (!)"); break; + case MetaActionType::REFPOINT : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTLINECOLOR : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTLINE : OSL_ENSURE(false, "Tried to construct SdrObject from MetaTextLineAction: not supported (!)"); break; + case MetaActionType::FLOATTRANSPARENT : DoAction(static_cast(*pAct)); break; + case MetaActionType::GRADIENTEX : DoAction(static_cast(*pAct)); break; + case MetaActionType::LAYOUTMODE : DoAction(static_cast(*pAct)); break; + case MetaActionType::TEXTLANGUAGE : DoAction(static_cast(*pAct)); break; + case MetaActionType::OVERLINECOLOR : DoAction(static_cast(*pAct)); break; + default: break; + } + + if(pProgrInfo && pActionsToReport) + { + (*pActionsToReport)++; + + if(*pActionsToReport >= 16) // update all 16 actions + { + if(!pProgrInfo->ReportActions(*pActionsToReport)) + break; + + *pActionsToReport = 0; + } + } + } +} + +size_t ImpSdrGDIMetaFileImport::DoImport( + const GDIMetaFile& rMtf, + SdrObjList& rOL, + size_t nInsPos, + SvdProgressInfo* pProgrInfo) +{ + // setup some global scale parameter + // mfScaleX, mfScaleY, maScaleX, maScaleY, mbMov, mbSize + mfScaleX = mfScaleY = 1.0; + const Size aMtfSize(rMtf.GetPrefSize()); + + if(aMtfSize.Width() & aMtfSize.Height() && (!maScaleRect.IsEmpty())) + { + maOfs = maScaleRect.TopLeft(); + + if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1)) + { + mfScaleX = static_cast( maScaleRect.GetWidth() - 1 ) / static_cast(aMtfSize.Width()); + } + + if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1)) + { + mfScaleY = static_cast( maScaleRect.GetHeight() - 1 ) / static_cast(aMtfSize.Height()); + } + } + + mbMov = maOfs.X()!=0 || maOfs.Y()!=0; + mbSize = false; + maScaleX = Fraction( 1, 1 ); + maScaleY = Fraction( 1, 1 ); + + if(aMtfSize.Width() != (maScaleRect.GetWidth() - 1)) + { + maScaleX = Fraction(maScaleRect.GetWidth() - 1, aMtfSize.Width()); + mbSize = true; + } + + if(aMtfSize.Height() != (maScaleRect.GetHeight() - 1)) + { + maScaleY = Fraction(maScaleRect.GetHeight() - 1, aMtfSize.Height()); + mbSize = true; + } + + if(pProgrInfo) + { + pProgrInfo->SetActionCount(rMtf.GetActionSize()); + } + + sal_uInt32 nActionsToReport(0); + + // execute + DoLoopActions(rMtf, pProgrInfo, &nActionsToReport); + + if(pProgrInfo) + { + pProgrInfo->ReportActions(nActionsToReport); + nActionsToReport = 0; + } + + // MapMode scaling + MapScaling(); + + // To calculate the progress meter, we use GetActionSize()*3. + // However, maTmpList has a lower entry count limit than GetActionSize(), + // so the actions that were assumed were too much have to be re-added. + nActionsToReport = (rMtf.GetActionSize() - maTmpList.size()) * 2; + + // announce all currently unannounced rescales + if(pProgrInfo) + { + pProgrInfo->ReportRescales(nActionsToReport); + pProgrInfo->SetInsertCount(maTmpList.size()); + } + + nActionsToReport = 0; + + // insert all objects cached in aTmpList now into rOL from nInsPos + nInsPos = std::min(nInsPos, rOL.GetObjCount()); + + for(rtl::Reference& pObj : maTmpList) + { + rOL.NbcInsertObject(pObj.get(), nInsPos); + nInsPos++; + + if(pProgrInfo) + { + nActionsToReport++; + + if(nActionsToReport >= 32) // update all 32 actions + { + pProgrInfo->ReportInserts(nActionsToReport); + nActionsToReport = 0; + } + } + } + + // report all remaining inserts for the last time + if(pProgrInfo) + { + pProgrInfo->ReportInserts(nActionsToReport); + } + + return maTmpList.size(); +} + +void ImpSdrGDIMetaFileImport::SetAttributes(SdrObject* pObj, bool bForceTextAttr) +{ + mbNoLine = false; + mbNoFill = false; + bool bLine(!bForceTextAttr); + bool bFill(!pObj || (pObj->IsClosedObj() && !bForceTextAttr)); + bool bText(bForceTextAttr || (pObj && pObj->GetOutlinerParaObject())); + + if(bLine) + { + if(mnLineWidth) + { + mpLineAttr->Put(XLineWidthItem(mnLineWidth)); + } + else + { + mpLineAttr->Put(XLineWidthItem(0)); + } + + maOldLineColor = mpVD->GetLineColor(); + + if(mpVD->IsLineColor()) + { + mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_SOLID)); + mpLineAttr->Put(XLineColorItem(OUString(), mpVD->GetLineColor())); + } + else + { + mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_NONE)); + } + + switch(maLineJoin) + { + case basegfx::B2DLineJoin::NONE: + mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_NONE)); + break; + case basegfx::B2DLineJoin::Bevel: + mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_BEVEL)); + break; + case basegfx::B2DLineJoin::Miter: + mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_MITER)); + break; + case basegfx::B2DLineJoin::Round: + mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_ROUND)); + break; + } + + // Add LineCap support + mpLineAttr->Put(XLineCapItem(maLineCap)); + + if(((maDash.GetDots() && maDash.GetDotLen()) || (maDash.GetDashes() && maDash.GetDashLen())) && maDash.GetDistance()) + { + mpLineAttr->Put(XLineDashItem(OUString(), maDash)); + } + else + { + mpLineAttr->Put(XLineDashItem(OUString(), XDash(css::drawing::DashStyle_RECT))); + } + } + else + { + mbNoLine = true; + } + + if(bFill) + { + if(mpVD->IsFillColor()) + { + mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_SOLID)); + mpFillAttr->Put(XFillColorItem(OUString(), mpVD->GetFillColor())); + } + else + { + mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_NONE)); + } + } + else + { + mbNoFill = true; + } + + if(bText && mbFntDirty) + { + vcl::Font aFnt(mpVD->GetFont()); + const sal_uInt32 nHeight(FRound(aFnt.GetFontSize().Height() * mfScaleY)); + + mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO ) ); + mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CJK ) ); + mpTextAttr->Put( SvxFontItem( aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CTL ) ); + mpTextAttr->Put(SvxPostureItem(aFnt.GetItalic(), EE_CHAR_ITALIC)); + mpTextAttr->Put(SvxWeightItem(aFnt.GetWeight(), EE_CHAR_WEIGHT)); + mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) ); + mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) ); + mpTextAttr->Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) ); + mpTextAttr->Put(SvxCharScaleWidthItem(100, EE_CHAR_FONTWIDTH)); + mpTextAttr->Put(SvxUnderlineItem(aFnt.GetUnderline(), EE_CHAR_UNDERLINE)); + mpTextAttr->Put(SvxOverlineItem(aFnt.GetOverline(), EE_CHAR_OVERLINE)); + mpTextAttr->Put(SvxCrossedOutItem(aFnt.GetStrikeout(), EE_CHAR_STRIKEOUT)); + mpTextAttr->Put(SvxShadowedItem(aFnt.IsShadow(), EE_CHAR_SHADOW)); + + // #i118485# Setting this item leads to problems (written #i118498# for this) + // mpTextAttr->Put(SvxAutoKernItem(aFnt.IsKerning(), EE_CHAR_KERNING)); + + mpTextAttr->Put(SvxWordLineModeItem(aFnt.IsWordLineMode(), EE_CHAR_WLM)); + mpTextAttr->Put(SvxContourItem(aFnt.IsOutline(), EE_CHAR_OUTLINE)); + mpTextAttr->Put(SvxColorItem(mpVD->GetTextColor(), EE_CHAR_COLOR)); + //... svxfont textitem svditext + mbFntDirty = false; + } + + if(!pObj) + return; + + pObj->SetLayer(mnLayer); + + if(bLine) + { + pObj->SetMergedItemSet(*mpLineAttr); + } + + if(bFill) + { + pObj->SetMergedItemSet(*mpFillAttr); + } + + if(bText) + { + pObj->SetMergedItemSet(*mpTextAttr); + pObj->SetMergedItem(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); + } +} + +void ImpSdrGDIMetaFileImport::InsertObj(SdrObject* pObj1, bool bScale) +{ + rtl::Reference pObj = pObj1; + if(bScale && !maScaleRect.IsEmpty()) + { + if(mbSize) + { + pObj->NbcResize(Point(), maScaleX, maScaleY); + } + + if(mbMov) + { + pObj->NbcMove(Size(maOfs.X(), maOfs.Y())); + } + } + + if(isClip()) + { + const basegfx::B2DPolyPolygon aPoly(pObj->TakeXorPoly()); + const basegfx::B2DRange aOldRange(aPoly.getB2DRange()); + const SdrLayerID aOldLayer(pObj->GetLayer()); + const SfxItemSet aOldItemSet(pObj->GetMergedItemSet()); + const SdrGrafObj* pSdrGrafObj = dynamic_cast< SdrGrafObj* >(pObj.get()); + const SdrTextObj* pSdrTextObj = DynCastSdrTextObj(pObj.get()); + + if(pSdrTextObj && pSdrTextObj->HasText()) + { + // all text objects are created from ImportText and have no line or fill attributes, so + // it is okay to concentrate on the text itself + while(true) + { + const basegfx::B2DPolyPolygon aTextContour(pSdrTextObj->TakeContour()); + const basegfx::B2DRange aTextRange(aTextContour.getB2DRange()); + const basegfx::B2DRange aClipRange(maClip.getB2DRange()); + + // no overlap -> completely outside + if(!aClipRange.overlaps(aTextRange)) + { + pObj.clear(); + break; + } + + // when the clip is a rectangle fast check for inside is possible + if(basegfx::utils::isRectangle(maClip) && aClipRange.isInside(aTextRange)) + { + // completely inside ClipRect + break; + } + + // here text needs to be clipped; to do so, convert to SdrObjects with polygons + // and add these recursively. Delete original object, do not add in this run + rtl::Reference pConverted = pSdrTextObj->ConvertToPolyObj(true, true); + pObj.clear(); + + if(pConverted) + { + // recursively add created conversion; per definition this shall not + // contain further SdrTextObjs. Visit only non-group objects + SdrObjListIter aIter(*pConverted, SdrIterMode::DeepNoGroups); + + // work with clones; the created conversion may contain group objects + // and when working with the original objects the loop itself could + // break and the cleanup later would be pretty complicated (only delete group + // objects, are these empty, ...?) + while(aIter.IsMore()) + { + SdrObject* pCandidate = aIter.Next(); + OSL_ENSURE(pCandidate && dynamic_cast< SdrObjGroup* >(pCandidate) == nullptr, "SdrObjListIter with SdrIterMode::DeepNoGroups error (!)"); + rtl::Reference pNewClone(pCandidate->CloneSdrObject(pCandidate->getSdrModelFromSdrObject())); + + if(pNewClone) + { + InsertObj(pNewClone.get(), false); + } + else + { + OSL_ENSURE(false, "SdrObject::Clone() failed (!)"); + } + } + } + + break; + } + } + else + { + BitmapEx aBitmapEx; + + if(pSdrGrafObj) + { + aBitmapEx = pSdrGrafObj->GetGraphic().GetBitmapEx(); + } + + pObj.clear(); + + if(!aOldRange.isEmpty()) + { + // clip against ClipRegion + const basegfx::B2DPolyPolygon aNewPoly( + basegfx::utils::clipPolyPolygonOnPolyPolygon( + aPoly, + maClip, + true, + !aPoly.isClosed())); + const basegfx::B2DRange aNewRange(aNewPoly.getB2DRange()); + + if(!aNewRange.isEmpty()) + { + pObj = new SdrPathObj( + *mpModel, + aNewPoly.isClosed() ? SdrObjKind::Polygon : SdrObjKind::PolyLine, + aNewPoly); + + pObj->SetLayer(aOldLayer); + pObj->SetMergedItemSet(aOldItemSet); + + if(!aBitmapEx.IsEmpty()) + { + // aNewRange is inside of aOldRange and defines which part of aBitmapEx is used + const double fScaleX(aBitmapEx.GetSizePixel().Width() / (aOldRange.getWidth() ? aOldRange.getWidth() : 1.0)); + const double fScaleY(aBitmapEx.GetSizePixel().Height() / (aOldRange.getHeight() ? aOldRange.getHeight() : 1.0)); + basegfx::B2DRange aPixel(aNewRange); + basegfx::B2DHomMatrix aTrans; + + aTrans.translate(-aOldRange.getMinX(), -aOldRange.getMinY()); + aTrans.scale(fScaleX, fScaleY); + aPixel.transform(aTrans); + + const Size aOrigSizePixel(aBitmapEx.GetSizePixel()); + const Point aClipTopLeft( + basegfx::fround(floor(std::max(0.0, aPixel.getMinX()))), + basegfx::fround(floor(std::max(0.0, aPixel.getMinY())))); + const Size aClipSize( + basegfx::fround(ceil(std::min(static_cast(aOrigSizePixel.Width()), aPixel.getWidth()))), + basegfx::fround(ceil(std::min(static_cast(aOrigSizePixel.Height()), aPixel.getHeight())))); + const BitmapEx aClippedBitmap( + aBitmapEx, + aClipTopLeft, + aClipSize); + + pObj->SetMergedItem(XFillStyleItem(drawing::FillStyle_BITMAP)); + pObj->SetMergedItem(XFillBitmapItem(OUString(), Graphic(aClippedBitmap))); + pObj->SetMergedItem(XFillBmpTileItem(false)); + pObj->SetMergedItem(XFillBmpStretchItem(true)); + } + } + } + } + } + + if(!pObj) + return; + + // #i111954# check object for visibility + // used are SdrPathObj, SdrRectObj, SdrCircObj, SdrGrafObj + bool bVisible(false); + + if(pObj->HasLineStyle()) + { + bVisible = true; + } + + if(!bVisible && pObj->HasFillStyle()) + { + bVisible = true; + } + + if(!bVisible) + { + SdrTextObj* pTextObj = DynCastSdrTextObj(pObj.get()); + + if(pTextObj && pTextObj->HasText()) + { + bVisible = true; + } + } + + if(!bVisible) + { + SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >(pObj.get()); + + if(pGrafObj) + { + // this may be refined to check if the graphic really is visible. It + // is here to ensure that graphic objects without fill, line and text + // get created + bVisible = true; + } + } + + if(bVisible) + { + maTmpList.push_back(pObj); + + if(dynamic_cast< SdrPathObj* >(pObj.get())) + { + const bool bClosed(pObj->IsClosedObj()); + + mbLastObjWasPolyWithoutLine = mbNoLine && bClosed; + mbLastObjWasLine = !bClosed; + } + else + { + mbLastObjWasPolyWithoutLine = false; + mbLastObjWasLine = false; + } + } +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaLineAction const & rAct) +{ + // #i73407# reformulation to use new B2DPolygon classes + const basegfx::B2DPoint aStart(rAct.GetStartPoint().X(), rAct.GetStartPoint().Y()); + const basegfx::B2DPoint aEnd(rAct.GetEndPoint().X(), rAct.GetEndPoint().Y()); + + if(aStart.equal(aEnd)) + return; + + basegfx::B2DPolygon aLine; + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + + aLine.append(aStart); + aLine.append(aEnd); + aLine.transform(aTransform); + + const LineInfo& rLineInfo = rAct.GetLineInfo(); + const sal_Int32 nNewLineWidth(rLineInfo.GetWidth()); + bool bCreateLineObject(true); + + if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aLine)) + { + bCreateLineObject = false; + } + + if(!bCreateLineObject) + return; + + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Line, + basegfx::B2DPolyPolygon(aLine)); + mnLineWidth = nNewLineWidth; + maLineJoin = rLineInfo.GetLineJoin(); + maLineCap = rLineInfo.GetLineCap(); + maDash = XDash(css::drawing::DashStyle_RECT, + rLineInfo.GetDotCount(), rLineInfo.GetDotLen(), + rLineInfo.GetDashCount(), rLineInfo.GetDashLen(), + rLineInfo.GetDistance()); + SetAttributes(pPath.get()); + mnLineWidth = 0; + maLineJoin = basegfx::B2DLineJoin::NONE; + maDash = XDash(); + InsertObj(pPath.get(), false); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaRectAction const & rAct) +{ + rtl::Reference pRect = new SdrRectObj( + *mpModel, + rAct.GetRect()); + SetAttributes(pRect.get()); + InsertObj(pRect.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaRoundRectAction const & rAct) +{ + rtl::Reference pRect = new SdrRectObj( + *mpModel, + rAct.GetRect()); + SetAttributes(pRect.get()); + tools::Long nRad=(rAct.GetHorzRound()+rAct.GetVertRound())/2; + if (nRad!=0) { + SfxItemSetFixed aSet(*mpLineAttr->GetPool()); + aSet.Put(SdrMetricItem(SDRATTR_CORNER_RADIUS, nRad)); + pRect->SetMergedItemSet(aSet); + } + InsertObj(pRect.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaEllipseAction const & rAct) +{ + rtl::Reference pCirc=new SdrCircObj( + *mpModel, + SdrCircKind::Full, + rAct.GetRect()); + SetAttributes(pCirc.get()); + InsertObj(pCirc.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaArcAction const & rAct) +{ + Point aCenter(rAct.GetRect().Center()); + Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter); + Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter); + rtl::Reference pCirc = new SdrCircObj( + *mpModel, + SdrCircKind::Arc, + rAct.GetRect(),nStart,nEnd); + SetAttributes(pCirc.get()); + InsertObj(pCirc.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaPieAction const & rAct) +{ + Point aCenter(rAct.GetRect().Center()); + Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter); + Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter); + rtl::Reference pCirc = new SdrCircObj( + *mpModel, + SdrCircKind::Section, + rAct.GetRect(), + nStart, + nEnd); + SetAttributes(pCirc.get()); + InsertObj(pCirc.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaChordAction const & rAct) +{ + Point aCenter(rAct.GetRect().Center()); + Degree100 nStart=GetAngle(rAct.GetStartPoint()-aCenter); + Degree100 nEnd=GetAngle(rAct.GetEndPoint()-aCenter); + rtl::Reference pCirc = new SdrCircObj( + *mpModel, + SdrCircKind::Cut, + rAct.GetRect(), + nStart, + nEnd); + SetAttributes(pCirc.get()); + InsertObj(pCirc.get()); +} + +bool ImpSdrGDIMetaFileImport::CheckLastLineMerge(const basegfx::B2DPolygon& rSrcPoly) +{ + // #i102706# Do not merge closed polygons + if(rSrcPoly.isClosed()) + { + return false; + } + + // #i73407# reformulation to use new B2DPolygon classes + if(mbLastObjWasLine && (maOldLineColor == mpVD->GetLineColor()) && rSrcPoly.count()) + { + SdrObject* pTmpObj = !maTmpList.empty() ? maTmpList[maTmpList.size() - 1].get() : nullptr; + SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj); + + if(pLastPoly) + { + if(1 == pLastPoly->GetPathPoly().count()) + { + bool bOk(false); + basegfx::B2DPolygon aDstPoly(pLastPoly->GetPathPoly().getB2DPolygon(0)); + + // #i102706# Do not merge closed polygons + if(aDstPoly.isClosed()) + { + return false; + } + + if(aDstPoly.count()) + { + const sal_uInt32 nMaxDstPnt(aDstPoly.count() - 1); + const sal_uInt32 nMaxSrcPnt(rSrcPoly.count() - 1); + + if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(0)) + { + aDstPoly.append(rSrcPoly, 1, rSrcPoly.count() - 1); + bOk = true; + } + else if(aDstPoly.getB2DPoint(0) == rSrcPoly.getB2DPoint(nMaxSrcPnt)) + { + basegfx::B2DPolygon aNew(rSrcPoly); + aNew.append(aDstPoly, 1, aDstPoly.count() - 1); + aDstPoly = aNew; + bOk = true; + } + else if(aDstPoly.getB2DPoint(0) == rSrcPoly.getB2DPoint(0)) + { + aDstPoly.flip(); + aDstPoly.append(rSrcPoly, 1, rSrcPoly.count() - 1); + bOk = true; + } + else if(aDstPoly.getB2DPoint(nMaxDstPnt) == rSrcPoly.getB2DPoint(nMaxSrcPnt)) + { + basegfx::B2DPolygon aNew(rSrcPoly); + aNew.flip(); + aDstPoly.append(aNew, 1, aNew.count() - 1); + bOk = true; + } + } + + if(bOk) + { + pLastPoly->NbcSetPathPoly(basegfx::B2DPolyPolygon(aDstPoly)); + } + + return bOk; + } + } + } + + return false; +} + +bool ImpSdrGDIMetaFileImport::CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon & rPolyPolygon) +{ + // #i73407# reformulation to use new B2DPolygon classes + if(mbLastObjWasPolyWithoutLine) + { + SdrObject* pTmpObj = !maTmpList.empty() ? maTmpList[maTmpList.size() - 1].get() : nullptr; + SdrPathObj* pLastPoly = dynamic_cast< SdrPathObj* >(pTmpObj); + + if(pLastPoly) + { + if(pLastPoly->GetPathPoly() == rPolyPolygon) + { + SetAttributes(nullptr); + + if(!mbNoLine && mbNoFill) + { + pLastPoly->SetMergedItemSet(*mpLineAttr); + + return true; + } + } + } + } + + return false; +} + +void ImpSdrGDIMetaFileImport::checkClip() +{ + if(!mpVD->IsClipRegion()) + return; + + maClip = mpVD->GetClipRegion().GetAsB2DPolyPolygon(); + + if(isClip()) + { + const basegfx::B2DHomMatrix aTransform( + basegfx::utils::createScaleTranslateB2DHomMatrix( + mfScaleX, + mfScaleY, + maOfs.X(), + maOfs.Y())); + + maClip.transform(aTransform); + } +} + +bool ImpSdrGDIMetaFileImport::isClip() const +{ + return !maClip.getB2DRange().isEmpty(); +} + +void ImpSdrGDIMetaFileImport::DoAction( MetaPolyLineAction const & rAct ) +{ + // #i73407# reformulation to use new B2DPolygon classes + basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon()); + + if(aSource.count()) + { + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + } + + const LineInfo& rLineInfo = rAct.GetLineInfo(); + const sal_Int32 nNewLineWidth(rLineInfo.GetWidth()); + bool bCreateLineObject(true); + + if(mbLastObjWasLine && (nNewLineWidth == mnLineWidth) && CheckLastLineMerge(aSource)) + { + bCreateLineObject = false; + } + else if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource))) + { + bCreateLineObject = false; + } + + if(!bCreateLineObject) + return; + + rtl::Reference pPath = new SdrPathObj( + *mpModel, + aSource.isClosed() ? SdrObjKind::Polygon : SdrObjKind::PolyLine, + basegfx::B2DPolyPolygon(aSource)); + mnLineWidth = nNewLineWidth; + maLineJoin = rLineInfo.GetLineJoin(); + maLineCap = rLineInfo.GetLineCap(); + maDash = XDash(css::drawing::DashStyle_RECT, + rLineInfo.GetDotCount(), rLineInfo.GetDotLen(), + rLineInfo.GetDashCount(), rLineInfo.GetDashLen(), + rLineInfo.GetDistance()); + SetAttributes(pPath.get()); + mnLineWidth = 0; + maLineJoin = basegfx::B2DLineJoin::NONE; + maDash = XDash(); + InsertObj(pPath.get(), false); +} + +void ImpSdrGDIMetaFileImport::DoAction( MetaPolygonAction const & rAct ) +{ + // #i73407# reformulation to use new B2DPolygon classes + basegfx::B2DPolygon aSource(rAct.GetPolygon().getB2DPolygon()); + + if(!aSource.count()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + + if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(basegfx::B2DPolyPolygon(aSource))) + { + // #i73407# make sure polygon is closed, it's a filled primitive + aSource.setClosed(true); + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + basegfx::B2DPolyPolygon(aSource)); + SetAttributes(pPath.get()); + InsertObj(pPath.get(), false); + } +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaPolyPolygonAction const & rAct) +{ + // #i73407# reformulation to use new B2DPolygon classes + basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); + + if(!aSource.count()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + + if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) + { + // #i73407# make sure polygon is closed, it's a filled primitive + aSource.setClosed(true); + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + std::move(aSource)); + SetAttributes(pPath.get()); + InsertObj(pPath.get(), false); + } +} + +void ImpSdrGDIMetaFileImport::ImportText( const Point& rPos, const OUString& rStr, const MetaAction& rAct ) +{ + // calc text box size, add 5% to make it fit safely + + FontMetric aFontMetric( mpVD->GetFontMetric() ); + vcl::Font aFnt( mpVD->GetFont() ); + TextAlign eAlg( aFnt.GetAlignment() ); + + sal_Int32 nTextWidth = static_cast( mpVD->GetTextWidth( rStr ) * mfScaleX ); + sal_Int32 nTextHeight = static_cast( mpVD->GetTextHeight() * mfScaleY ); + + Point aPos( FRound(rPos.X() * mfScaleX + maOfs.X()), FRound(rPos.Y() * mfScaleY + maOfs.Y()) ); + Size aSize( nTextWidth, nTextHeight ); + + if ( eAlg == ALIGN_BASELINE ) + aPos.AdjustY( -(FRound(aFontMetric.GetAscent() * mfScaleY)) ); + else if ( eAlg == ALIGN_BOTTOM ) + aPos.AdjustY( -nTextHeight ); + + tools::Rectangle aTextRect( aPos, aSize ); + rtl::Reference pText = new SdrRectObj( + *mpModel, + SdrObjKind::Text, + aTextRect); + + pText->SetMergedItem ( makeSdrTextUpperDistItem (0)); + pText->SetMergedItem ( makeSdrTextLowerDistItem (0)); + pText->SetMergedItem ( makeSdrTextRightDistItem (0)); + pText->SetMergedItem ( makeSdrTextLeftDistItem (0)); + + if ( aFnt.GetAverageFontWidth() || ( rAct.GetType() == MetaActionType::STRETCHTEXT ) ) + { + pText->ClearMergedItem( SDRATTR_TEXT_AUTOGROWWIDTH ); + pText->SetMergedItem( makeSdrTextAutoGrowHeightItem( false ) ); + // don't let the margins eat the space needed for the text + pText->SetMergedItem( SdrTextFitToSizeTypeItem(drawing::TextFitToSizeType_ALLLINES) ); + } + else + { + pText->SetMergedItem( makeSdrTextAutoGrowWidthItem( true ) ); + } + + pText->SetLayer(mnLayer); + pText->NbcSetText( rStr ); + SetAttributes( pText.get(), true ); + pText->SetSnapRect( aTextRect ); + + if (!aFnt.IsTransparent()) + { + SfxItemSetFixed aAttr(*mpFillAttr->GetPool()); + aAttr.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + aAttr.Put(XFillColorItem(OUString(), aFnt.GetFillColor())); + pText->SetMergedItemSet(aAttr); + } + Degree100 nAngle = to(aFnt.GetOrientation()); + if ( nAngle ) + pText->SdrAttrObj::NbcRotate(aPos,nAngle); + InsertObj( pText.get(), false ); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaTextAction const & rAct) +{ + OUString aStr(rAct.GetText()); + aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen()); + ImportText( rAct.GetPoint(), aStr, rAct ); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaTextArrayAction const & rAct) +{ + OUString aStr(rAct.GetText()); + aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen()); + ImportText( rAct.GetPoint(), aStr, rAct ); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaStretchTextAction const & rAct) +{ + OUString aStr(rAct.GetText()); + aStr = aStr.copy(rAct.GetIndex(), rAct.GetLen()); + ImportText( rAct.GetPoint(), aStr, rAct ); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmap().GetSizePixel()); + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + Graphic(BitmapEx(rAct.GetBitmap())), + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScaleAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + Graphic(BitmapEx(rAct.GetBitmap())), + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(),rAct.GetBitmapEx().GetSizePixel()); + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + rAct.GetBitmapEx(), + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScaleAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + rAct.GetBitmapEx(), + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + + +void ImpSdrGDIMetaFileImport::DoAction( MetaHatchAction const & rAct ) +{ + // #i73407# reformulation to use new B2DPolygon classes + basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); + + if(!aSource.count()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + + if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource)) + return; + + const Hatch& rHatch = rAct.GetHatch(); + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + std::move(aSource)); + // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet + SfxItemSet aHatchAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges()); + css::drawing::HatchStyle eStyle; + + switch(rHatch.GetStyle()) + { + case HatchStyle::Triple : + { + eStyle = css::drawing::HatchStyle_TRIPLE; + break; + } + + case HatchStyle::Double : + { + eStyle = css::drawing::HatchStyle_DOUBLE; + break; + } + + default: + { + eStyle = css::drawing::HatchStyle_SINGLE; + break; + } + } + + SetAttributes(pPath.get()); + aHatchAttr.Put(XFillStyleItem(drawing::FillStyle_HATCH)); + aHatchAttr.Put(XFillHatchItem(XHatch(rHatch.GetColor(), eStyle, rHatch.GetDistance(), rHatch.GetAngle()))); + pPath->SetMergedItemSet(aHatchAttr); + + InsertObj(pPath.get(), false); +} + + +void ImpSdrGDIMetaFileImport::DoAction(MetaLineColorAction& rAct) +{ + rAct.Execute(mpVD); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaMapModeAction& rAct) +{ + MapScaling(); + rAct.Execute(mpVD); + mbLastObjWasPolyWithoutLine = false; + mbLastObjWasLine = false; +} + +void ImpSdrGDIMetaFileImport::MapScaling() +{ + const size_t nCount(maTmpList.size()); + const MapMode& rMap = mpVD->GetMapMode(); + Point aMapOrg( rMap.GetOrigin() ); + bool bMov2(aMapOrg.X() != 0 || aMapOrg.Y() != 0); + + if(bMov2) + { + for(size_t i = mnMapScalingOfs; i < nCount; i++) + { + SdrObject* pObj = maTmpList[i].get(); + + pObj->NbcMove(Size(aMapOrg.X(), aMapOrg.Y())); + } + } + + mnMapScalingOfs = nCount; +} + + +void ImpSdrGDIMetaFileImport::DoAction( MetaCommentAction const & rAct, GDIMetaFile const & rMtf, sal_uLong& a) // GDIMetaFile* pMtf ) +{ + bool aSkipComment = false; + + if (a < rMtf.GetActionSize() && rAct.GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_BEGIN")) + { + // #i125211# Check if next action is a MetaGradientExAction + MetaGradientExAction* pAct = dynamic_cast< MetaGradientExAction* >(rMtf.GetAction(a + 1)); + + if( pAct && pAct->GetType() == MetaActionType::GRADIENTEX ) + { + // #i73407# reformulation to use new B2DPolygon classes + basegfx::B2DPolyPolygon aSource(pAct->GetPolyPolygon().getB2DPolyPolygon()); + + if(aSource.count()) + { + if(!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aSource)) + { + const Gradient& rGrad = pAct->GetGradient(); + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + std::move(aSource)); + // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet + SfxItemSet aGradAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges()); + basegfx::BGradient aBGradient( + basegfx::BColorStops( + rGrad.GetStartColor().getBColor(), + rGrad.GetEndColor().getBColor())); + + aBGradient.SetGradientStyle(rGrad.GetStyle()); + aBGradient.SetAngle(rGrad.GetAngle()); + aBGradient.SetBorder(rGrad.GetBorder()); + aBGradient.SetXOffset(rGrad.GetOfsX()); + aBGradient.SetYOffset(rGrad.GetOfsY()); + aBGradient.SetStartIntens(rGrad.GetStartIntensity()); + aBGradient.SetEndIntens(rGrad.GetEndIntensity()); + aBGradient.SetSteps(rGrad.GetSteps()); + + // no need to use SetAttributes(..) here since line and fill style + // need to be set individually + // SetAttributes(pPath); + + // switch line off; if there was one there will be a + // MetaActionType::POLYLINE following creating another object + aGradAttr.Put(XLineStyleItem(drawing::LineStyle_NONE)); + + // add detected gradient fillstyle + aGradAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); + aGradAttr.Put(XFillGradientItem(aBGradient)); + + pPath->SetMergedItemSet(aGradAttr); + + InsertObj(pPath.get()); + } + } + + aSkipComment = true; + } + } + + if(aSkipComment) + { + // #i125211# forward until closing MetaCommentAction + MetaAction* pSkipAct = rMtf.GetAction(++a); + + while( pSkipAct + && ((pSkipAct->GetType() != MetaActionType::COMMENT ) + || !(static_cast(pSkipAct)->GetComment().equalsIgnoreAsciiCase("XGRAD_SEQ_END")))) + { + pSkipAct = rMtf.GetAction(++a); + } + } +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaTextRectAction const & rAct) +{ + GDIMetaFile aTemp; + + mpVD->AddTextRectActions(rAct.GetRect(), rAct.GetText(), rAct.GetStyle(), aTemp); + DoLoopActions(aTemp, nullptr, nullptr); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpScalePartAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize()); + BitmapEx aBitmapEx(rAct.GetBitmap()); + + aRect.AdjustRight( 1 ); + aRect.AdjustBottom( 1 ); + aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaBmpExScalePartAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetDestPoint(),rAct.GetDestSize()); + BitmapEx aBitmapEx(rAct.GetBitmapEx()); + + aRect.AdjustRight( 1 ); + aRect.AdjustBottom( 1 ); + aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaMaskAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(), rAct.GetBitmap().GetSizePixel()); + BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); + + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScaleAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetPoint(), rAct.GetSize()); + BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); + + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaMaskScalePartAction const & rAct) +{ + tools::Rectangle aRect(rAct.GetDestPoint(), rAct.GetDestSize()); + BitmapEx aBitmapEx(rAct.GetBitmap(), rAct.GetColor()); + + aRect.AdjustRight( 1 ); aRect.AdjustBottom( 1 ); + aBitmapEx.Crop(tools::Rectangle(rAct.GetSrcPoint(), rAct.GetSrcSize())); + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaGradientAction const & rAct) +{ + basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rAct.GetRect()); + + if(aRange.isEmpty()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aRange.transform(aTransform); + const Gradient& rGradient = rAct.GetGradient(); + rtl::Reference pRect = new SdrRectObj( + *mpModel, + tools::Rectangle( + floor(aRange.getMinX()), + floor(aRange.getMinY()), + ceil(aRange.getMaxX()), + ceil(aRange.getMaxY()))); + // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet + SfxItemSet aGradientAttr(mpModel->GetItemPool(), pRect->GetMergedItemSet().GetRanges()); + const XFillGradientItem aXFillGradientItem( + basegfx::BGradient( + basegfx::BColorStops( + rGradient.GetStartColor().getBColor(), + rGradient.GetEndColor().getBColor()), + rGradient.GetStyle(), + rGradient.GetAngle(), + rGradient.GetOfsX(), + rGradient.GetOfsY(), + rGradient.GetBorder(), + rGradient.GetStartIntensity(), + rGradient.GetEndIntensity(), + rGradient.GetSteps())); + + SetAttributes(pRect.get()); + aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211# + aGradientAttr.Put(aXFillGradientItem); + pRect->SetMergedItemSet(aGradientAttr); + + InsertObj(pRect.get(), false); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaTransparentAction const & rAct) +{ + basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); + + if(!aSource.count()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + aSource.setClosed(true); + + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + std::move(aSource)); + SetAttributes(pPath.get()); + pPath->SetMergedItem(XFillTransparenceItem(rAct.GetTransparence())); + InsertObj(pPath.get(), false); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaGradientExAction const & rAct) +{ + basegfx::B2DPolyPolygon aSource(rAct.GetPolyPolygon().getB2DPolyPolygon()); + + if(!aSource.count()) + return; + + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aSource.transform(aTransform); + + if(mbLastObjWasPolyWithoutLine && CheckLastPolyLineAndFillMerge(aSource)) + return; + + const Gradient& rGradient = rAct.GetGradient(); + rtl::Reference pPath = new SdrPathObj( + *mpModel, + SdrObjKind::Polygon, + std::move(aSource)); + // #i125211# Use the ranges from the SdrObject to create a new empty SfxItemSet + SfxItemSet aGradientAttr(mpModel->GetItemPool(), pPath->GetMergedItemSet().GetRanges()); + const XFillGradientItem aXFillGradientItem( + basegfx::BGradient( + basegfx::BColorStops( + rGradient.GetStartColor().getBColor(), + rGradient.GetEndColor().getBColor()), + rGradient.GetStyle(), + rGradient.GetAngle(), + rGradient.GetOfsX(), + rGradient.GetOfsY(), + rGradient.GetBorder(), + rGradient.GetStartIntensity(), + rGradient.GetEndIntensity(), + rGradient.GetSteps())); + + SetAttributes(pPath.get()); + aGradientAttr.Put(XFillStyleItem(drawing::FillStyle_GRADIENT)); // #i125211# + aGradientAttr.Put(aXFillGradientItem); + pPath->SetMergedItemSet(aGradientAttr); + + InsertObj(pPath.get(), false); +} + +void ImpSdrGDIMetaFileImport::DoAction(MetaFloatTransparentAction const & rAct) +{ + const GDIMetaFile& rMtf = rAct.GetGDIMetaFile(); + + if(!rMtf.GetActionSize()) + return; + + const tools::Rectangle aRect(rAct.GetPoint(),rAct.GetSize()); + + // convert metafile sub-content to BitmapEx + BitmapEx aBitmapEx( + convertMetafileToBitmapEx( + rMtf, + vcl::unotools::b2DRectangleFromRectangle(aRect), + 125000)); + + // handle colors + const Gradient& rGradient = rAct.GetGradient(); + basegfx::BColor aStart(rGradient.GetStartColor().getBColor()); + basegfx::BColor aEnd(rGradient.GetEndColor().getBColor()); + + if(100 != rGradient.GetStartIntensity()) + { + aStart *= static_cast(rGradient.GetStartIntensity()) / 100.0; + } + + if(100 != rGradient.GetEndIntensity()) + { + aEnd *= static_cast(rGradient.GetEndIntensity()) / 100.0; + } + + const bool bEqualColors(aStart == aEnd); + const bool bNoSteps(1 == rGradient.GetSteps()); + bool bCreateObject(true); + bool bHasNewMask(false); + AlphaMask aNewMask; + double fTransparence(0.0); + bool bFixedTransparence(false); + + if(bEqualColors || bNoSteps) + { + // single transparence + const basegfx::BColor aMedium(basegfx::average(aStart, aEnd)); + fTransparence = aMedium.luminance(); + + if(basegfx::fTools::lessOrEqual(fTransparence, 0.0)) + { + // no transparence needed, all done + } + else if(basegfx::fTools::moreOrEqual(fTransparence, 1.0)) + { + // all transparent, no object + bCreateObject = false; + } + else + { + // 0.0 < transparence < 1.0, apply fixed transparence + bFixedTransparence = true; + } + } + else + { + // gradient transparence + ScopedVclPtrInstance< VirtualDevice > pVDev; + + pVDev->SetOutputSizePixel(aBitmapEx.GetBitmap().GetSizePixel()); + pVDev->DrawGradient(tools::Rectangle(Point(0, 0), pVDev->GetOutputSizePixel()), rGradient); + + aNewMask = AlphaMask(pVDev->GetBitmap(Point(0, 0), pVDev->GetOutputSizePixel())); + aNewMask.Invert(); // convert transparency to alpha + bHasNewMask = true; + } + + if(!bCreateObject) + return; + + if(bHasNewMask || bFixedTransparence) + { + if(!aBitmapEx.IsAlpha()) + { + // no transparence yet, apply new one + if(bFixedTransparence) + { + sal_uInt8 nTransparence(basegfx::fround(fTransparence * 255.0)); + + aNewMask = AlphaMask(aBitmapEx.GetBitmap().GetSizePixel(), &nTransparence); + } + + aBitmapEx = BitmapEx(aBitmapEx.GetBitmap(), aNewMask); + } + else + { + vcl::bitmap::DrawAlphaBitmapAndAlphaGradient(aBitmapEx, bFixedTransparence, fTransparence, aNewMask); + } + } + + // create and add object + rtl::Reference pGraf = new SdrGrafObj( + *mpModel, + aBitmapEx, + aRect); + + // for MetaFloatTransparentAction, do not use SetAttributes(...) + // since these metafile content is not used to draw line/fill + // dependent of these setting at the device content + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdfmtf.hxx b/svx/source/svdraw/svdfmtf.hxx new file mode 100644 index 0000000000..31c3255827 --- /dev/null +++ b/svx/source/svdraw/svdfmtf.hxx @@ -0,0 +1,173 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_SVDRAW_SVDFMTF_HXX +#define INCLUDED_SVX_SOURCE_SVDRAW_SVDFMTF_HXX + +#include + +#include + +#include +#include +#include +#include +#include +#include + +// Forward Declarations + + +class SfxItemSet; +class SdrObjList; +class SdrModel; +class SdrPage; +class SdrObject; +class SvdProgressInfo; + + +// Helper Class ImpSdrGDIMetaFileImport +class ImpSdrGDIMetaFileImport final +{ + ::std::vector< rtl::Reference > maTmpList; + ScopedVclPtr mpVD; + tools::Rectangle maScaleRect; + size_t mnMapScalingOfs; // from here on, not edited with MapScaling + std::unique_ptr mpLineAttr; + std::unique_ptr mpFillAttr; + std::unique_ptr mpTextAttr; + SdrModel* mpModel; + SdrLayerID mnLayer; + Color maOldLineColor; + sal_Int32 mnLineWidth; + basegfx::B2DLineJoin maLineJoin; + css::drawing::LineCap maLineCap; + XDash maDash; + + bool mbMov; + bool mbSize; + Point maOfs; + double mfScaleX; + double mfScaleY; + Fraction maScaleX; + Fraction maScaleY; + + bool mbFntDirty; + + // to optimize (PenNULL,Brush,DrawPoly),(Pen,BrushNULL,DrawPoly) -> two-in-one + bool mbLastObjWasPolyWithoutLine; + bool mbNoLine; + bool mbNoFill; + + // to optimize multiple lines into a Polyline + bool mbLastObjWasLine; + + // clipregion + basegfx::B2DPolyPolygon maClip; + + // check for clip and evtl. fill maClip + void checkClip(); + bool isClip() const; + + // actions + void DoAction(MetaLineAction const & rAct); + void DoAction(MetaRectAction const & rAct); + void DoAction(MetaRoundRectAction const & rAct); + void DoAction(MetaEllipseAction const & rAct); + void DoAction(MetaArcAction const & rAct); + void DoAction(MetaPieAction const & rAct); + void DoAction(MetaChordAction const & rAct); + void DoAction(MetaPolyLineAction const & rAct); + void DoAction(MetaPolygonAction const & rAct); + void DoAction(MetaPolyPolygonAction const & rAct); + void DoAction(MetaTextAction const & rAct); + void DoAction(MetaTextArrayAction const & rAct); + void DoAction(MetaStretchTextAction const & rAct); + void DoAction(MetaBmpAction const & rAct); + void DoAction(MetaBmpScaleAction const & rAct); + void DoAction(MetaBmpExAction const & rAct); + void DoAction(MetaBmpExScaleAction const & rAct); + void DoAction(MetaHatchAction const & rAct); + void DoAction(MetaLineColorAction & rAct); + void DoAction(MetaMapModeAction & rAct); + void DoAction(MetaFillColorAction & rAct) { rAct.Execute(mpVD); } + void DoAction(MetaTextColorAction & rAct) { rAct.Execute(mpVD); } + void DoAction(MetaTextFillColorAction & rAct) { rAct.Execute(mpVD); } + void DoAction(MetaFontAction & rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + void DoAction(MetaTextAlignAction & rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + void DoAction(MetaClipRegionAction & rAct) { rAct.Execute(mpVD); checkClip(); } + void DoAction(MetaRasterOpAction & rAct) { rAct.Execute(mpVD); } + void DoAction(MetaPushAction & rAct) { rAct.Execute(mpVD); checkClip(); } + void DoAction(MetaPopAction & rAct) { rAct.Execute(mpVD); mbFntDirty = true; checkClip(); } + void DoAction(MetaMoveClipRegionAction & rAct) { rAct.Execute(mpVD); checkClip(); } + void DoAction(MetaISectRectClipRegionAction& rAct) { rAct.Execute(mpVD); checkClip(); } + void DoAction(MetaISectRegionClipRegionAction& rAct) { rAct.Execute(mpVD); checkClip(); } + + // #i125211# The MetaCommentAction needs to advance (if used), thus + // give current metafile and index which may be changed + void DoAction(MetaCommentAction const & rAct, GDIMetaFile const & rMtf, sal_uLong& a); + + // missing actions added + void DoAction(MetaTextRectAction const & rAct); + void DoAction(MetaBmpScalePartAction const & rAct); + void DoAction(MetaBmpExScalePartAction const & rAct); + void DoAction(MetaMaskAction const & rAct); + void DoAction(MetaMaskScaleAction const & rAct); + void DoAction(MetaMaskScalePartAction const & rAct); + void DoAction(MetaGradientAction const & rAct); + void DoAction(MetaTransparentAction const & rAct); + void DoAction(MetaRefPointAction& rAct) { rAct.Execute(mpVD); } + void DoAction(MetaTextLineColorAction& rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + void DoAction(MetaFloatTransparentAction const & rAct); + void DoAction(MetaGradientExAction const & rAct); + void DoAction(MetaLayoutModeAction& rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + void DoAction(MetaTextLanguageAction& rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + void DoAction(MetaOverlineColorAction& rAct) { rAct.Execute(mpVD); mbFntDirty = true; } + + void ImportText(const Point& rPos, const OUString& rStr, const MetaAction& rAct); + void SetAttributes(SdrObject* pObj, bool bForceTextAttr = false); + void InsertObj(SdrObject* pObj, bool bScale = true); + void MapScaling(); + + // #i73407# reformulation to use new B2DPolygon classes + bool CheckLastLineMerge(const basegfx::B2DPolygon& rSrcPoly); + bool CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon& rPolyPolygon); + + void DoLoopActions(GDIMetaFile const & rMtf, SvdProgressInfo* pProgrInfo, sal_uInt32* pActionsToReport); + + // Copy assignment is forbidden and not implemented. + ImpSdrGDIMetaFileImport (const ImpSdrGDIMetaFileImport &) = delete; + ImpSdrGDIMetaFileImport & operator= (const ImpSdrGDIMetaFileImport &) = delete; + +public: + ImpSdrGDIMetaFileImport( + SdrModel& rModel, + SdrLayerID nLay, + const tools::Rectangle& rRect); + + size_t DoImport( + const GDIMetaFile& rMtf, + SdrObjList& rDestList, + size_t nInsPos, + SvdProgressInfo* pProgrInfo = nullptr); +}; + +#endif // INCLUDED_SVX_SOURCE_SVDRAW_SVDFMTF_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdglev.cxx b/svx/source/svdraw/svdglev.cxx new file mode 100644 index 0000000000..5a67e3685f --- /dev/null +++ b/svx/source/svdraw/svdglev.cxx @@ -0,0 +1,402 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include + +SdrGlueEditView::SdrGlueEditView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: SdrPolyEditView(rSdrModel, pOut) +{ +} + +SdrGlueEditView::~SdrGlueEditView() +{ +} + +void SdrGlueEditView::ImpDoMarkedGluePoints(PGlueDoFunc pDoFunc, bool bConst, const void* p1, const void* p2, const void* p3, const void* p4) +{ + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + const SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + if (!rPts.empty()) + { + SdrGluePointList* pGPL=nullptr; + if (bConst) { + const SdrGluePointList* pConstGPL=pObj->GetGluePointList(); + pGPL=const_cast(pConstGPL); + } else { + pGPL=pObj->ForceGluePointList(); + } + if (pGPL!=nullptr) + { + if(!bConst && IsUndoEnabled() ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + for(sal_uInt16 nPtId : rPts) + { + sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId); + if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND) + { + SdrGluePoint& rGP=(*pGPL)[nGlueIdx]; + (*pDoFunc)(rGP,pObj,p1,p2,p3,p4); + } + } + if (!bConst) + { + pObj->SetChanged(); + pObj->BroadcastObjectChange(); + } + } + } + } + if (!bConst && nMarkCount!=0) + GetModel().SetChanged(); +} + + +static void ImpGetEscDir(SdrGluePoint & rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnThisEsc, const void* pnRet, const void*) +{ + TriState& nRet=*const_cast(static_cast(pnRet)); + if (nRet!=TRISTATE_INDET) { + SdrEscapeDirection nEsc = rGP.GetEscDir(); + bool bOn = bool(nEsc & *static_cast(pnThisEsc)); + bool& bFirst=*const_cast(static_cast(pbFirst)); + if (bFirst) { + nRet = bOn ? TRISTATE_TRUE : TRISTATE_FALSE; + bFirst = false; + } + else if (nRet != (bOn ? TRISTATE_TRUE : TRISTATE_FALSE)) nRet=TRISTATE_INDET; + } +} + +TriState SdrGlueEditView::IsMarkedGluePointsEscDir(SdrEscapeDirection nThisEsc) const +{ + ForceUndirtyMrkPnt(); + bool bFirst=true; + TriState nRet=TRISTATE_FALSE; + const_cast(this)->ImpDoMarkedGluePoints(ImpGetEscDir,true,&bFirst,&nThisEsc,&nRet); + return nRet; +} + +static void ImpSetEscDir(SdrGluePoint& rGP, const SdrObject* /*pObj*/, const void* pnThisEsc, const void* pbOn, const void*, const void*) +{ + SdrEscapeDirection nEsc=rGP.GetEscDir(); + if (*static_cast(pbOn)) + nEsc |= *static_cast(pnThisEsc); + else + nEsc &= ~*static_cast(pnThisEsc); + rGP.SetEscDir(nEsc); +} + +void SdrGlueEditView::SetMarkedGluePointsEscDir(SdrEscapeDirection nThisEsc, bool bOn) +{ + ForceUndirtyMrkPnt(); + BegUndo(SvxResId(STR_EditSetGlueEscDir),GetDescriptionOfMarkedGluePoints()); + ImpDoMarkedGluePoints(ImpSetEscDir,false,&nThisEsc,&bOn); + EndUndo(); +} + + +static void ImpGetPercent(SdrGluePoint & rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pnRet, const void*, const void*) +{ + TriState& nRet=*const_cast(static_cast(pnRet)); + if (nRet!=TRISTATE_INDET) { + bool bOn=rGP.IsPercent(); + bool& bFirst=*const_cast(static_cast(pbFirst)); + if (bFirst) { + nRet = bOn ? TRISTATE_TRUE : TRISTATE_FALSE; + bFirst = false; + } + else if ((nRet!=TRISTATE_FALSE)!=bOn) + nRet=TRISTATE_INDET; + } +} + +TriState SdrGlueEditView::IsMarkedGluePointsPercent() const +{ + ForceUndirtyMrkPnt(); + bool bFirst=true; + TriState nRet = TRISTATE_TRUE; + const_cast(this)->ImpDoMarkedGluePoints(ImpGetPercent,true,&bFirst,&nRet); + return nRet; +} + +static void ImpSetPercent(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbOn, const void*, const void*, const void*) +{ + Point aPos(rGP.GetAbsolutePos(*pObj)); + rGP.SetPercent(*static_cast(pbOn)); + rGP.SetAbsolutePos(aPos,*pObj); +} + +void SdrGlueEditView::SetMarkedGluePointsPercent(bool bOn) +{ + ForceUndirtyMrkPnt(); + BegUndo(SvxResId(STR_EditSetGluePercent),GetDescriptionOfMarkedGluePoints()); + ImpDoMarkedGluePoints(ImpSetPercent,false,&bOn); + EndUndo(); +} + + +static void ImpGetAlign(SdrGluePoint & rGP, const SdrObject* /*pObj*/, const void* pbFirst, const void* pbDontCare, const void* pbVert, const void* pnRet) +{ + SdrAlign& nRet=*const_cast(static_cast(pnRet)); + bool& bDontCare=*const_cast(static_cast(pbDontCare)); + bool bVert=*static_cast(pbVert); + if (bDontCare) + return; + + SdrAlign nAlg=SdrAlign::NONE; + if (bVert) { + nAlg=rGP.GetVertAlign(); + } else { + nAlg=rGP.GetHorzAlign(); + } + bool& bFirst=*const_cast(static_cast(pbFirst)); + if (bFirst) { nRet=nAlg; bFirst=false; } + else if (nRet!=nAlg) { + if (bVert) { + nRet=SdrAlign::VERT_DONTCARE; + } else { + nRet=SdrAlign::HORZ_DONTCARE; + } + bDontCare=true; + } +} + +SdrAlign SdrGlueEditView::GetMarkedGluePointsAlign(bool bVert) const +{ + ForceUndirtyMrkPnt(); + bool bFirst=true; + bool bDontCare=false; + SdrAlign nRet=SdrAlign::NONE; + const_cast(this)->ImpDoMarkedGluePoints(ImpGetAlign,true,&bFirst,&bDontCare,&bVert,&nRet); + return nRet; +} + +static void ImpSetAlign(SdrGluePoint& rGP, const SdrObject* pObj, const void* pbVert, const void* pnAlign, const void*, const void*) +{ + Point aPos(rGP.GetAbsolutePos(*pObj)); + if (*static_cast(pbVert)) { // bVert? + rGP.SetVertAlign(*static_cast(pnAlign)); + } else { + rGP.SetHorzAlign(*static_cast(pnAlign)); + } + rGP.SetAbsolutePos(aPos,*pObj); +} + +void SdrGlueEditView::SetMarkedGluePointsAlign(bool bVert, SdrAlign nAlign) +{ + ForceUndirtyMrkPnt(); + BegUndo(SvxResId(STR_EditSetGlueAlign),GetDescriptionOfMarkedGluePoints()); + ImpDoMarkedGluePoints(ImpSetAlign,false,&bVert,&nAlign); + EndUndo(); +} + +void SdrGlueEditView::DeleteMarkedGluePoints() +{ + BrkAction(); + ForceUndirtyMrkPnt(); + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditDelete),GetDescriptionOfMarkedGluePoints(),SdrRepeatFunc::Delete); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + const SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + if (!rPts.empty()) + { + SdrGluePointList* pGPL=pObj->ForceGluePointList(); + if (pGPL!=nullptr) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + for(sal_uInt16 nPtId : rPts) + { + sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId); + if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND) + { + pGPL->Delete(nGlueIdx); + } + } + pObj->SetChanged(); + pObj->BroadcastObjectChange(); + } + } + } + if( bUndo ) + EndUndo(); + UnmarkAllGluePoints(); + if (nMarkCount!=0) + GetModel().SetChanged(); +} + + +void SdrGlueEditView::ImpCopyMarkedGluePoints() +{ + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + SdrGluePointList* pGPL=pObj->ForceGluePointList(); + if (!rPts.empty() && pGPL!=nullptr) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + SdrUShortCont aIdsToErase; + SdrUShortCont aIdsToInsert; + for(sal_uInt16 nPtId : rPts) + { + sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId); + if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND) + { + SdrGluePoint aNewGP((*pGPL)[nGlueIdx]); // clone GluePoint + sal_uInt16 nNewIdx=pGPL->Insert(aNewGP); // and insert it + sal_uInt16 nNewId=(*pGPL)[nNewIdx].GetId(); // retrieve ID of new GluePoints + aIdsToErase.insert(nPtId); // select it (instead of the old one) + aIdsToInsert.insert(nNewId); + } + } + for(const auto& rId : aIdsToErase) + rPts.erase(rId); + rPts.insert(aIdsToInsert); + } + } + if( bUndo ) + EndUndo(); + + if (nMarkCount!=0) + GetModel().SetChanged(); +} + + +void SdrGlueEditView::ImpTransformMarkedGluePoints(PGlueTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4) +{ + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + const SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + if (!rPts.empty()) { + SdrGluePointList* pGPL=pObj->ForceGluePointList(); + if (pGPL!=nullptr) + { + if( IsUndoEnabled() ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + for(sal_uInt16 nPtId : rPts) + { + sal_uInt16 nGlueIdx=pGPL->FindGluePoint(nPtId); + if (nGlueIdx!=SDRGLUEPOINT_NOTFOUND) { + SdrGluePoint& rGP=(*pGPL)[nGlueIdx]; + Point aPos(rGP.GetAbsolutePos(*pObj)); + (*pTrFunc)(aPos,p1,p2,p3,p4); + rGP.SetAbsolutePos(aPos,*pObj); + } + } + pObj->SetChanged(); + pObj->BroadcastObjectChange(); + } + } + } + if (nMarkCount!=0) + GetModel().SetChanged(); +} + + +static void ImpMove(Point& rPt, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/) +{ + rPt.AdjustX(static_cast(p1)->Width() ); + rPt.AdjustY(static_cast(p1)->Height() ); +} + +void SdrGlueEditView::MoveMarkedGluePoints(const Size& rSiz, bool bCopy) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditMove)); + if (bCopy) aStr += SvxResId(STR_EditWithCopy); + BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SdrRepeatFunc::Move); + if (bCopy) ImpCopyMarkedGluePoints(); + ImpTransformMarkedGluePoints(ImpMove,&rSiz); + EndUndo(); + AdjustMarkHdl(); +} + + +static void ImpResize(Point& rPt, const void* p1, const void* p2, const void* p3, const void* /*p4*/) +{ + ResizePoint(rPt,*static_cast(p1),*static_cast(p2),*static_cast(p3)); +} + +void SdrGlueEditView::ResizeMarkedGluePoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditResize)); + if (bCopy) aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SdrRepeatFunc::Resize); + if (bCopy) ImpCopyMarkedGluePoints(); + ImpTransformMarkedGluePoints(ImpResize,&rRef,&xFact,&yFact); + EndUndo(); + AdjustMarkHdl(); +} + + +static void ImpRotate(Point& rPt, const void* p1, const void* /*p2*/, const void* p3, const void* p4) +{ + RotatePoint(rPt,*static_cast(p1),*static_cast(p3),*static_cast(p4)); +} + +void SdrGlueEditView::RotateMarkedGluePoints(const Point& rRef, Degree100 nAngle, bool bCopy) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditRotate)); + if (bCopy) aStr+=SvxResId(STR_EditWithCopy); + BegUndo(aStr,GetDescriptionOfMarkedGluePoints(),SdrRepeatFunc::Rotate); + if (bCopy) ImpCopyMarkedGluePoints(); + double nSin = sin(toRadians(nAngle)); + double nCos = cos(toRadians(nAngle)); + ImpTransformMarkedGluePoints(ImpRotate,&rRef,&nAngle,&nSin,&nCos); + EndUndo(); + AdjustMarkHdl(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdglue.cxx b/svx/source/svdraw/svdglue.cxx new file mode 100644 index 0000000000..c27fc2e2bd --- /dev/null +++ b/svx/source/svdraw/svdglue.cxx @@ -0,0 +1,394 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include +#include + +#include +#include +#include +#include + +const Size aGlueHalfSize(4,4); + +void SdrGluePoint::SetReallyAbsolute(bool bOn, const SdrObject& rObj) +{ + if ( m_bReallyAbsolute == bOn ) + return; + + if ( bOn ) + { + m_aPos=GetAbsolutePos(rObj); + m_bReallyAbsolute=bOn; + } + else + { + m_bReallyAbsolute=bOn; + Point aPt(m_aPos); + SetAbsolutePos(aPt,rObj); + } +} + +Point SdrGluePoint::GetAbsolutePos(const SdrObject& rObj) const +{ + if (m_bReallyAbsolute) return m_aPos; + tools::Rectangle aSnap(rObj.GetSnapRect()); + tools::Rectangle aBound(rObj.GetSnapRect()); + Point aPt(m_aPos); + + Point aOfs(aSnap.Center()); + switch (GetHorzAlign()) { + case SdrAlign::HORZ_LEFT : aOfs.setX(aSnap.Left() ); break; + case SdrAlign::HORZ_RIGHT : aOfs.setX(aSnap.Right() ); break; + default: break; + } + switch (GetVertAlign()) { + case SdrAlign::VERT_TOP : aOfs.setY(aSnap.Top() ); break; + case SdrAlign::VERT_BOTTOM: aOfs.setY(aSnap.Bottom() ); break; + default: break; + } + if (!m_bNoPercent) { + tools::Long nXMul=aSnap.Right()-aSnap.Left(); + tools::Long nYMul=aSnap.Bottom()-aSnap.Top(); + tools::Long nXDiv=10000; + tools::Long nYDiv=10000; + if (nXMul!=nXDiv) { + aPt.setX( aPt.X() * nXMul ); + aPt.setX( aPt.X() / nXDiv ); + } + if (nYMul!=nYDiv) { + aPt.setY( aPt.Y() * nYMul ); + aPt.setY( aPt.Y() / nYDiv ); + } + } + aPt+=aOfs; + // Now limit to the BoundRect of the object + if (aPt.X()aBound.Right ()) aPt.setX(aBound.Right () ); + if (aPt.Y()aBound.Bottom()) aPt.setY(aBound.Bottom() ); + return aPt; +} + +void SdrGluePoint::SetAbsolutePos(const Point& rNewPos, const SdrObject& rObj) +{ + if (m_bReallyAbsolute) { + m_aPos=rNewPos; + return; + } + tools::Rectangle aSnap(rObj.GetSnapRect()); + Point aPt(rNewPos); + + Point aOfs(aSnap.Center()); + switch (GetHorzAlign()) { + case SdrAlign::HORZ_LEFT : aOfs.setX(aSnap.Left() ); break; + case SdrAlign::HORZ_RIGHT : aOfs.setX(aSnap.Right() ); break; + default: break; + } + switch (GetVertAlign()) { + case SdrAlign::VERT_TOP : aOfs.setY(aSnap.Top() ); break; + case SdrAlign::VERT_BOTTOM: aOfs.setY(aSnap.Bottom() ); break; + default: break; + } + aPt-=aOfs; + if (!m_bNoPercent) { + tools::Long nXMul=aSnap.Right()-aSnap.Left(); + tools::Long nYMul=aSnap.Bottom()-aSnap.Top(); + if (nXMul==0) nXMul=1; + if (nYMul==0) nYMul=1; + tools::Long nXDiv=10000; + tools::Long nYDiv=10000; + if (nXMul!=nXDiv) { + aPt.setX( aPt.X() * nXDiv ); + aPt.setX( aPt.X() / nXMul ); + } + if (nYMul!=nYDiv) { + aPt.setY( aPt.Y() * nYDiv ); + aPt.setY( aPt.Y() / nYMul ); + } + } + m_aPos=aPt; +} + +Degree100 SdrGluePoint::GetAlignAngle() const +{ + if (m_nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER)) + return 0_deg100; // Invalid! + else if (m_nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER)) + return 0_deg100; + else if (m_nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP)) + return 4500_deg100; + else if (m_nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP)) + return 9000_deg100; + else if (m_nAlign == (SdrAlign::HORZ_LEFT |SdrAlign::VERT_TOP)) + return 13500_deg100; + else if (m_nAlign == (SdrAlign::HORZ_LEFT |SdrAlign::VERT_CENTER)) + return 18000_deg100; + else if (m_nAlign == (SdrAlign::HORZ_LEFT |SdrAlign::VERT_BOTTOM)) + return 22500_deg100; + else if (m_nAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM)) + return 27000_deg100; + else if (m_nAlign == (SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM)) + return 31500_deg100; + return 0_deg100; +} + +void SdrGluePoint::SetAlignAngle(Degree100 nAngle) +{ + nAngle=NormAngle36000(nAngle); + if (nAngle>=33750_deg100 || nAngle<2250_deg100) m_nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_CENTER; + else if (nAngle< 6750_deg100) m_nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_TOP ; + else if (nAngle<11250_deg100) m_nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP ; + else if (nAngle<15750_deg100) m_nAlign=SdrAlign::HORZ_LEFT |SdrAlign::VERT_TOP ; + else if (nAngle<20250_deg100) m_nAlign=SdrAlign::HORZ_LEFT |SdrAlign::VERT_CENTER; + else if (nAngle<24750_deg100) m_nAlign=SdrAlign::HORZ_LEFT |SdrAlign::VERT_BOTTOM; + else if (nAngle<29250_deg100) m_nAlign=SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM; + else if (nAngle<33750_deg100) m_nAlign=SdrAlign::HORZ_RIGHT |SdrAlign::VERT_BOTTOM; +} + +Degree100 SdrGluePoint::EscDirToAngle(SdrEscapeDirection nEsc) +{ + switch (nEsc) { + case SdrEscapeDirection::RIGHT : return 0_deg100; + case SdrEscapeDirection::TOP : return 9000_deg100; + case SdrEscapeDirection::LEFT : return 18000_deg100; + case SdrEscapeDirection::BOTTOM: return 27000_deg100; + default: break; + } // switch + return 0_deg100; +} + +SdrEscapeDirection SdrGluePoint::EscAngleToDir(Degree100 nAngle) +{ + nAngle=NormAngle36000(nAngle); + if (nAngle>=31500_deg100 || nAngle<4500_deg100) + return SdrEscapeDirection::RIGHT; + if (nAngle<13500_deg100) + return SdrEscapeDirection::TOP; + if (nAngle<22500_deg100) + return SdrEscapeDirection::LEFT; + /* (nAngle<31500)*/ + return SdrEscapeDirection::BOTTOM; +} + +void SdrGluePoint::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs, const SdrObject* pObj) +{ + Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos()); + RotatePoint(aPt,rRef,sn,cs); + // rotate reference edge + if(m_nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER)) + { + SetAlignAngle(GetAlignAngle()+nAngle); + } + // rotate exit directions + SdrEscapeDirection nEscDir0=m_nEscDir; + SdrEscapeDirection nEscDir1=SdrEscapeDirection::SMART; + if (nEscDir0&SdrEscapeDirection::LEFT ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::LEFT )+nAngle); + if (nEscDir0&SdrEscapeDirection::TOP ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::TOP )+nAngle); + if (nEscDir0&SdrEscapeDirection::RIGHT ) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::RIGHT )+nAngle); + if (nEscDir0&SdrEscapeDirection::BOTTOM) nEscDir1 |= EscAngleToDir(EscDirToAngle(SdrEscapeDirection::BOTTOM)+nAngle); + m_nEscDir=nEscDir1; + if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); +} + +void SdrGluePoint::Mirror(const Point& rRef1, const Point& rRef2, Degree100 nAngle, const SdrObject* pObj) +{ + Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos()); + MirrorPoint(aPt,rRef1,rRef2); + // mirror reference edge + if(m_nAlign != (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER)) + { + Degree100 nAW=GetAlignAngle(); + nAW+=2_deg100*(nAngle-nAW); + SetAlignAngle(nAW); + } + // mirror exit directions + SdrEscapeDirection nEscDir0=m_nEscDir; + SdrEscapeDirection nEscDir1=SdrEscapeDirection::SMART; + if (nEscDir0&SdrEscapeDirection::LEFT) { + Degree100 nEW=EscDirToAngle(SdrEscapeDirection::LEFT); + nEW+=2_deg100*(nAngle-nEW); + nEscDir1|=EscAngleToDir(nEW); + } + if (nEscDir0&SdrEscapeDirection::TOP) { + Degree100 nEW=EscDirToAngle(SdrEscapeDirection::TOP); + nEW+=2_deg100*(nAngle-nEW); + nEscDir1|=EscAngleToDir(nEW); + } + if (nEscDir0&SdrEscapeDirection::RIGHT) { + Degree100 nEW=EscDirToAngle(SdrEscapeDirection::RIGHT); + nEW+=2_deg100*(nAngle-nEW); + nEscDir1|=EscAngleToDir(nEW); + } + if (nEscDir0&SdrEscapeDirection::BOTTOM) { + Degree100 nEW=EscDirToAngle(SdrEscapeDirection::BOTTOM); + nEW+=2_deg100*(nAngle-nEW); + nEscDir1|=EscAngleToDir(nEW); + } + m_nEscDir=nEscDir1; + if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); +} + +void SdrGluePoint::Shear(const Point& rRef, double tn, bool bVShear, const SdrObject* pObj) +{ + Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos()); + ShearPoint(aPt,rRef,tn,bVShear); + if (pObj!=nullptr) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); +} + +void SdrGluePoint::Invalidate(vcl::Window& rWin, const SdrObject* pObj) const +{ + if (comphelper::LibreOfficeKit::isActive()) + return; + bool bMapMode=rWin.IsMapModeEnabled(); + Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos()); + aPt=rWin.LogicToPixel(aPt); + rWin.EnableMapMode(false); + + Size aSiz( aGlueHalfSize ); + tools::Rectangle aRect(aPt.X()-aSiz.Width(),aPt.Y()-aSiz.Height(), + aPt.X()+aSiz.Width(),aPt.Y()+aSiz.Height()); + + // do not erase background, that causes flicker (!) + rWin.Invalidate(aRect, InvalidateFlags::NoErase); + + rWin.EnableMapMode(bMapMode); +} + +bool SdrGluePoint::IsHit(const Point& rPnt, const OutputDevice& rOut, const SdrObject* pObj) const +{ + Point aPt(pObj!=nullptr ? GetAbsolutePos(*pObj) : GetPos()); + Size aSiz=rOut.PixelToLogic(aGlueHalfSize); + tools::Rectangle aRect(aPt.X()-aSiz.Width(),aPt.Y()-aSiz.Height(),aPt.X()+aSiz.Width(),aPt.Y()+aSiz.Height()); + return aRect.Contains(rPnt); +} + + +SdrGluePointList& SdrGluePointList::operator=(const SdrGluePointList& rSrcList) +{ + if (GetCount()!=0) m_aList.clear(); + sal_uInt16 nCount=rSrcList.GetCount(); + for (sal_uInt16 i=0; i=nCount,"SdrGluePointList::Insert(): nLastIdnCount; + if (nId<=nLastId) { + if (!bHole || nId==0) { + nId=nLastId+1; + } else { + bool bBrk = false; + for (sal_uInt16 nNum=0; nNumnId) { + nInsPos=nNum; // insert here (sort) + bBrk = true; + } + } + } + aGP.SetId(nId); + } + m_aList.emplace(m_aList.begin()+nInsPos, aGP); + return nInsPos; +} + +void SdrGluePointList::Invalidate(vcl::Window& rWin, const SdrObject* pObj) const +{ + if (comphelper::LibreOfficeKit::isActive()) + return; + for (auto& xGP : m_aList) + xGP.Invalidate(rWin,pObj); +} + +sal_uInt16 SdrGluePointList::FindGluePoint(sal_uInt16 nId) const +{ + // TODO: Implement a better search algorithm + // List should be sorted at all times! + sal_uInt16 nCount=GetCount(); + sal_uInt16 nRet=SDRGLUEPOINT_NOTFOUND; + for (sal_uInt16 nNum=0; nNum0) && nRet==SDRGLUEPOINT_NOTFOUND) { + nNum--; + const auto& pGP = m_aList[nNum]; + if (pGP.IsHit(rPnt,rOut,pObj)) + nRet = nNum; + } + return nRet; +} + +void SdrGluePointList::SetReallyAbsolute(bool bOn, const SdrObject& rObj) +{ + for (auto& xGP : m_aList) + xGP.SetReallyAbsolute(bOn,rObj); +} + +void SdrGluePointList::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs, const SdrObject* pObj) +{ + for (auto& xGP : m_aList) + xGP.Rotate(rRef,nAngle,sn,cs,pObj); +} + +void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, const SdrObject* pObj) +{ + Point aPt(rRef2); aPt-=rRef1; + Degree100 nAngle=GetAngle(aPt); + Mirror(rRef1,rRef2,nAngle,pObj); +} + +void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, Degree100 nAngle, const SdrObject* pObj) +{ + for (auto& xGP : m_aList) + xGP.Mirror(rRef1,rRef2,nAngle,pObj); +} + +void SdrGluePointList::Shear(const Point& rRef, double tn, bool bVShear, const SdrObject* pObj) +{ + for (auto& xGP : m_aList) + xGP.Shear(rRef,tn,bVShear,pObj); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdhdl.cxx b/svx/source/svdraw/svdhdl.cxx new file mode 100644 index 0000000000..867afa6a90 --- /dev/null +++ b/svx/source/svdraw/svdhdl.cxx @@ -0,0 +1,2674 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include "gradtrns.hxx" +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +// #i15222# +// Due to the resource problems in Win95/98 with bitmap resources I +// will change this handle bitmap providing class. Old version was splitting +// and preparing all small handle bitmaps in device bitmap format, now this will +// be done on the fly. Thus, there is only one big bitmap in memory. With +// three source bitmaps, this will be 3 system bitmap resources instead of hundreds. +// The price for that needs to be evaluated. Maybe we will need another change here +// if this is too expensive. +class SdrHdlBitmapSet +{ + // the bitmap holding all information + BitmapEx maMarkersBitmap; + + // the cropped Bitmaps for reusage + ::std::vector< BitmapEx > maRealMarkers; + + // helpers + BitmapEx& impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const tools::Rectangle& rRectangle); + +public: + explicit SdrHdlBitmapSet(); + + const BitmapEx& GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd); +}; + +} + +#define KIND_COUNT (14) +#define INDEX_COUNT (6) +#define INDIVIDUAL_COUNT (5) + +SdrHdlBitmapSet::SdrHdlBitmapSet() + : maMarkersBitmap(SIP_SA_MARKERS), + // 15 kinds (BitmapMarkerKind) use index [0..5] + 5 extra + maRealMarkers((KIND_COUNT * INDEX_COUNT) + INDIVIDUAL_COUNT) +{ +} + +BitmapEx& SdrHdlBitmapSet::impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const tools::Rectangle& rRectangle) +{ + BitmapEx& rTargetBitmap = maRealMarkers[nIndex]; + + if(rTargetBitmap.IsEmpty()) + { + rTargetBitmap = maMarkersBitmap; + rTargetBitmap.Crop(rRectangle); + } + + return rTargetBitmap; +} + +// change getting of bitmap to use the big resource bitmap +const BitmapEx& SdrHdlBitmapSet::GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd) +{ + // fill in size and source position in maMarkersBitmap + const sal_uInt16 nYPos(nInd * 11); + + switch(eKindOfMarker) + { + default: + { + OSL_FAIL( "Unknown kind of marker." ); + [[fallthrough]]; // return Rect_9x9 as default + } + case BitmapMarkerKind::Rect_9x9: + { + return impGetOrCreateTargetBitmap((1 * INDEX_COUNT) + nInd, tools::Rectangle(Point(7, nYPos), Size(9, 9))); + } + + case BitmapMarkerKind::Rect_7x7: + { + return impGetOrCreateTargetBitmap((0 * INDEX_COUNT) + nInd, tools::Rectangle(Point(0, nYPos), Size(7, 7))); + } + + case BitmapMarkerKind::Rect_11x11: + { + return impGetOrCreateTargetBitmap((2 * INDEX_COUNT) + nInd, tools::Rectangle(Point(16, nYPos), Size(11, 11))); + } + + case BitmapMarkerKind::Rect_13x13: + { + const sal_uInt16 nIndex((3 * INDEX_COUNT) + nInd); + + switch(nInd) + { + case 0: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(72, 66), Size(13, 13))); + } + case 1: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(85, 66), Size(13, 13))); + } + case 2: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(72, 79), Size(13, 13))); + } + case 3: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(85, 79), Size(13, 13))); + } + case 4: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(98, 79), Size(13, 13))); + } + default: // case 5: + { + return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(98, 66), Size(13, 13))); + } + } + } + + case BitmapMarkerKind::Circ_7x7: + case BitmapMarkerKind::Customshape_7x7: + { + return impGetOrCreateTargetBitmap((4 * INDEX_COUNT) + nInd, tools::Rectangle(Point(27, nYPos), Size(7, 7))); + } + + case BitmapMarkerKind::Circ_9x9: + case BitmapMarkerKind::Customshape_9x9: + { + return impGetOrCreateTargetBitmap((5 * INDEX_COUNT) + nInd, tools::Rectangle(Point(34, nYPos), Size(9, 9))); + } + + case BitmapMarkerKind::Circ_11x11: + case BitmapMarkerKind::Customshape_11x11: + { + return impGetOrCreateTargetBitmap((6 * INDEX_COUNT) + nInd, tools::Rectangle(Point(43, nYPos), Size(11, 11))); + } + + case BitmapMarkerKind::Elli_7x9: + { + return impGetOrCreateTargetBitmap((7 * INDEX_COUNT) + nInd, tools::Rectangle(Point(54, nYPos), Size(7, 9))); + } + + case BitmapMarkerKind::Elli_9x11: + { + return impGetOrCreateTargetBitmap((8 * INDEX_COUNT) + nInd, tools::Rectangle(Point(61, nYPos), Size(9, 11))); + } + + case BitmapMarkerKind::Elli_9x7: + { + return impGetOrCreateTargetBitmap((9 * INDEX_COUNT) + nInd, tools::Rectangle(Point(70, nYPos), Size(9, 7))); + } + + case BitmapMarkerKind::Elli_11x9: + { + return impGetOrCreateTargetBitmap((10 * INDEX_COUNT) + nInd, tools::Rectangle(Point(79, nYPos), Size(11, 9))); + } + + case BitmapMarkerKind::RectPlus_7x7: + { + return impGetOrCreateTargetBitmap((11 * INDEX_COUNT) + nInd, tools::Rectangle(Point(90, nYPos), Size(7, 7))); + } + + case BitmapMarkerKind::RectPlus_9x9: + { + return impGetOrCreateTargetBitmap((12 * INDEX_COUNT) + nInd, tools::Rectangle(Point(97, nYPos), Size(9, 9))); + } + + case BitmapMarkerKind::RectPlus_11x11: + { + return impGetOrCreateTargetBitmap((13 * INDEX_COUNT) + nInd, tools::Rectangle(Point(106, nYPos), Size(11, 11))); + } + + case BitmapMarkerKind::Crosshair: + { + return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 0, tools::Rectangle(Point(0, 68), Size(15, 15))); + } + + case BitmapMarkerKind::Glue: + { + return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 1, tools::Rectangle(Point(15, 76), Size(9, 9))); + } + + case BitmapMarkerKind::Glue_Deselected: + { + return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 2, tools::Rectangle(Point(15, 67), Size(9, 9))); + } + + case BitmapMarkerKind::Anchor: // AnchorTR for SW + case BitmapMarkerKind::AnchorTR: + { + return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 3, tools::Rectangle(Point(24, 67), Size(24, 24))); + } + + // add AnchorPressed to be able to animate anchor control + case BitmapMarkerKind::AnchorPressed: + case BitmapMarkerKind::AnchorPressedTR: + { + return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 4, tools::Rectangle(Point(48, 67), Size(24, 24))); + } + } +} + + +SdrHdl::SdrHdl(): + m_pObj(nullptr), + m_pPV(nullptr), + m_pHdlList(nullptr), + m_eKind(SdrHdlKind::Move), + m_nRotationAngle(0), + m_nObjHdlNum(0), + m_nPolyNum(0), + m_nPPntNum(0), + m_nSourceHdlNum(0), + m_bSelect(false), + m_b1PixMore(false), + m_bPlusHdl(false), + mbMoveOutside(false), + mbMouseOver(false) +{ +} + +SdrHdl::SdrHdl(const Point& rPnt, SdrHdlKind eNewKind): + m_pObj(nullptr), + m_pPV(nullptr), + m_pHdlList(nullptr), + m_aPos(rPnt), + m_eKind(eNewKind), + m_nRotationAngle(0), + m_nObjHdlNum(0), + m_nPolyNum(0), + m_nPPntNum(0), + m_nSourceHdlNum(0), + m_bSelect(false), + m_b1PixMore(false), + m_bPlusHdl(false), + mbMoveOutside(false), + mbMouseOver(false) +{ +} + +SdrHdl::~SdrHdl() +{ + GetRidOfIAObject(); +} + +void SdrHdl::Set1PixMore(bool bJa) +{ + if(m_b1PixMore != bJa) + { + m_b1PixMore = bJa; + + // create new display + Touch(); + } +} + +void SdrHdl::SetMoveOutside( bool bMoveOutside ) +{ + if(mbMoveOutside != bMoveOutside) + { + mbMoveOutside = bMoveOutside; + + // create new display + Touch(); + } +} + +void SdrHdl::SetRotationAngle(Degree100 n) +{ + if(m_nRotationAngle != n) + { + m_nRotationAngle = n; + + // create new display + Touch(); + } +} + +void SdrHdl::SetPos(const Point& rPnt) +{ + if(m_aPos != rPnt) + { + // remember new position + m_aPos = rPnt; + + // create new display + Touch(); + } +} + +void SdrHdl::SetSelected(bool bJa) +{ + if(m_bSelect != bJa) + { + // remember new value + m_bSelect = bJa; + + // create new display + Touch(); + } +} + +void SdrHdl::SetHdlList(SdrHdlList* pList) +{ + if(m_pHdlList != pList) + { + // remember list + m_pHdlList = pList; + + // now it's possible to create graphic representation + Touch(); + } +} + +void SdrHdl::SetObj(SdrObject* pNewObj) +{ + if(m_pObj != pNewObj) + { + // remember new object + m_pObj = pNewObj; + + // graphic representation may have changed + Touch(); + } +} + +void SdrHdl::Touch() +{ + // force update of graphic representation + CreateB2dIAObject(); +} + +void SdrHdl::GetRidOfIAObject() +{ + + // OVERLAYMANAGER + maOverlayGroup.clear(); +} + +void SdrHdl::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList || !m_pHdlList->GetView() || m_pHdlList->GetView()->areMarkHandlesHidden()) + return; + + BitmapColorIndex eColIndex = BitmapColorIndex::LightGreen; + BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_7x7; + + bool bRot = m_pHdlList->IsRotateShear(); + if(m_pObj) + eColIndex = m_bSelect ? BitmapColorIndex::Cyan : BitmapColorIndex::LightCyan; + if(bRot) + { + // red rotation handles + if(m_pObj && m_bSelect) + eColIndex = BitmapColorIndex::Red; + else + eColIndex = BitmapColorIndex::LightRed; + } + + switch(m_eKind) + { + case SdrHdlKind::Move: + { + eKindOfMarker = m_b1PixMore ? BitmapMarkerKind::Rect_9x9 : BitmapMarkerKind::Rect_7x7; + break; + } + case SdrHdlKind::UpperLeft: + case SdrHdlKind::UpperRight: + case SdrHdlKind::LowerLeft: + case SdrHdlKind::LowerRight: + { + // corner handles + if(bRot) + { + eKindOfMarker = BitmapMarkerKind::Circ_7x7; + } + else + { + eKindOfMarker = BitmapMarkerKind::Rect_7x7; + } + break; + } + case SdrHdlKind::Upper: + case SdrHdlKind::Lower: + { + // Upper/Lower handles + if(bRot) + { + eKindOfMarker = BitmapMarkerKind::Elli_9x7; + } + else + { + eKindOfMarker = BitmapMarkerKind::Rect_7x7; + } + break; + } + case SdrHdlKind::Left: + case SdrHdlKind::Right: + { + // Left/Right handles + if(bRot) + { + eKindOfMarker = BitmapMarkerKind::Elli_7x9; + } + else + { + eKindOfMarker = BitmapMarkerKind::Rect_7x7; + } + break; + } + case SdrHdlKind::Poly: + { + if(bRot) + { + eKindOfMarker = m_b1PixMore ? BitmapMarkerKind::Circ_9x9 : BitmapMarkerKind::Circ_7x7; + } + else + { + eKindOfMarker = m_b1PixMore ? BitmapMarkerKind::Rect_9x9 : BitmapMarkerKind::Rect_7x7; + } + break; + } + case SdrHdlKind::BezierWeight: // weight at poly + { + eKindOfMarker = BitmapMarkerKind::Circ_7x7; + break; + } + case SdrHdlKind::Circle: + { + eKindOfMarker = BitmapMarkerKind::Rect_11x11; + break; + } + case SdrHdlKind::Ref1: + case SdrHdlKind::Ref2: + { + eKindOfMarker = BitmapMarkerKind::Crosshair; + break; + } + case SdrHdlKind::Glue: + { + eKindOfMarker = BitmapMarkerKind::Glue; + break; + } + case SdrHdlKind::Anchor: + { + eKindOfMarker = BitmapMarkerKind::Anchor; + break; + } + case SdrHdlKind::User: + { + break; + } + // top right anchor for SW + case SdrHdlKind::Anchor_TR: + { + eKindOfMarker = BitmapMarkerKind::AnchorTR; + break; + } + + // for SJ and the CustomShapeHandles: + case SdrHdlKind::CustomShape1: + { + eKindOfMarker = m_b1PixMore ? BitmapMarkerKind::Customshape_9x9 : BitmapMarkerKind::Customshape_7x7; + eColIndex = BitmapColorIndex::Yellow; + break; + } + default: + break; + } + + SdrMarkView* pView = m_pHdlList->GetView(); + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b]; + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + Point aMoveOutsideOffset(0, 0); + OutputDevice& rOutDev = rPageWindow.GetPaintWindow().GetOutputDevice(); + + // add offset if necessary + if(m_pHdlList->IsMoveOutside() || mbMoveOutside) + { + Size aOffset = rOutDev.PixelToLogic(Size(4, 4)); + + if(m_eKind == SdrHdlKind::UpperLeft || m_eKind == SdrHdlKind::Upper || m_eKind == SdrHdlKind::UpperRight) + aMoveOutsideOffset.AdjustY( -(aOffset.Width()) ); + if(m_eKind == SdrHdlKind::LowerLeft || m_eKind == SdrHdlKind::Lower || m_eKind == SdrHdlKind::LowerRight) + aMoveOutsideOffset.AdjustY(aOffset.Height() ); + if(m_eKind == SdrHdlKind::UpperLeft || m_eKind == SdrHdlKind::Left || m_eKind == SdrHdlKind::LowerLeft) + aMoveOutsideOffset.AdjustX( -(aOffset.Width()) ); + if(m_eKind == SdrHdlKind::UpperRight || m_eKind == SdrHdlKind::Right || m_eKind == SdrHdlKind::LowerRight) + aMoveOutsideOffset.AdjustX(aOffset.Height() ); + } + + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + std::unique_ptr pNewOverlayObject; + if (getenv ("SVX_DRAW_HANDLES") && (eKindOfMarker == BitmapMarkerKind::Rect_7x7 || eKindOfMarker == BitmapMarkerKind::Rect_9x9 || eKindOfMarker == BitmapMarkerKind::Rect_11x11)) + { + double fSize = 7.0; + switch (eKindOfMarker) + { + case BitmapMarkerKind::Rect_9x9: + fSize = 9.0; + break; + case BitmapMarkerKind::Rect_11x11: + fSize = 11.0; + break; + default: + break; + } + float fScalingFactor = rOutDev.GetDPIScaleFactor(); + basegfx::B2DSize aB2DSize(fSize * fScalingFactor, fSize * fScalingFactor); + + Color aHandleFillColor(COL_LIGHTGREEN); + switch (eColIndex) + { + case BitmapColorIndex::Cyan: + aHandleFillColor = COL_CYAN; + break; + case BitmapColorIndex::LightCyan: + aHandleFillColor = COL_LIGHTCYAN; + break; + case BitmapColorIndex::Red: + aHandleFillColor = COL_RED; + break; + case BitmapColorIndex::LightRed: + aHandleFillColor = COL_LIGHTRED; + break; + case BitmapColorIndex::Yellow: + aHandleFillColor = COL_YELLOW; + break; + default: + break; + } + pNewOverlayObject.reset(new sdr::overlay::OverlayHandle(aPosition, aB2DSize, /*HandleStrokeColor*/COL_BLACK, aHandleFillColor)); + } + else + { + pNewOverlayObject = CreateOverlayObject( + aPosition, eColIndex, eKindOfMarker, + aMoveOutsideOffset); + } + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +BitmapMarkerKind SdrHdl::GetNextBigger(BitmapMarkerKind eKnd) +{ + BitmapMarkerKind eRetval(eKnd); + + switch(eKnd) + { + case BitmapMarkerKind::Rect_7x7: eRetval = BitmapMarkerKind::Rect_9x9; break; + case BitmapMarkerKind::Rect_9x9: eRetval = BitmapMarkerKind::Rect_11x11; break; + case BitmapMarkerKind::Rect_11x11: eRetval = BitmapMarkerKind::Rect_13x13; break; + + case BitmapMarkerKind::Circ_7x7: eRetval = BitmapMarkerKind::Circ_9x9; break; + case BitmapMarkerKind::Circ_9x9: eRetval = BitmapMarkerKind::Circ_11x11; break; + + case BitmapMarkerKind::Customshape_7x7: eRetval = BitmapMarkerKind::Customshape_9x9; break; + case BitmapMarkerKind::Customshape_9x9: eRetval = BitmapMarkerKind::Customshape_11x11; break; + //case BitmapMarkerKind::Customshape_11x11: eRetval = ; break; + + case BitmapMarkerKind::Elli_7x9: eRetval = BitmapMarkerKind::Elli_9x11; break; + + case BitmapMarkerKind::Elli_9x7: eRetval = BitmapMarkerKind::Elli_11x9; break; + + case BitmapMarkerKind::RectPlus_7x7: eRetval = BitmapMarkerKind::RectPlus_9x9; break; + case BitmapMarkerKind::RectPlus_9x9: eRetval = BitmapMarkerKind::RectPlus_11x11; break; + + // let anchor blink with its pressed state + case BitmapMarkerKind::Anchor: eRetval = BitmapMarkerKind::AnchorPressed; break; + + // same for AnchorTR + case BitmapMarkerKind::AnchorTR: eRetval = BitmapMarkerKind::AnchorPressedTR; break; + default: + break; + } + + return eRetval; +} + +namespace +{ + +OUString appendMarkerName(BitmapMarkerKind eKindOfMarker) +{ + switch(eKindOfMarker) + { + case BitmapMarkerKind::Rect_7x7: + return "rect7"; + case BitmapMarkerKind::Rect_9x9: + return "rect9"; + case BitmapMarkerKind::Rect_11x11: + return "rect11"; + case BitmapMarkerKind::Rect_13x13: + return "rect13"; + case BitmapMarkerKind::Circ_7x7: + case BitmapMarkerKind::Customshape_7x7: + return "circ7"; + case BitmapMarkerKind::Circ_9x9: + case BitmapMarkerKind::Customshape_9x9: + return "circ9"; + case BitmapMarkerKind::Circ_11x11: + case BitmapMarkerKind::Customshape_11x11: + return "circ11"; + case BitmapMarkerKind::Elli_7x9: + return "elli7x9"; + case BitmapMarkerKind::Elli_9x11: + return "elli9x11"; + case BitmapMarkerKind::Elli_9x7: + return "elli9x7"; + case BitmapMarkerKind::Elli_11x9: + return "elli11x9"; + case BitmapMarkerKind::RectPlus_7x7: + return "rectplus7"; + case BitmapMarkerKind::RectPlus_9x9: + return "rectplus9"; + case BitmapMarkerKind::RectPlus_11x11: + return "rectplus11"; + case BitmapMarkerKind::Crosshair: + return "cross"; + case BitmapMarkerKind::Anchor: + case BitmapMarkerKind::AnchorTR: + return "anchor"; + case BitmapMarkerKind::AnchorPressed: + case BitmapMarkerKind::AnchorPressedTR: + return "anchor-pressed"; + case BitmapMarkerKind::Glue: + return "glue-selected"; + case BitmapMarkerKind::Glue_Deselected: + return "glue-unselected"; + default: + break; + } + return OUString(); +} + +OUString appendMarkerColor(BitmapColorIndex eIndex) +{ + switch(eIndex) + { + case BitmapColorIndex::LightGreen: + return "1"; + case BitmapColorIndex::Cyan: + return "2"; + case BitmapColorIndex::LightCyan: + return "3"; + case BitmapColorIndex::Red: + return "4"; + case BitmapColorIndex::LightRed: + return "5"; + case BitmapColorIndex::Yellow: + return "6"; + default: + break; + } + return OUString(); +} + +BitmapEx ImpGetBitmapEx(BitmapMarkerKind eKindOfMarker, BitmapColorIndex eIndex) +{ + // use this code path only when we use HiDPI (for now) + if (Application::GetDefaultDevice()->GetDPIScalePercentage() > 100) + { + OUString sMarkerName = appendMarkerName(eKindOfMarker); + if (!sMarkerName.isEmpty()) + { + OUString sMarkerPrefix("svx/res/marker-"); + BitmapEx aBitmapEx; + + if (eKindOfMarker == BitmapMarkerKind::Crosshair + || eKindOfMarker == BitmapMarkerKind::Anchor + || eKindOfMarker == BitmapMarkerKind::AnchorTR + || eKindOfMarker == BitmapMarkerKind::AnchorPressed + || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR + || eKindOfMarker == BitmapMarkerKind::Glue + || eKindOfMarker == BitmapMarkerKind::Glue_Deselected) + { + aBitmapEx = vcl::bitmap::loadFromName(sMarkerPrefix + sMarkerName + ".png"); + } + else + { + aBitmapEx = vcl::bitmap::loadFromName(sMarkerPrefix + sMarkerName + "-" + appendMarkerColor(eIndex) + ".png"); + } + + if (!aBitmapEx.IsEmpty()) + return aBitmapEx; + } + } + + // if we can't load the marker... + + static vcl::DeleteOnDeinit< SdrHdlBitmapSet > aModernSet {}; + return aModernSet.get()->GetBitmapEx(eKindOfMarker, sal_uInt16(eIndex)); +} + +} // end anonymous namespace + +std::unique_ptr SdrHdl::CreateOverlayObject( + const basegfx::B2DPoint& rPos, + BitmapColorIndex eColIndex, BitmapMarkerKind eKindOfMarker, Point aMoveOutsideOffset) +{ + std::unique_ptr pRetval; + + // support bigger sizes + bool bForceBiggerSize(false); + + if (m_pHdlList && m_pHdlList->GetHdlSize() > 3) + { + switch(eKindOfMarker) + { + case BitmapMarkerKind::Anchor: + case BitmapMarkerKind::AnchorPressed: + case BitmapMarkerKind::AnchorTR: + case BitmapMarkerKind::AnchorPressedTR: + { + // #i121463# For anchor, do not simply make bigger because of HdlSize, + // do it dependent of IsSelected() which Writer can set in drag mode + if(IsSelected()) + { + bForceBiggerSize = true; + } + break; + } + default: + { + bForceBiggerSize = true; + break; + } + } + } + + if(bForceBiggerSize) + { + eKindOfMarker = GetNextBigger(eKindOfMarker); + } + + // This handle has the focus, visualize it + if(IsFocusHdl() && m_pHdlList && m_pHdlList->GetFocusHdl() == this) + { + // create animated handle + BitmapMarkerKind eNextBigger = GetNextBigger(eKindOfMarker); + + if(eNextBigger == eKindOfMarker) + { + // this may happen for the not supported getting-bigger types. + // Choose an alternative here + switch(eKindOfMarker) + { + case BitmapMarkerKind::Rect_13x13: eNextBigger = BitmapMarkerKind::Rect_11x11; break; + case BitmapMarkerKind::Circ_11x11: eNextBigger = BitmapMarkerKind::Elli_11x9; break; + case BitmapMarkerKind::Elli_9x11: eNextBigger = BitmapMarkerKind::Elli_11x9; break; + case BitmapMarkerKind::Elli_11x9: eNextBigger = BitmapMarkerKind::Elli_9x11; break; + case BitmapMarkerKind::RectPlus_11x11: eNextBigger = BitmapMarkerKind::Rect_13x13; break; + + case BitmapMarkerKind::Crosshair: + eNextBigger = BitmapMarkerKind::Glue; + break; + + case BitmapMarkerKind::Glue: + eNextBigger = BitmapMarkerKind::Crosshair; + break; + case BitmapMarkerKind::Glue_Deselected: + eNextBigger = BitmapMarkerKind::Glue; + break; + default: + break; + } + } + + // create animated handle + BitmapEx aBmpEx1 = ImpGetBitmapEx(eKindOfMarker, eColIndex); + BitmapEx aBmpEx2 = ImpGetBitmapEx(eNextBigger, eColIndex); + + // #i53216# Use system cursor blink time. Use the unsigned value. + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const sal_uInt64 nBlinkTime(rStyleSettings.GetCursorBlinkTime()); + + if(eKindOfMarker == BitmapMarkerKind::Anchor || eKindOfMarker == BitmapMarkerKind::AnchorPressed) + { + // when anchor is used take upper left as reference point inside the handle + pRetval.reset(new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime)); + } + else if(eKindOfMarker == BitmapMarkerKind::AnchorTR || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR) + { + // AnchorTR for SW, take top right as (0,0) + pRetval.reset(new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime, + static_cast(aBmpEx1.GetSizePixel().Width() - 1), 0, + static_cast(aBmpEx2.GetSizePixel().Width() - 1), 0)); + } + else + { + // create centered handle as default + pRetval.reset(new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime, + static_cast(aBmpEx1.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpEx1.GetSizePixel().Height() - 1) >> 1, + static_cast(aBmpEx2.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpEx2.GetSizePixel().Height() - 1) >> 1)); + } + } + else + { + // create normal handle: use ImpGetBitmapEx(...) now + BitmapEx aBmpEx = ImpGetBitmapEx(eKindOfMarker, eColIndex); + + // When the image with handles is not found, the bitmap returned is + // empty. This is a problem when we use LibreOffice as a library + // (through LOKit - for example on Android) even when we don't show + // the handles, because the hit test would always return false. + // + // This HACK replaces the empty bitmap with a black 13x13 bitmap handle + // so that the hit test works for this case. + if (aBmpEx.IsEmpty()) + { + aBmpEx = BitmapEx(Size(13, 13), vcl::PixelFormat::N24_BPP); + aBmpEx.Erase(COL_BLACK); + } + + if(eKindOfMarker == BitmapMarkerKind::Anchor || eKindOfMarker == BitmapMarkerKind::AnchorPressed) + { + // upper left as reference point inside the handle for AnchorPressed, too + pRetval.reset(new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx)); + } + else if(eKindOfMarker == BitmapMarkerKind::AnchorTR || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR) + { + // AnchorTR for SW, take top right as (0,0) + pRetval.reset(new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx, + static_cast(aBmpEx.GetSizePixel().Width() - 1), 0)); + } + else + { + sal_uInt16 nCenX(static_cast(aBmpEx.GetSizePixel().Width() - 1) >> 1); + sal_uInt16 nCenY(static_cast(aBmpEx.GetSizePixel().Height() - 1) >> 1); + + if(aMoveOutsideOffset.X() > 0) + { + nCenX = 0; + } + else if(aMoveOutsideOffset.X() < 0) + { + nCenX = static_cast(aBmpEx.GetSizePixel().Width() - 1); + } + + if(aMoveOutsideOffset.Y() > 0) + { + nCenY = 0; + } + else if(aMoveOutsideOffset.Y() < 0) + { + nCenY = static_cast(aBmpEx.GetSizePixel().Height() - 1); + } + + // create centered handle as default + pRetval.reset(new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx, nCenX, nCenY)); + } + } + + return pRetval; +} + +bool SdrHdl::IsHdlHit(const Point& rPnt) const +{ + // OVERLAYMANAGER + basegfx::B2DPoint aPosition(rPnt.X(), rPnt.Y()); + return maOverlayGroup.isHitLogic(aPosition); +} + +PointerStyle SdrHdl::GetPointer() const +{ + PointerStyle ePtr=PointerStyle::Move; + const bool bSize=m_eKind>=SdrHdlKind::UpperLeft && m_eKind<=SdrHdlKind::LowerRight; + const bool bRot=m_pHdlList!=nullptr && m_pHdlList->IsRotateShear(); + const bool bDis=m_pHdlList!=nullptr && m_pHdlList->IsDistortShear(); + if (bSize && m_pHdlList!=nullptr && (bRot || bDis)) { + switch (m_eKind) { + case SdrHdlKind::UpperLeft: case SdrHdlKind::UpperRight: + case SdrHdlKind::LowerLeft: case SdrHdlKind::LowerRight: ePtr=bRot ? PointerStyle::Rotate : PointerStyle::RefHand; break; + case SdrHdlKind::Left : case SdrHdlKind::Right: ePtr=PointerStyle::VShear; break; + case SdrHdlKind::Upper: case SdrHdlKind::Lower: ePtr=PointerStyle::HShear; break; + default: + break; + } + } else { + // When resizing rotated rectangles, rotate the mouse cursor slightly, too + if (bSize && m_nRotationAngle!=0_deg100) { + Degree100 nHdlAngle(0); + switch (m_eKind) { + case SdrHdlKind::LowerRight: nHdlAngle=31500_deg100; break; + case SdrHdlKind::Lower: nHdlAngle=27000_deg100; break; + case SdrHdlKind::LowerLeft: nHdlAngle=22500_deg100; break; + case SdrHdlKind::Left : nHdlAngle=18000_deg100; break; + case SdrHdlKind::UpperLeft: nHdlAngle=13500_deg100; break; + case SdrHdlKind::Upper: nHdlAngle=9000_deg100; break; + case SdrHdlKind::UpperRight: nHdlAngle=4500_deg100; break; + case SdrHdlKind::Right: nHdlAngle=0_deg100; break; + default: + break; + } + // a little bit more (for rounding) + nHdlAngle = NormAngle36000(nHdlAngle + m_nRotationAngle + 2249_deg100); + nHdlAngle/=4500_deg100; + switch (static_cast(nHdlAngle.get())) { + case 0: ePtr=PointerStyle::ESize; break; + case 1: ePtr=PointerStyle::NESize; break; + case 2: ePtr=PointerStyle::NSize; break; + case 3: ePtr=PointerStyle::NWSize; break; + case 4: ePtr=PointerStyle::WSize; break; + case 5: ePtr=PointerStyle::SWSize; break; + case 6: ePtr=PointerStyle::SSize; break; + case 7: ePtr=PointerStyle::SESize; break; + } // switch + } else { + switch (m_eKind) { + case SdrHdlKind::UpperLeft: ePtr=PointerStyle::NWSize; break; + case SdrHdlKind::Upper: ePtr=PointerStyle::NSize; break; + case SdrHdlKind::UpperRight: ePtr=PointerStyle::NESize; break; + case SdrHdlKind::Left : ePtr=PointerStyle::WSize; break; + case SdrHdlKind::Right: ePtr=PointerStyle::ESize; break; + case SdrHdlKind::LowerLeft: ePtr=PointerStyle::SWSize; break; + case SdrHdlKind::Lower: ePtr=PointerStyle::SSize; break; + case SdrHdlKind::LowerRight: ePtr=PointerStyle::SESize; break; + case SdrHdlKind::Poly : ePtr=PointerStyle::MovePoint; break; + case SdrHdlKind::Circle : ePtr=PointerStyle::Hand; break; + case SdrHdlKind::Ref1 : ePtr=PointerStyle::RefHand; break; + case SdrHdlKind::Ref2 : ePtr=PointerStyle::RefHand; break; + case SdrHdlKind::BezierWeight : ePtr=PointerStyle::MoveBezierWeight; break; + case SdrHdlKind::Glue : ePtr=PointerStyle::MovePoint; break; + case SdrHdlKind::CustomShape1 : ePtr=PointerStyle::RefHand; break; + default: + break; + } + } + } + return ePtr; +} + +bool SdrHdl::IsFocusHdl() const +{ + switch(m_eKind) + { + case SdrHdlKind::UpperLeft: + case SdrHdlKind::Upper: + case SdrHdlKind::UpperRight: + case SdrHdlKind::Left: + case SdrHdlKind::Right: + case SdrHdlKind::LowerLeft: + case SdrHdlKind::Lower: + case SdrHdlKind::LowerRight: + { + // if it's an activated TextEdit, it's moved to extended points + return !m_pHdlList || !m_pHdlList->IsMoveOutside(); + } + + case SdrHdlKind::Move: // handle to move object + case SdrHdlKind::Poly: // selected point of polygon or curve + case SdrHdlKind::BezierWeight: // weight at a curve + case SdrHdlKind::Circle: // angle of circle segments, corner radius of rectangles + case SdrHdlKind::Ref1: // reference point 1, e. g. center of rotation + case SdrHdlKind::Ref2: // reference point 2, e. g. endpoint of reflection axis + case SdrHdlKind::Glue: // gluepoint + + // for SJ and the CustomShapeHandles: + case SdrHdlKind::CustomShape1: + + case SdrHdlKind::User: + { + return true; + } + + default: + { + return false; + } + } +} + +void SdrHdl::onMouseEnter(const MouseEvent& /*rMEvt*/) +{ +} + +void SdrHdl::onHelpRequest() +{ +} + +void SdrHdl::onMouseLeave() +{ +} + +BitmapEx SdrHdl::createGluePointBitmap() +{ + return ImpGetBitmapEx(BitmapMarkerKind::Glue_Deselected, BitmapColorIndex::LightGreen); +} + +void SdrHdl::insertNewlyCreatedOverlayObjectForSdrHdl( + std::unique_ptr pOverlayObject, + const sdr::contact::ObjectContact& rObjectContact, + sdr::overlay::OverlayManager& rOverlayManager) +{ + // check if we have an OverlayObject + if(!pOverlayObject) + { + return; + } + + // Add GridOffset for non-linear ViewToDevice transformation (calc) + if(nullptr != GetObj() && rObjectContact.supportsGridOffsets()) + { + basegfx::B2DVector aOffset(0.0, 0.0); + const sdr::contact::ViewObjectContact& rVOC(GetObj()->GetViewContact().GetViewObjectContact( + const_cast(rObjectContact))); + + rObjectContact.calculateGridOffsetForViewObjectContact(aOffset, rVOC); + + if(!aOffset.equalZero()) + { + pOverlayObject->setOffset(aOffset); + } + } + + // add to OverlayManager + rOverlayManager.add(*pOverlayObject); + + // add to local OverlayObjectList - ownership change (!) + maOverlayGroup.append(std::move(pOverlayObject)); +} + +SdrHdlColor::SdrHdlColor(const Point& rRef, Color aCol, const Size& rSize, bool bLum) +: SdrHdl(rRef, SdrHdlKind::Color), + m_aMarkerSize(rSize), + m_bUseLuminance(bLum) +{ + if(IsUseLuminance()) + aCol = GetLuminance(aCol); + + // remember color + m_aMarkerColor = aCol; +} + +SdrHdlColor::~SdrHdlColor() +{ +} + +void SdrHdlColor::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + BitmapEx aBmpCol(CreateColorDropper(m_aMarkerColor)); + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + std::unique_ptr pNewOverlayObject(new + sdr::overlay::OverlayBitmapEx( + aPosition, + aBmpCol, + static_cast(aBmpCol.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpCol.GetSizePixel().Height() - 1) >> 1 + )); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +BitmapEx SdrHdlColor::CreateColorDropper(Color aCol) +{ + // get the Bitmap + VclPtr pWrite(VclPtr::Create()); + pWrite->SetOutputSizePixel(m_aMarkerSize); + pWrite->SetBackground(aCol); + pWrite->Erase(); + + // draw outer border + sal_Int32 nWidth = m_aMarkerSize.Width(); + sal_Int32 nHeight = m_aMarkerSize.Height(); + + pWrite->SetLineColor(COL_LIGHTGRAY); + pWrite->DrawLine(Point(0, 0), Point(0, nHeight - 1)); + pWrite->DrawLine(Point(1, 0), Point(nWidth - 1, 0)); + pWrite->SetLineColor(COL_GRAY); + pWrite->DrawLine(Point(1, nHeight - 1), Point(nWidth - 1, nHeight - 1)); + pWrite->DrawLine(Point(nWidth - 1, 1), Point(nWidth - 1, nHeight - 2)); + + // draw lighter UpperLeft + const Color aLightColor( + static_cast(::std::min(static_cast(static_cast(aCol.GetRed()) + sal_Int16(0x0040)), sal_Int16(0x00ff))), + static_cast(::std::min(static_cast(static_cast(aCol.GetGreen()) + sal_Int16(0x0040)), sal_Int16(0x00ff))), + static_cast(::std::min(static_cast(static_cast(aCol.GetBlue()) + sal_Int16(0x0040)), sal_Int16(0x00ff)))); + pWrite->SetLineColor(aLightColor); + pWrite->DrawLine(Point(1, 1), Point(1, nHeight - 2)); + pWrite->DrawLine(Point(2, 1), Point(nWidth - 2, 1)); + + // draw darker LowerRight + const Color aDarkColor( + static_cast(::std::max(static_cast(static_cast(aCol.GetRed()) - sal_Int16(0x0040)), sal_Int16(0x0000))), + static_cast(::std::max(static_cast(static_cast(aCol.GetGreen()) - sal_Int16(0x0040)), sal_Int16(0x0000))), + static_cast(::std::max(static_cast(static_cast(aCol.GetBlue()) - sal_Int16(0x0040)), sal_Int16(0x0000)))); + pWrite->SetLineColor(aDarkColor); + pWrite->DrawLine(Point(2, nHeight - 2), Point(nWidth - 2, nHeight - 2)); + pWrite->DrawLine(Point(nWidth - 2, 2), Point(nWidth - 2, nHeight - 3)); + + return pWrite->GetBitmapEx(Point(0,0), m_aMarkerSize); +} + +Color SdrHdlColor::GetLuminance(const Color& rCol) +{ + sal_uInt8 aLum = rCol.GetLuminance(); + Color aRetval(aLum, aLum, aLum); + return aRetval; +} + +void SdrHdlColor::SetColor(Color aNew, bool bCallLink) +{ + if(IsUseLuminance()) + aNew = GetLuminance(aNew); + + if(m_aMarkerColor != aNew) + { + // remember new color + m_aMarkerColor = aNew; + + // create new display + Touch(); + + // tell about change + if(bCallLink) + m_aColorChangeHdl.Call(this); + } +} + +void SdrHdlColor::SetSize(const Size& rNew) +{ + if(rNew != m_aMarkerSize) + { + // remember new size + m_aMarkerSize = rNew; + + // create new display + Touch(); + } +} + +SdrHdlGradient::SdrHdlGradient(const Point& rRef1, const Point& rRef2, bool bGrad) + : SdrHdl(rRef1, bGrad ? SdrHdlKind::Gradient : SdrHdlKind::Transparence) + , m_pColHdl1(nullptr) + , m_pColHdl2(nullptr) + , m_a2ndPos(rRef2) + , m_bGradient(bGrad) + , m_bMoveSingleHandle(false) + , m_bMoveFirstHandle(false) +{ +} + +SdrHdlGradient::~SdrHdlGradient() +{ +} + +void SdrHdlGradient::Set2ndPos(const Point& rPnt) +{ + if(m_a2ndPos != rPnt) + { + // remember new position + m_a2ndPos = rPnt; + + // create new display + Touch(); + } +} + +void SdrHdlGradient::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + // striped line in between + basegfx::B2DVector aVec(m_a2ndPos.X() - m_aPos.X(), m_a2ndPos.Y() - m_aPos.Y()); + double fVecLen = aVec.getLength(); + double fLongPercentArrow = (1.0 - 0.05) * fVecLen; + double fHalfArrowWidth = (0.05 * 0.5) * fVecLen; + aVec.normalize(); + basegfx::B2DVector aPerpend(-aVec.getY(), aVec.getX()); + sal_Int32 nMidX = static_cast(m_aPos.X() + aVec.getX() * fLongPercentArrow); + sal_Int32 nMidY = static_cast(m_aPos.Y() + aVec.getY() * fLongPercentArrow); + Point aMidPoint(nMidX, nMidY); + + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + basegfx::B2DPoint aMidPos(aMidPoint.X(), aMidPoint.Y()); + + std::unique_ptr pNewOverlayObject(new + sdr::overlay::OverlayLineStriped( + aPosition, aMidPos + )); + + pNewOverlayObject->setBaseColor(IsGradient() ? COL_BLACK : COL_BLUE); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + + // arrowhead + Point aLeft(aMidPoint.X() + static_cast(aPerpend.getX() * fHalfArrowWidth), + aMidPoint.Y() + static_cast(aPerpend.getY() * fHalfArrowWidth)); + Point aRight(aMidPoint.X() - static_cast(aPerpend.getX() * fHalfArrowWidth), + aMidPoint.Y() - static_cast(aPerpend.getY() * fHalfArrowWidth)); + + basegfx::B2DPoint aPositionLeft(aLeft.X(), aLeft.Y()); + basegfx::B2DPoint aPositionRight(aRight.X(), aRight.Y()); + basegfx::B2DPoint aPosition2(m_a2ndPos.X(), m_a2ndPos.Y()); + + pNewOverlayObject.reset(new + sdr::overlay::OverlayTriangle( + aPositionLeft, + aPosition2, + aPositionRight, + IsGradient() ? COL_BLACK : COL_BLUE + )); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +IMPL_LINK_NOARG(SdrHdlGradient, ColorChangeHdl, SdrHdlColor*, void) +{ + if(GetObj()) + FromIAOToItem(GetObj(), true, true); +} + +void SdrHdlGradient::FromIAOToItem(SdrObject* _pObj, bool bSetItemOnObject, bool bUndo) +{ + // from IAO positions and colors to gradient + const SfxItemSet& rSet = _pObj->GetMergedItemSet(); + + GradTransGradient aOldGradTransGradient; + GradTransGradient aGradTransGradient; + GradTransVector aGradTransVector; + + aGradTransVector.maPositionA = basegfx::B2DPoint(GetPos().X(), GetPos().Y()); + aGradTransVector.maPositionB = basegfx::B2DPoint(Get2ndPos().X(), Get2ndPos().Y()); + if(m_pColHdl1) + aGradTransVector.aCol1 = m_pColHdl1->GetColor(); + if(m_pColHdl2) + aGradTransVector.aCol2 = m_pColHdl2->GetColor(); + + if(IsGradient()) + aOldGradTransGradient.aGradient = rSet.Get(XATTR_FILLGRADIENT).GetGradientValue(); + else + aOldGradTransGradient.aGradient = rSet.Get(XATTR_FILLFLOATTRANSPARENCE).GetGradientValue(); + + // transform vector data to gradient + GradTransformer::VecToGrad(aGradTransVector, aGradTransGradient, aOldGradTransGradient, _pObj, m_bMoveSingleHandle, m_bMoveFirstHandle); + + if(bSetItemOnObject) + { + SdrModel& rModel(_pObj->getSdrModelFromSdrObject()); + SfxItemSet aNewSet(rModel.GetItemPool()); + const OUString aString; + + if(IsGradient()) + { + XFillGradientItem aNewGradItem(aString, aGradTransGradient.aGradient); + aNewSet.Put(aNewGradItem); + } + else + { + XFillFloatTransparenceItem aNewTransItem(aString, aGradTransGradient.aGradient); + aNewSet.Put(aNewTransItem); + } + + if(bUndo && rModel.IsUndoEnabled()) + { + rModel.BegUndo(SvxResId(IsGradient() ? SIP_XA_FILLGRADIENT : SIP_XA_FILLTRANSPARENCE)); + rModel.AddUndo(rModel.GetSdrUndoFactory().CreateUndoAttrObject(*_pObj)); + rModel.EndUndo(); + } + + m_pObj->SetMergedItemSetAndBroadcast(aNewSet); + } + + // back transformation, set values on pIAOHandle + GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, _pObj); + + SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY()))); + Set2ndPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY()))); + if(m_pColHdl1) + { + m_pColHdl1->SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY()))); + m_pColHdl1->SetColor(aGradTransVector.aCol1); + } + if(m_pColHdl2) + { + m_pColHdl2->SetPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY()))); + m_pColHdl2->SetColor(aGradTransVector.aCol2); + } +} + + +SdrHdlLine::~SdrHdlLine() {} + +void SdrHdlLine::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!(pView && !pView->areMarkHandlesHidden() && m_pHdl1 && m_pHdl2)) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition1(m_pHdl1->GetPos().X(), m_pHdl1->GetPos().Y()); + basegfx::B2DPoint aPosition2(m_pHdl2->GetPos().X(), m_pHdl2->GetPos().Y()); + + std::unique_ptr pNewOverlayObject(new + sdr::overlay::OverlayLineStriped( + aPosition1, + aPosition2 + )); + + // color(?) + pNewOverlayObject->setBaseColor(COL_LIGHTRED); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +PointerStyle SdrHdlLine::GetPointer() const +{ + return PointerStyle::RefHand; +} + + +SdrHdlBezWgt::~SdrHdlBezWgt() {} + +void SdrHdlBezWgt::CreateB2dIAObject() +{ + // call parent + SdrHdl::CreateB2dIAObject(); + + // create lines + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition1(m_pHdl1->GetPos().X(), m_pHdl1->GetPos().Y()); + basegfx::B2DPoint aPosition2(m_aPos.X(), m_aPos.Y()); + + if(!aPosition1.equal(aPosition2)) + { + std::unique_ptr pNewOverlayObject(new + sdr::overlay::OverlayLineStriped( + aPosition1, + aPosition2 + )); + + // line part is not hittable + pNewOverlayObject->setHittable(false); + + // color(?) + pNewOverlayObject->setBaseColor(COL_LIGHTBLUE); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } + } +} + + +E3dVolumeMarker::E3dVolumeMarker(const basegfx::B2DPolyPolygon& rWireframePoly) +{ + m_aWireframePoly = rWireframePoly; +} + +void E3dVolumeMarker::CreateB2dIAObject() +{ + // create lines + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is() && m_aWireframePoly.count()) + { + std::unique_ptr pNewOverlayObject(new + sdr::overlay::OverlayPolyPolygonStripedAndFilled( + m_aWireframePoly)); + + pNewOverlayObject->setBaseColor(COL_BLACK); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + + +ImpEdgeHdl::~ImpEdgeHdl() +{ +} + +void ImpEdgeHdl::CreateB2dIAObject() +{ + if(m_nObjHdlNum <= 1 && m_pObj) + { + // first throw away old one + GetRidOfIAObject(); + + BitmapColorIndex eColIndex = BitmapColorIndex::LightCyan; + BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_7x7; + + if(m_pHdlList) + { + SdrMarkView* pView = m_pHdlList->GetView(); + + if(pView && !pView->areMarkHandlesHidden()) + { + const SdrEdgeObj* pEdge = static_cast(m_pObj); + + if(pEdge->GetConnectedNode(m_nObjHdlNum == 0) != nullptr) + eColIndex = BitmapColorIndex::LightRed; + + if(m_nPPntNum < 2) + { + // Handle with plus sign inside + eKindOfMarker = BitmapMarkerKind::Circ_7x7; + } + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(pPageView) + { + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + std::unique_ptr pNewOverlayObject(CreateOverlayObject( + aPosition, + eColIndex, + eKindOfMarker)); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } + } + } + } + } + else + { + // call parent + SdrHdl::CreateB2dIAObject(); + } +} + +void ImpEdgeHdl::SetLineCode(SdrEdgeLineCode eCode) +{ + if(m_eLineCode != eCode) + { + // remember new value + m_eLineCode = eCode; + + // create new display + Touch(); + } +} + +PointerStyle ImpEdgeHdl::GetPointer() const +{ + SdrEdgeObj* pEdge=dynamic_cast( m_pObj ); + if (pEdge==nullptr) + return SdrHdl::GetPointer(); + if (m_nObjHdlNum<=1) + return PointerStyle::MovePoint; + if (IsHorzDrag()) + return PointerStyle::ESize; + else + return PointerStyle::SSize; +} + +bool ImpEdgeHdl::IsHorzDrag() const +{ + SdrEdgeObj* pEdge=dynamic_cast( m_pObj ); + if (pEdge==nullptr) + return false; + if (m_nObjHdlNum<=1) + return false; + + SdrEdgeKind eEdgeKind = pEdge->GetObjectItem(SDRATTR_EDGEKIND).GetValue(); + + const SdrEdgeInfoRec& rInfo=pEdge->m_aEdgeInfo; + if (eEdgeKind==SdrEdgeKind::OrthoLines || eEdgeKind==SdrEdgeKind::Bezier) + { + return !rInfo.ImpIsHorzLine(m_eLineCode,*pEdge->m_pEdgeTrack); + } + else if (eEdgeKind==SdrEdgeKind::ThreeLines) + { + tools::Long nAngle=m_nObjHdlNum==2 ? rInfo.m_nAngle1 : rInfo.m_nAngle2; + return nAngle==0 || nAngle==18000; + } + return false; +} + + +ImpMeasureHdl::~ImpMeasureHdl() +{ +} + +void ImpMeasureHdl::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + BitmapColorIndex eColIndex = BitmapColorIndex::LightCyan; + BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_9x9; + + if(m_nObjHdlNum > 1) + { + eKindOfMarker = BitmapMarkerKind::Rect_7x7; + } + + if(m_bSelect) + { + eColIndex = BitmapColorIndex::Cyan; + } + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + std::unique_ptr pNewOverlayObject(CreateOverlayObject( + aPosition, + eColIndex, + eKindOfMarker)); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +PointerStyle ImpMeasureHdl::GetPointer() const +{ + switch (m_nObjHdlNum) + { + case 0: case 1: return PointerStyle::Hand; + case 2: case 3: return PointerStyle::MovePoint; + case 4: case 5: return SdrHdl::GetPointer(); // will then be rotated appropriately + } // switch + return PointerStyle::NotAllowed; +} + + +ImpTextframeHdl::ImpTextframeHdl(const tools::Rectangle& rRect) : + SdrHdl(rRect.TopLeft(),SdrHdlKind::Move), + maRect(rRect) +{ +} + +void ImpTextframeHdl::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + if(!m_pHdlList) + return; + + SdrMarkView* pView = m_pHdlList->GetView(); + + if(!pView || pView->areMarkHandlesHidden()) + return; + + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + const basegfx::B2DPoint aTopLeft(maRect.Left(), maRect.Top()); + const basegfx::B2DPoint aBottomRight(maRect.Right(), maRect.Bottom()); + const Color aHilightColor(SvtOptionsDrawinglayer::getHilightColor()); + const double fTransparence(SvtOptionsDrawinglayer::GetTransparentSelectionPercent() * 0.01); + + std::unique_ptr pNewOverlayObject(new sdr::overlay::OverlayRectangle( + aTopLeft, + aBottomRight, + aHilightColor, + fTransparence, + 3.0, + 3.0, + -toRadians(m_nRotationAngle), + true)); // allow animation; the Handle is not shown at text edit time + + pNewOverlayObject->setHittable(false); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNewOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + + +static bool ImpSdrHdlListSorter(std::unique_ptr const& lhs, std::unique_ptr const& rhs) +{ + SdrHdlKind eKind1=lhs->GetKind(); + SdrHdlKind eKind2=rhs->GetKind(); + // Level 1: first normal handles, then Glue, then User, then Plus handles, then reference point handles + unsigned n1=1; + unsigned n2=1; + if (eKind1!=eKind2) + { + if (eKind1==SdrHdlKind::Ref1 || eKind1==SdrHdlKind::Ref2 || eKind1==SdrHdlKind::MirrorAxis) n1=5; + else if (eKind1==SdrHdlKind::Glue) n1=2; + else if (eKind1==SdrHdlKind::User) n1=3; + else if (eKind1==SdrHdlKind::SmartTag) n1=0; + if (eKind2==SdrHdlKind::Ref1 || eKind2==SdrHdlKind::Ref2 || eKind2==SdrHdlKind::MirrorAxis) n2=5; + else if (eKind2==SdrHdlKind::Glue) n2=2; + else if (eKind2==SdrHdlKind::User) n2=3; + else if (eKind2==SdrHdlKind::SmartTag) n2=0; + } + if (lhs->IsPlusHdl()) n1=4; + if (rhs->IsPlusHdl()) n2=4; + if (n1==n2) + { + // Level 2: PageView (Pointer) + SdrPageView* pPV1=lhs->GetPageView(); + SdrPageView* pPV2=rhs->GetPageView(); + if (pPV1==pPV2) + { + // Level 3: Position (x+y) + SdrObject* pObj1=lhs->GetObj(); + SdrObject* pObj2=rhs->GetObj(); + if (pObj1==pObj2) + { + sal_uInt32 nNum1=lhs->GetObjHdlNum(); + sal_uInt32 nNum2=rhs->GetObjHdlNum(); + if (nNum1==nNum2) + { + if (eKind1==eKind2) + return lhs(eKind1)(eKind2); + } + else + return nNum1(pVoid1); + const ImplHdlAndIndex* p2 = static_cast(pVoid2); + + if(p1->mpHdl->GetObj() == p2->mpHdl->GetObj()) + { + if(p1->mpHdl->GetObj() && dynamic_cast(p1->mpHdl->GetObj()) != nullptr) + { + // same object and a path object + if((p1->mpHdl->GetKind() == SdrHdlKind::Poly || p1->mpHdl->GetKind() == SdrHdlKind::BezierWeight) + && (p2->mpHdl->GetKind() == SdrHdlKind::Poly || p2->mpHdl->GetKind() == SdrHdlKind::BezierWeight)) + { + // both handles are point or control handles + if(p1->mpHdl->GetPolyNum() == p2->mpHdl->GetPolyNum()) + { + if(p1->mpHdl->GetPointNum() < p2->mpHdl->GetPointNum()) + { + return -1; + } + else + { + return 1; + } + } + else if(p1->mpHdl->GetPolyNum() < p2->mpHdl->GetPolyNum()) + { + return -1; + } + else + { + return 1; + } + } + } + } + else + { + if(!p1->mpHdl->GetObj()) + { + return -1; + } + else if(!p2->mpHdl->GetObj()) + { + return 1; + } + else + { + // different objects, use OrdNum for sort + const sal_uInt32 nOrdNum1 = p1->mpHdl->GetObj()->GetOrdNum(); + const sal_uInt32 nOrdNum2 = p2->mpHdl->GetObj()->GetOrdNum(); + + if(nOrdNum1 < nOrdNum2) + { + return -1; + } + else + { + return 1; + } + } + } + + // fallback to indices + if(p1->mnIndex < p2->mnIndex) + { + return -1; + } + else + { + return 1; + } +} + +} + +void SdrHdlList::TravelFocusHdl(bool bForward) +{ + // security correction + if (mnFocusIndex >= GetHdlCount()) + mnFocusIndex = SAL_MAX_SIZE; + + if(maList.empty()) + return; + + // take care of old handle + const size_t nOldHdlNum(mnFocusIndex); + SdrHdl* pOld = nullptr; + if (nOldHdlNum < GetHdlCount()) + pOld = GetHdl(nOldHdlNum); + + if(pOld) + { + // switch off old handle + mnFocusIndex = SAL_MAX_SIZE; + pOld->Touch(); + } + + // allocate pointer array for sorted handle list + std::unique_ptr pHdlAndIndex(new ImplHdlAndIndex[maList.size()]); + + // build sorted handle list + for( size_t a = 0; a < maList.size(); ++a) + { + pHdlAndIndex[a].mpHdl = maList[a].get(); + pHdlAndIndex[a].mnIndex = a; + } + + qsort(pHdlAndIndex.get(), maList.size(), sizeof(ImplHdlAndIndex), ImplSortHdlFunc); + + // look for old num in sorted array + size_t nOldHdl(nOldHdlNum); + + if(nOldHdlNum != SAL_MAX_SIZE) + { + for(size_t a = 0; a < maList.size(); ++a) + { + if(pHdlAndIndex[a].mpHdl == pOld) + { + nOldHdl = a; + break; + } + } + } + + // build new HdlNum + size_t nNewHdl(nOldHdl); + + // do the focus travel + if(bForward) + { + if(nOldHdl != SAL_MAX_SIZE) + { + if(nOldHdl == maList.size() - 1) + { + // end forward run + nNewHdl = SAL_MAX_SIZE; + } + else + { + // simply the next handle + nNewHdl++; + } + } + else + { + // start forward run at first entry + nNewHdl = 0; + } + } + else + { + if(nOldHdl == SAL_MAX_SIZE) + { + // start backward run at last entry + nNewHdl = maList.size() - 1; + + } + else + { + if(nOldHdl == 0) + { + // end backward run + nNewHdl = SAL_MAX_SIZE; + } + else + { + // simply the previous handle + nNewHdl--; + } + } + } + + // build new HdlNum + sal_uIntPtr nNewHdlNum(nNewHdl); + + // look for old num in sorted array + if(nNewHdl != SAL_MAX_SIZE) + { + SdrHdl* pNew = pHdlAndIndex[nNewHdl].mpHdl; + + for(size_t a = 0; a < maList.size(); ++a) + { + if(maList[a].get() == pNew) + { + nNewHdlNum = a; + break; + } + } + } + + // take care of next handle + if(nOldHdlNum != nNewHdlNum) + { + mnFocusIndex = nNewHdlNum; + if (mnFocusIndex < GetHdlCount()) + { + SdrHdl* pNew = GetHdl(mnFocusIndex); + pNew->Touch(); + } + } +} + +SdrHdl* SdrHdlList::GetFocusHdl() const +{ + if(mnFocusIndex < GetHdlCount()) + return GetHdl(mnFocusIndex); + else + return nullptr; +} + +void SdrHdlList::SetFocusHdl(SdrHdl* pNew) +{ + if(!pNew) + return; + + SdrHdl* pActual = GetFocusHdl(); + + if(pActual && pActual == pNew) + return; + + const size_t nNewHdlNum = GetHdlNum(pNew); + + if(nNewHdlNum != SAL_MAX_SIZE) + { + mnFocusIndex = nNewHdlNum; + + if(pActual) + { + pActual->Touch(); + } + + pNew->Touch(); + } +} + +void SdrHdlList::ResetFocusHdl() +{ + SdrHdl* pHdl = GetFocusHdl(); + + mnFocusIndex = SAL_MAX_SIZE; + + if(pHdl) + { + pHdl->Touch(); + } +} + + +SdrHdlList::SdrHdlList(SdrMarkView* pV) +: mnFocusIndex(SAL_MAX_SIZE), + m_pView(pV) +{ + m_nHdlSize = 3; + m_bRotateShear = false; + m_bMoveOutside = false; + m_bDistortShear = false; +} + +SdrHdlList::~SdrHdlList() +{ + Clear(); +} + +void SdrHdlList::SetHdlSize(sal_uInt16 nSiz) +{ + if(m_nHdlSize != nSiz) + { + // remember new value + m_nHdlSize = nSiz; + + // propagate change to IAOs + for(size_t i=0; iTouch(); + } + } +} + +void SdrHdlList::SetMoveOutside(bool bOn) +{ + if(m_bMoveOutside != bOn) + { + // remember new value + m_bMoveOutside = bOn; + + // propagate change to IAOs + for(size_t i=0; iTouch(); + } + } +} + +void SdrHdlList::SetRotateShear(bool bOn) +{ + m_bRotateShear = bOn; +} + +void SdrHdlList::SetDistortShear(bool bOn) +{ + m_bDistortShear = bOn; +} + +std::unique_ptr SdrHdlList::RemoveHdl(size_t nNum) +{ + std::unique_ptr pRetval = std::move(maList[nNum]); + maList.erase(maList.begin() + nNum); + + return pRetval; +} + +void SdrHdlList::RemoveAllByKind(SdrHdlKind eKind) +{ + std::erase_if(maList, [&eKind](std::unique_ptr& rItem) { return rItem->GetKind() == eKind; }); +} + +void SdrHdlList::Clear() +{ + maList.clear(); + + m_bRotateShear=false; + m_bDistortShear=false; +} + +void SdrHdlList::Sort() +{ + // remember currently focused handle + SdrHdl* pPrev = GetFocusHdl(); + + std::sort( maList.begin(), maList.end(), ImpSdrHdlListSorter ); + + // get now and compare + SdrHdl* pNow = GetFocusHdl(); + + if(pPrev == pNow) + return; + + if(pPrev) + { + pPrev->Touch(); + } + + if(pNow) + { + pNow->Touch(); + } +} + +size_t SdrHdlList::GetHdlNum(const SdrHdl* pHdl) const +{ + if (pHdl==nullptr) + return SAL_MAX_SIZE; + auto it = std::find_if( maList.begin(), maList.end(), + [&](const std::unique_ptr & p) { return p.get() == pHdl; }); + assert(it != maList.end()); + if( it == maList.end() ) + return SAL_MAX_SIZE; + return it - maList.begin(); +} + +void SdrHdlList::AddHdl(std::unique_ptr pHdl) +{ + assert(pHdl); + pHdl->SetHdlList(this); + maList.push_back(std::move(pHdl)); +} + +SdrHdl* SdrHdlList::IsHdlListHit(const Point& rPnt) const +{ + SdrHdl* pRet=nullptr; + const size_t nCount=GetHdlCount(); + size_t nNum=nCount; + while (nNum>0 && pRet==nullptr) + { + nNum--; + SdrHdl* pHdl=GetHdl(nNum); + if (pHdl->IsHdlHit(rPnt)) + pRet=pHdl; + } + return pRet; +} + +SdrHdl* SdrHdlList::GetHdl(SdrHdlKind eKind1) const +{ + SdrHdl* pRet=nullptr; + for (size_t i=0; iGetKind()==eKind1) + pRet=pHdl; + } + return pRet; +} + +void SdrHdlList::MoveTo(SdrHdlList& rOther) +{ + for (auto & pHdl : maList) + pHdl->SetHdlList(&rOther); + rOther.maList.insert(rOther.maList.end(), + std::make_move_iterator(maList.begin()), std::make_move_iterator(maList.end())); + maList.clear(); +} + +SdrCropHdl::SdrCropHdl( + const Point& rPnt, + SdrHdlKind eNewKind, + double fShearX, + double fRotation) +: SdrHdl(rPnt, eNewKind), + mfShearX(fShearX), + mfRotation(fRotation) +{ +} + + +BitmapEx SdrCropHdl::GetBitmapForHandle( const BitmapEx& rBitmap, int nSize ) +{ + int nPixelSize = 0, nX = 0, nY = 0, nOffset = 0; + + if( nSize <= 3 ) + { + nPixelSize = 13; + nOffset = 0; + } + else if( nSize <=4 ) + { + nPixelSize = 17; + nOffset = 39; + } + else + { + nPixelSize = 21; + nOffset = 90; + } + + switch( m_eKind ) + { + case SdrHdlKind::UpperLeft: nX = 0; nY = 0; break; + case SdrHdlKind::Upper: nX = 1; nY = 0; break; + case SdrHdlKind::UpperRight: nX = 2; nY = 0; break; + case SdrHdlKind::Left: nX = 0; nY = 1; break; + case SdrHdlKind::Right: nX = 2; nY = 1; break; + case SdrHdlKind::LowerLeft: nX = 0; nY = 2; break; + case SdrHdlKind::Lower: nX = 1; nY = 2; break; + case SdrHdlKind::LowerRight: nX = 2; nY = 2; break; + default: break; + } + + tools::Rectangle aSourceRect( Point( nX * nPixelSize + nOffset, nY * nPixelSize), Size(nPixelSize, nPixelSize) ); + + BitmapEx aRetval(rBitmap); + aRetval.Crop(aSourceRect); + return aRetval; +} + + +void SdrCropHdl::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + SdrMarkView* pView = m_pHdlList ? m_pHdlList->GetView() : nullptr; + SdrPageView* pPageView = pView ? pView->GetSdrPageView() : nullptr; + + if( !pPageView || pView->areMarkHandlesHidden() ) + return; + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + int nHdlSize = m_pHdlList->GetHdlSize(); + + const BitmapEx aHandlesBitmap(SIP_SA_CROP_MARKERS); + BitmapEx aBmpEx1( GetBitmapForHandle( aHandlesBitmap, nHdlSize ) ); + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if (xManager.is()) + { + basegfx::B2DPoint aPosition(m_aPos.X(), m_aPos.Y()); + + std::unique_ptr pOverlayObject; + + // animate focused handles + if(IsFocusHdl() && (m_pHdlList->GetFocusHdl() == this)) + { + if( nHdlSize >= 2 ) + nHdlSize = 1; + + BitmapEx aBmpEx2( GetBitmapForHandle( aHandlesBitmap, nHdlSize + 1 ) ); + + const sal_uInt64 nBlinkTime = rStyleSettings.GetCursorBlinkTime(); + + pOverlayObject.reset(new sdr::overlay::OverlayAnimatedBitmapEx( + aPosition, + aBmpEx1, + aBmpEx2, + nBlinkTime, + static_cast(aBmpEx1.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpEx1.GetSizePixel().Height() - 1) >> 1, + static_cast(aBmpEx2.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpEx2.GetSizePixel().Height() - 1) >> 1, + mfShearX, + mfRotation)); + } + else + { + // create centered handle as default + pOverlayObject.reset(new sdr::overlay::OverlayBitmapEx( + aPosition, + aBmpEx1, + static_cast(aBmpEx1.GetSizePixel().Width() - 1) >> 1, + static_cast(aBmpEx1.GetSizePixel().Height() - 1) >> 1, + 0.0, + mfShearX, + mfRotation)); + } + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pOverlayObject), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + + +// with the correction of crop handling I could get rid of the extra mirroring flag, adapted stuff +// accordingly + +SdrCropViewHdl::SdrCropViewHdl( + basegfx::B2DHomMatrix aObjectTransform, + Graphic aGraphic, + double fCropLeft, + double fCropTop, + double fCropRight, + double fCropBottom) +: SdrHdl(Point(), SdrHdlKind::User), + maObjectTransform(std::move(aObjectTransform)), + maGraphic(std::move(aGraphic)), + mfCropLeft(fCropLeft), + mfCropTop(fCropTop), + mfCropRight(fCropRight), + mfCropBottom(fCropBottom) +{ +} + +namespace { + +void translateRotationToMirroring(basegfx::B2DVector & scale, double * rotate) { + assert(rotate != nullptr); + + // detect 180 degree rotation, this is the same as mirrored in X and Y, + // thus change to mirroring. Prefer mirroring here. Use the equal call + // with getSmallValue here, the original which uses rtl::math::approxEqual + // is too correct here. Maybe this changes with enhanced precision in aw080 + // to the better so that this can be reduced to the more precise call again + if(basegfx::fTools::equal(fabs(*rotate), M_PI, 0.000000001)) + { + scale.setX(scale.getX() * -1.0); + scale.setY(scale.getY() * -1.0); + *rotate = 0.0; + } +} + +} + +void SdrCropViewHdl::CreateB2dIAObject() +{ + GetRidOfIAObject(); + SdrMarkView* pView = m_pHdlList ? m_pHdlList->GetView() : nullptr; + SdrPageView* pPageView = pView ? pView->GetSdrPageView() : nullptr; + + if(!pPageView || pView->areMarkHandlesHidden()) + { + return; + } + + // decompose to have current translate and scale + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + + maObjectTransform.decompose(aScale, aTranslate, fRotate, fShearX); + + if(aScale.equalZero()) + { + return; + } + + translateRotationToMirroring(aScale, &fRotate); + + // remember mirroring, reset at Scale and adapt crop values for usage; + // mirroring can stay in the object transformation, so do not have to + // cope with it here (except later for the CroppedImage transformation, + // see below) + const bool bMirroredX(aScale.getX() < 0.0); + const bool bMirroredY(aScale.getY() < 0.0); + double fCropLeft(mfCropLeft); + double fCropTop(mfCropTop); + double fCropRight(mfCropRight); + double fCropBottom(mfCropBottom); + + if(bMirroredX) + { + aScale.setX(-aScale.getX()); + } + + if(bMirroredY) + { + aScale.setY(-aScale.getY()); + } + + // create target translate and scale + const basegfx::B2DVector aTargetScale( + aScale.getX() + fCropRight + fCropLeft, + aScale.getY() + fCropBottom + fCropTop); + const basegfx::B2DVector aTargetTranslate( + aTranslate.getX() - fCropLeft, + aTranslate.getY() - fCropTop); + + // create ranges to make comparisons + const basegfx::B2DRange aCurrentForCompare( + aTranslate.getX(), aTranslate.getY(), + aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY()); + basegfx::B2DRange aCropped( + aTargetTranslate.getX(), aTargetTranslate.getY(), + aTargetTranslate.getX() + aTargetScale.getX(), aTargetTranslate.getY() + aTargetScale.getY()); + + if(aCropped.isEmpty()) + { + // nothing to return since cropped content is completely empty + return; + } + + if(aCurrentForCompare.equal(aCropped)) + { + // no crop at all + return; + } + + // back-transform to have values in unit coordinates + basegfx::B2DHomMatrix aBackToUnit; + aBackToUnit.translate(-aTranslate.getX(), -aTranslate.getY()); + aBackToUnit.scale( + basegfx::fTools::equalZero(aScale.getX()) ? 1.0 : 1.0 / aScale.getX(), + basegfx::fTools::equalZero(aScale.getY()) ? 1.0 : 1.0 / aScale.getY()); + + // transform cropped back to unit coordinates + aCropped.transform(aBackToUnit); + + // prepare crop PolyPolygon + basegfx::B2DPolygon aGraphicOutlinePolygon( + basegfx::utils::createPolygonFromRect( + aCropped)); + basegfx::B2DPolyPolygon aCropPolyPolygon(aGraphicOutlinePolygon); + + // current range is unit range + basegfx::B2DRange aOverlap(0.0, 0.0, 1.0, 1.0); + + aOverlap.intersect(aCropped); + + if(!aOverlap.isEmpty()) + { + aCropPolyPolygon.append( + basegfx::utils::createPolygonFromRect( + aOverlap)); + } + + // transform to object coordinates to prepare for clip + aCropPolyPolygon.transform(maObjectTransform); + aGraphicOutlinePolygon.transform(maObjectTransform); + + // create cropped transformation + basegfx::B2DHomMatrix aCroppedTransform; + + aCroppedTransform.scale( + aCropped.getWidth(), + aCropped.getHeight()); + aCroppedTransform.translate( + aCropped.getMinX(), + aCropped.getMinY()); + aCroppedTransform = maObjectTransform * aCroppedTransform; + + // prepare graphic primitive (transformed) + const drawinglayer::primitive2d::Primitive2DReference aGraphic( + new drawinglayer::primitive2d::GraphicPrimitive2D( + aCroppedTransform, + maGraphic)); + + // prepare outline polygon for whole graphic + const basegfx::BColor aHilightColor(SvtOptionsDrawinglayer::getHilightColor().getBColor()); + const drawinglayer::primitive2d::Primitive2DReference aGraphicOutline( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( + std::move(aGraphicOutlinePolygon), + aHilightColor)); + + // combine these + drawinglayer::primitive2d::Primitive2DContainer aCombination(2); + aCombination[0] = aGraphic; + aCombination[1] = aGraphicOutline; + + // embed to MaskPrimitive2D + const drawinglayer::primitive2d::Primitive2DReference aMaskedGraphic( + new drawinglayer::primitive2d::MaskPrimitive2D( + std::move(aCropPolyPolygon), + std::move(aCombination))); + + // embed to UnifiedTransparencePrimitive2D + const drawinglayer::primitive2d::Primitive2DReference aTransparenceMaskedGraphic( + new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( + drawinglayer::primitive2d::Primitive2DContainer { aMaskedGraphic }, + 0.8)); + + const drawinglayer::primitive2d::Primitive2DContainer aSequence { aTransparenceMaskedGraphic }; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b]; + const SdrPageWindow& rPageWindow = *(pPageView->GetPageWindow(b)); + + if(rPageWindow.GetPaintWindow().OutputToWindow()) + { + const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager(); + if(xManager.is()) + { + std::unique_ptr pNew(new sdr::overlay::OverlayPrimitive2DSequenceObject(drawinglayer::primitive2d::Primitive2DContainer(aSequence))); + + // only informative object, no hit + pNew->setHittable(false); + + // OVERLAYMANAGER + insertNewlyCreatedOverlayObjectForSdrHdl( + std::move(pNew), + rPageWindow.GetObjectContact(), + *xManager); + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdhlpln.cxx b/svx/source/svdraw/svdhlpln.cxx new file mode 100644 index 0000000000..0d515191ed --- /dev/null +++ b/svx/source/svdraw/svdhlpln.cxx @@ -0,0 +1,109 @@ +/* -*- 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 + +#include +#include + + +PointerStyle SdrHelpLine::GetPointer() const +{ + switch (eKind) { + case SdrHelpLineKind::Vertical : return PointerStyle::ESize; + case SdrHelpLineKind::Horizontal: return PointerStyle::SSize; + default : return PointerStyle::Move; + } // switch +} + +bool SdrHelpLine::IsHit(const Point& rPnt, sal_uInt16 nTolLog, const OutputDevice& rOut) const +{ + Size a1Pix(rOut.PixelToLogic(Size(1,1))); + bool bXHit=rPnt.X()>=aPos.X()-nTolLog && rPnt.X()<=aPos.X()+nTolLog+a1Pix.Width(); + bool bYHit=rPnt.Y()>=aPos.Y()-nTolLog && rPnt.Y()<=aPos.Y()+nTolLog+a1Pix.Height(); + switch (eKind) { + case SdrHelpLineKind::Vertical : return bXHit; + case SdrHelpLineKind::Horizontal: return bYHit; + case SdrHelpLineKind::Point: { + if (bXHit || bYHit) { + Size aRad(rOut.PixelToLogic(Size(SDRHELPLINE_POINT_PIXELSIZE,SDRHELPLINE_POINT_PIXELSIZE))); + return rPnt.X()>=aPos.X()-aRad.Width() && rPnt.X()<=aPos.X()+aRad.Width()+a1Pix.Width() && + rPnt.Y()>=aPos.Y()-aRad.Height() && rPnt.Y()<=aPos.Y()+aRad.Height()+a1Pix.Height(); + } + } break; + } // switch + return false; +} + +tools::Rectangle SdrHelpLine::GetBoundRect(const OutputDevice& rOut) const +{ + tools::Rectangle aRet(aPos,aPos); + Point aOfs(rOut.GetMapMode().GetOrigin()); + Size aSiz(rOut.GetOutputSize()); + switch (eKind) { + case SdrHelpLineKind::Vertical : aRet.SetTop(-aOfs.Y() ); aRet.SetBottom(-aOfs.Y()+aSiz.Height() ); break; + case SdrHelpLineKind::Horizontal: aRet.SetLeft(-aOfs.X() ); aRet.SetRight(-aOfs.X()+aSiz.Width() ); break; + case SdrHelpLineKind::Point : { + Size aRad(rOut.PixelToLogic(Size(SDRHELPLINE_POINT_PIXELSIZE,SDRHELPLINE_POINT_PIXELSIZE))); + aRet.AdjustLeft( -(aRad.Width()) ); + aRet.AdjustRight(aRad.Width() ); + aRet.AdjustTop( -(aRad.Height()) ); + aRet.AdjustBottom(aRad.Height() ); + } break; + } // switch + return aRet; +} + +SdrHelpLineList& SdrHelpLineList::operator=(const SdrHelpLineList& rSrcList) +{ + aList.clear(); + sal_uInt16 nCount=rSrcList.GetCount(); + for (sal_uInt16 i=0; i0;) { + i--; + if (aList[i]->IsHit(rPnt,nTolLog,rOut)) return i; + } + return SDRHELPLINE_NOTFOUND; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svditer.cxx b/svx/source/svdraw/svditer.cxx new file mode 100644 index 0000000000..eaca2b335d --- /dev/null +++ b/svx/source/svdraw/svditer.cxx @@ -0,0 +1,140 @@ +/* -*- 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 +#include +#include +#include +#include + +SdrObjListIter::SdrObjListIter(const SdrObjList* pObjList, SdrIterMode eMode, bool bReverse) +: mnIndex(0), + mbReverse(bReverse), + mbUseZOrder(true) +{ + if(nullptr != pObjList) + { + ImpProcessObjectList(*pObjList, eMode); + } + + Reset(); +} + +SdrObjListIter::SdrObjListIter(const SdrObjList* pObjList, bool bUseZOrder, SdrIterMode eMode, bool bReverse) +: mnIndex(0), + mbReverse(bReverse), + mbUseZOrder(bUseZOrder) +{ + if(nullptr != pObjList) + { + // correct when we have no ObjectNavigationOrder + if(!mbUseZOrder && !pObjList->HasObjectNavigationOrder()) + { + mbUseZOrder = false; + } + + ImpProcessObjectList(*pObjList, eMode); + } + + Reset(); +} + +SdrObjListIter::SdrObjListIter(const SdrObject& rSdrObject, SdrIterMode eMode, bool bReverse) +: mnIndex(0), + mbReverse(bReverse), + mbUseZOrder(true) +{ + ImpProcessObj(rSdrObject, eMode); + Reset(); +} + +SdrObjListIter::SdrObjListIter(const SdrPage* pSdrPage, SdrIterMode eMode, bool bReverse) +: mnIndex(0), + mbReverse(bReverse), + mbUseZOrder(true) +{ + if (pSdrPage) + ImpProcessObjectList(*pSdrPage, eMode); + Reset(); +} + +SdrObjListIter::SdrObjListIter( const SdrMarkList& rMarkList, SdrIterMode eMode ) +: mnIndex(0), + mbReverse(false), + mbUseZOrder(true) +{ + ImpProcessMarkList(rMarkList, eMode); + Reset(); +} + +void SdrObjListIter::ImpProcessObjectList(const SdrObjList& rObjList, SdrIterMode eMode) +{ + for(size_t nIdx(0), nCount(rObjList.GetObjCount()); nIdx < nCount; ++nIdx) + { + const SdrObject* pSdrObject(mbUseZOrder + ? rObjList.GetObj(nIdx) + : rObjList.GetObjectForNavigationPosition(nIdx)); + + if(nullptr == pSdrObject) + { + OSL_ENSURE(false, "SdrObjListIter: corrupted SdrObjList (!)"); + } + else + { + ImpProcessObj(*pSdrObject, eMode); + } + } +} + +void SdrObjListIter::ImpProcessMarkList(const SdrMarkList& rMarkList, SdrIterMode eMode) +{ + for( size_t nIdx = 0, nCount = rMarkList.GetMarkCount(); nIdx < nCount; ++nIdx ) + { + if( SdrObject* pObj = rMarkList.GetMark( nIdx )->GetMarkedSdrObj() ) + { + ImpProcessObj(*pObj, eMode); + } + } +} + +void SdrObjListIter::ImpProcessObj(const SdrObject& rSdrObject, SdrIterMode eMode) +{ + // TTTT: Note: The behaviour has changed here, it will now deep-iterate + // for SdrObjGroup and E3dScene. Old version only deep-dived for SdrObjGroup, + // E3dScene was just added flat. This is now more correct, but potentially + // there will exist code in the 3D area that *self-iterates* with local + // functions/methods due to this iterator was not doing the expected thing. + // These will be difficult to find, but in most cases should do no harm, + // but cost runtime. Will need to have an eye on this aspect on continued + // changes... + const SdrObjList* pChildren(rSdrObject.getChildrenOfSdrObject()); + const bool bIsGroup(nullptr != pChildren); + + if(!bIsGroup || (SdrIterMode::DeepNoGroups != eMode)) + { + maObjList.push_back(&rSdrObject); + } + + if(bIsGroup && (SdrIterMode::Flat != eMode)) + { + ImpProcessObjectList(*pChildren, eMode); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdlayer.cxx b/svx/source/svdraw/svdlayer.cxx new file mode 100644 index 0000000000..74d5222f92 --- /dev/null +++ b/svx/source/svdraw/svdlayer.cxx @@ -0,0 +1,362 @@ +/* -*- 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 + +#include +#include + +#include +#include + +bool SdrLayerIDSet::IsEmpty() const +{ + for(sal_uInt8 i : m_aData) + { + if(i != 0) + return false; + } + + return true; +} + +void SdrLayerIDSet::operator&=(const SdrLayerIDSet& r2ndSet) +{ + for(sal_uInt16 i(0); i < 32; i++) + { + m_aData[i] &= r2ndSet.m_aData[i]; + } +} + +/** initialize this set with a UNO sequence of sal_Int8 (e.g. as stored in settings.xml) +*/ +void SdrLayerIDSet::PutValue( const css::uno::Any & rAny ) +{ + css::uno::Sequence< sal_Int8 > aSeq; + if( !(rAny >>= aSeq) ) + return; + + sal_Int16 nCount = static_cast(aSeq.getLength()); + if( nCount > 32 ) + nCount = 32; + + sal_Int16 nIndex; + for( nIndex = 0; nIndex < nCount; nIndex++ ) + { + m_aData[nIndex] = static_cast(aSeq[nIndex]); + } + + for( ; nIndex < 32; nIndex++ ) + { + m_aData[nIndex] = 0; + } +} + +SdrLayer::SdrLayer(SdrLayerID nNewID, OUString aNewName) : + maName(std::move(aNewName)), pModel(nullptr), nID(nNewID) +{ + // ODF default values + mbVisibleODF = true; + mbPrintableODF = true; + mbLockedODF = false; +} + +void SdrLayer::SetName(const OUString& rNewName) +{ + if (rNewName == maName) + return; + + maName = rNewName; + + if (pModel) + { + SdrHint aHint(SdrHintKind::LayerChange); + pModel->Broadcast(aHint); + pModel->SetChanged(); + } +} + +bool SdrLayer::operator==(const SdrLayer& rCmpLayer) const +{ + return (nID == rCmpLayer.nID + && maName == rCmpLayer.maName); +} + +SdrLayerAdmin::SdrLayerAdmin(SdrLayerAdmin* pNewParent): + pParent(pNewParent), + pModel(nullptr), + maControlLayerName("controls") +{ +} + +SdrLayerAdmin::SdrLayerAdmin(const SdrLayerAdmin& rSrcLayerAdmin): + pParent(nullptr), + pModel(nullptr), + maControlLayerName("controls") +{ + *this = rSrcLayerAdmin; +} + +SdrLayerAdmin::~SdrLayerAdmin() +{ +} + +void SdrLayerAdmin::ClearLayers() +{ + maLayers.clear(); +} + +SdrLayerAdmin& SdrLayerAdmin::operator=(const SdrLayerAdmin& rSrcLayerAdmin) +{ + if (this != &rSrcLayerAdmin) + { + maLayers.clear(); + pParent=rSrcLayerAdmin.pParent; + sal_uInt16 i; + sal_uInt16 nCount=rSrcLayerAdmin.GetLayerCount(); + for (i=0; iSetModel(pNewModelel); + } + } +} + +void SdrLayerAdmin::Broadcast() const +{ + if (pModel!=nullptr) { + SdrHint aHint(SdrHintKind::LayerOrderChange); + pModel->Broadcast(aHint); + pModel->SetChanged(); + } +} + +void SdrLayerAdmin::InsertLayer(std::unique_ptr pLayer, sal_uInt16 nPos) +{ + pLayer->SetModel(pModel); + if(nPos==0xFFFF) + maLayers.push_back(std::move(pLayer)); + else + maLayers.insert(maLayers.begin() + nPos, std::move(pLayer)); + Broadcast(); +} + +std::unique_ptr SdrLayerAdmin::RemoveLayer(sal_uInt16 nPos) +{ + std::unique_ptr pRetLayer = std::move(maLayers[nPos]); + maLayers.erase(maLayers.begin()+nPos); + Broadcast(); + return pRetLayer; +} + +SdrLayer* SdrLayerAdmin::NewLayer(const OUString& rName, sal_uInt16 nPos) +{ + SdrLayerID nID=GetUniqueLayerID(); + SdrLayer* pLay=new SdrLayer(nID,rName); + pLay->SetModel(pModel); + if(nPos==0xFFFF) + maLayers.push_back(std::unique_ptr(pLay)); + else + maLayers.insert(maLayers.begin() + nPos, std::unique_ptr(pLay)); + Broadcast(); + return pLay; +} + +sal_uInt16 SdrLayerAdmin::GetLayerPos(const SdrLayer* pLayer) const +{ + sal_uInt16 nRet=SDRLAYERPOS_NOTFOUND; + if (pLayer!=nullptr) { + auto it = std::find_if(maLayers.begin(), maLayers.end(), + [&](const std::unique_ptr & p) { return p.get() == pLayer; }); + if (it!=maLayers.end()) { + nRet=it - maLayers.begin(); + } + } + return nRet; +} + +SdrLayer* SdrLayerAdmin::GetLayer(const OUString& rName) +{ + return const_cast(const_cast(this)->GetLayer(rName)); +} + +const SdrLayer* SdrLayerAdmin::GetLayer(const OUString& rName) const +{ + sal_uInt16 i(0); + const SdrLayer* pLay = nullptr; + + while(i < GetLayerCount() && !pLay) + { + if (rName == GetLayer(i)->GetName()) + pLay = GetLayer(i); + else + i++; + } + + if(!pLay && pParent) + { + pLay = pParent->GetLayer(rName); + } + + return pLay; +} + +SdrLayerID SdrLayerAdmin::GetLayerID(const OUString& rName) const +{ + SdrLayerID nRet=SDRLAYER_NOTFOUND; + const SdrLayer* pLay=GetLayer(rName); + if (pLay!=nullptr) nRet=pLay->GetID(); + return nRet; +} + +const SdrLayer* SdrLayerAdmin::GetLayerPerID(SdrLayerID nID) const +{ + for (auto const & pLayer : maLayers) + if (pLayer->GetID() == nID) + return pLayer.get(); + return nullptr; +} + +// Global LayerIDs begin at 0 and increase, +// local LayerIDs begin at 254 and decrease; +// 255 is reserved for SDRLAYER_NOTFOUND. + +SdrLayerID SdrLayerAdmin::GetUniqueLayerID() const +{ + SdrLayerIDSet aSet; + for (sal_uInt16 j=0; jGetID()); + } + sal_uInt8 i; + if (pParent != nullptr) + { + i = 254; + while (i && aSet.IsSet(SdrLayerID(i))) + --i; + assert(i != 0); + if (i == 0) + i = 254; + } + else + { + i = 0; + while (i<=254 && aSet.IsSet(SdrLayerID(i))) + i++; + assert(i <= 254); + if (i>254) + i = 0; + } + return SdrLayerID(i); +} + +void SdrLayerAdmin::SetControlLayerName(const OUString& rNewName) +{ + maControlLayerName = rNewName; +} + +void SdrLayerAdmin::getVisibleLayersODF( SdrLayerIDSet& rOutSet) const +{ + rOutSet.ClearAll(); + for( auto & pCurrentLayer : maLayers ) + { + if ( pCurrentLayer->IsVisibleODF() ) + rOutSet.Set( pCurrentLayer->GetID() ); + } +} + +void SdrLayerAdmin::getPrintableLayersODF( SdrLayerIDSet& rOutSet) const +{ + rOutSet.ClearAll(); + for( auto & pCurrentLayer : maLayers ) + { + if ( pCurrentLayer->IsPrintableODF() ) + rOutSet.Set( pCurrentLayer->GetID() ); + } +} + +void SdrLayerAdmin::getLockedLayersODF( SdrLayerIDSet& rOutSet) const +{ + rOutSet.ClearAll(); + for( auto& pCurrentLayer : maLayers ) + { + if ( pCurrentLayer->IsLockedODF() ) + rOutSet.Set( pCurrentLayer->GetID() ); + } +} + + // Generates a bitfield for settings.xml from the SdrLayerIDSet. + // Output is a UNO sequence of BYTE (which is 'short' in API). +void SdrLayerAdmin::QueryValue(const SdrLayerIDSet& rViewLayerSet, css::uno::Any& rAny) +{ + // tdf#119392 The SdrLayerIDSet in a view is ordered according LayerID, but in file + // the bitfield is interpreted in order of layers in . + // First generate a new bitfield based on rViewLayerSet in the needed order. + sal_uInt8 aTmp[32]; // 256 bits in settings.xml makes byte 0 to 31 + for (auto nIndex = 0; nIndex <32; nIndex++) + { + aTmp[nIndex] = 0; + } + sal_uInt8 nByteIndex = 0; + sal_uInt8 nBitpos = 0; + sal_uInt16 nLayerPos = 0; // Position of the layer in member aLayer and in in file + sal_uInt16 nLayerIndex = 0; + for( const auto& pCurrentLayer : maLayers ) + { + SdrLayerID nCurrentID = pCurrentLayer->GetID(); + if ( rViewLayerSet.IsSet(nCurrentID) ) + { + nLayerPos = nLayerIndex; + nByteIndex = nLayerPos / 8; + if (nByteIndex > 31) + continue; // skip position, if too large for bitfield + nBitpos = nLayerPos % 8; + aTmp[nByteIndex] |= (1 << nBitpos); + } + ++nLayerIndex; + } + + // Second transform the bitfield to byte sequence, same as in previous version of QueryValue + sal_uInt8 nNumBytesSet = 0; + for( auto nIndex = 31; nIndex >= 0; nIndex--) + { + if( 0 != aTmp[nIndex] ) + { + nNumBytesSet = nIndex + 1; + break; + } + } + css::uno::Sequence< sal_Int8 > aSeq( nNumBytesSet ); + std::transform(aTmp, aTmp + nNumBytesSet, aSeq.getArray(), + [](const sal_uInt8 b) { return static_cast(b); }); + rAny <<= aSeq; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdmark.cxx b/svx/source/svdraw/svdmark.cxx new file mode 100644 index 0000000000..521e56d44b --- /dev/null +++ b/svx/source/svdraw/svdmark.cxx @@ -0,0 +1,780 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include +#include +#include + +#include + +void SdrMark::setTime() +{ + TimeValue aNow; + osl_getSystemTime(&aNow); + mnTimeStamp = sal_Int64(aNow.Seconds) * 1000000000 + aNow.Nanosec; +} + +SdrMark::SdrMark(SdrObject* pNewObj, SdrPageView* pNewPageView) +: mpSelectedSdrObject(pNewObj), + mpPageView(pNewPageView), + mbCon1(false), + mbCon2(false), + mnUser(0) +{ + if(mpSelectedSdrObject) + { + mpSelectedSdrObject->AddObjectUser( *this ); + } + setTime(); +} + +SdrMark::SdrMark(const SdrMark& rMark) +: ObjectUser(), + mnTimeStamp(0), + mpSelectedSdrObject(nullptr), + mpPageView(nullptr), + mbCon1(false), + mbCon2(false), + mnUser(0) +{ + *this = rMark; +} + +SdrMark::~SdrMark() +{ + if (mpSelectedSdrObject) + { + mpSelectedSdrObject->RemoveObjectUser( *this ); + } +} + +void SdrMark::ObjectInDestruction(const SdrObject& rObject) +{ + (void) rObject; // avoid warnings + OSL_ENSURE(mpSelectedSdrObject && mpSelectedSdrObject == &rObject, "SdrMark::ObjectInDestruction: called from object different from hosted one (!)"); + OSL_ENSURE(mpSelectedSdrObject, "SdrMark::ObjectInDestruction: still selected SdrObject is deleted, deselect first (!)"); + mpSelectedSdrObject = nullptr; +} + +void SdrMark::SetMarkedSdrObj(SdrObject* pNewObj) +{ + if(mpSelectedSdrObject) + { + mpSelectedSdrObject->RemoveObjectUser( *this ); + } + + mpSelectedSdrObject = pNewObj; + + if(mpSelectedSdrObject) + { + mpSelectedSdrObject->AddObjectUser( *this ); + } +} + +SdrMark& SdrMark::operator=(const SdrMark& rMark) +{ + SetMarkedSdrObj(rMark.mpSelectedSdrObject); + + mnTimeStamp = rMark.mnTimeStamp; + mpPageView = rMark.mpPageView; + mbCon1 = rMark.mbCon1; + mbCon2 = rMark.mbCon2; + mnUser = rMark.mnUser; + maPoints = rMark.maPoints; + maGluePoints = rMark.maGluePoints; + + return *this; +} + +static bool ImpSdrMarkListSorter(std::unique_ptr const& lhs, std::unique_ptr const& rhs) +{ + SdrObject* pObj1 = lhs->GetMarkedSdrObj(); + SdrObject* pObj2 = rhs->GetMarkedSdrObj(); + SdrObjList* pOL1 = pObj1 ? pObj1->getParentSdrObjListFromSdrObject() : nullptr; + SdrObjList* pOL2 = pObj2 ? pObj2->getParentSdrObjListFromSdrObject() : nullptr; + + if (pOL1 == pOL2) + { + // AF: Note that I reverted a change from sal_uInt32 to sal_uLong (made + // for 64bit compliance, #i78198#) because internally in SdrObject + // both nOrdNum and mnNavigationPosition are stored as sal_uInt32. + sal_uInt32 nObjOrd1(pObj1 ? pObj1->GetNavigationPosition() : 0); + sal_uInt32 nObjOrd2(pObj2 ? pObj2->GetNavigationPosition() : 0); + + return nObjOrd1 < nObjOrd2; + } + else + { + return pOL1 < pOL2; + } +} + + +void SdrMarkList::ForceSort() const +{ + if(!mbSorted) + { + const_cast(this)->ImpForceSort(); + } +} + +void SdrMarkList::ImpForceSort() +{ + if(mbSorted) + return; + + mbSorted = true; + size_t nCount = maList.size(); + + // remove invalid + if(nCount > 0 ) + { + std::erase_if(maList, [](std::unique_ptr& rItem) { return rItem->GetMarkedSdrObj() == nullptr; }); + nCount = maList.size(); + } + + if(nCount <= 1) + return; + + std::sort(maList.begin(), maList.end(), ImpSdrMarkListSorter); + + // remove duplicates + if(maList.size() <= 1) + return; + + SdrMark* pCurrent = maList.back().get(); + for (size_t count = maList.size() - 1; count; --count) + { + size_t i = count - 1; + SdrMark* pCmp = maList[i].get(); + assert(pCurrent->GetMarkedSdrObj()); + if(pCurrent->GetMarkedSdrObj() == pCmp->GetMarkedSdrObj()) + { + // Con1/Con2 Merging + if(pCmp->IsCon1()) + pCurrent->SetCon1(true); + + if(pCmp->IsCon2()) + pCurrent->SetCon2(true); + + // delete pCmp + maList.erase(maList.begin() + i); + } + else + { + pCurrent = pCmp; + } + } +} + +void SdrMarkList::Clear() +{ + maList.clear(); + mbSorted = true; //we're empty, so can be considered sorted + SetNameDirty(); +} + +SdrMarkList& SdrMarkList::operator=(const SdrMarkList& rLst) +{ + if (this != &rLst) + { + Clear(); + + for(size_t i = 0; i < rLst.GetMarkCount(); ++i) + { + SdrMark* pMark = rLst.GetMark(i); + maList.emplace_back(new SdrMark(*pMark)); + } + + maMarkName = rLst.maMarkName; + mbNameOk = rLst.mbNameOk; + maPointName = rLst.maPointName; + mbPointNameOk = rLst.mbPointNameOk; + maGluePointName = rLst.maGluePointName; + mbSorted = rLst.mbSorted; + } + return *this; +} + +SdrMark* SdrMarkList::GetMark(size_t nNum) const +{ + return (nNum < maList.size()) ? maList[nNum].get() : nullptr; +} + +size_t SdrMarkList::FindObject(const SdrObject* pObj) const +{ + // Since relying on OrdNums is not allowed for the selection because objects in the + // selection may not be inserted in a list if they are e.g. modified ATM, i changed + // this loop to just look if the object pointer is in the selection. + + // Problem is that GetOrdNum() which is const, internally casts to non-const and + // hardly sets the OrdNum member of the object (nOrdNum) to 0 (ZERO) if the object + // is not inserted in an object list. + // Since this may be by purpose and necessary somewhere else i decided that it is + // less dangerous to change this method then changing SdrObject::GetOrdNum(). + if(pObj) + { + for(size_t a = 0; a < maList.size(); ++a) + { + if(maList[a]->GetMarkedSdrObj() == pObj) + { + return a; + } + } + } + + return SAL_MAX_SIZE; +} + +void SdrMarkList::InsertEntry(const SdrMark& rMark, bool bChkSort) +{ + SetNameDirty(); + const size_t nCount(maList.size()); + + if(!bChkSort || !mbSorted || nCount == 0) + { + if(!bChkSort) + mbSorted = false; + + maList.emplace_back(new SdrMark(rMark)); + } + else + { + SdrMark* pLast = GetMark(nCount - 1); + const SdrObject* pLastObj = pLast->GetMarkedSdrObj(); + const SdrObject* pNewObj = rMark.GetMarkedSdrObj(); + + if(pLastObj == pNewObj) + { + // This one already exists. + // Con1/Con2 Merging + if(rMark.IsCon1()) + pLast->SetCon1(true); + + if(rMark.IsCon2()) + pLast->SetCon2(true); + } + else + { + maList.emplace_back(new SdrMark(rMark)); + + // now check if the sort is ok + const SdrObjList* pLastOL = pLastObj!=nullptr ? pLastObj->getParentSdrObjListFromSdrObject() : nullptr; + const SdrObjList* pNewOL = pNewObj !=nullptr ? pNewObj->getParentSdrObjListFromSdrObject() : nullptr; + + if(pLastOL == pNewOL) + { + const sal_uLong nLastNum(pLastObj!=nullptr ? pLastObj->GetOrdNum() : 0); + const sal_uLong nNewNum(pNewObj !=nullptr ? pNewObj ->GetOrdNum() : 0); + + if(nNewNum < nLastNum) + { + // at some point, we have to sort + mbSorted = false; + } + } + else + { + // at some point, we have to sort + mbSorted = false; + } + } + } +} + +void SdrMarkList::DeleteMark(size_t nNum) +{ + SdrMark* pMark = GetMark(nNum); + DBG_ASSERT(pMark!=nullptr,"DeleteMark: MarkEntry not found."); + + if(pMark) + { + maList.erase(maList.begin() + nNum); + if (maList.empty()) + mbSorted = true; //we're empty, so can be considered sorted + SetNameDirty(); + } +} + +void SdrMarkList::ReplaceMark(const SdrMark& rNewMark, size_t nNum) +{ + SdrMark* pMark = GetMark(nNum); + DBG_ASSERT(pMark!=nullptr,"ReplaceMark: MarkEntry not found."); + + if(pMark) + { + SetNameDirty(); + maList[nNum].reset(new SdrMark(rNewMark)); + mbSorted = false; + } +} + +void SdrMarkList::Merge(const SdrMarkList& rSrcList, bool bReverse) +{ + const size_t nCount(rSrcList.maList.size()); + + if(rSrcList.mbSorted) + { + // merge without forcing a Sort in rSrcList + bReverse = false; + } + + if(!bReverse) + { + for(size_t i = 0; i < nCount; ++i) + { + SdrMark* pM = rSrcList.maList[i].get(); + InsertEntry(*pM); + } + } + else + { + for(size_t i = nCount; i > 0;) + { + --i; + SdrMark* pM = rSrcList.maList[i].get(); + InsertEntry(*pM); + } + } +} + +bool SdrMarkList::DeletePageView(const SdrPageView& rPV) +{ + bool bChgd(false); + + for(auto it = maList.begin(); it != maList.end(); ) + { + SdrMark* pMark = it->get(); + + if(pMark->GetPageView()==&rPV) + { + it = maList.erase(it); + SetNameDirty(); + bChgd = true; + } + else + ++it; + } + + return bChgd; +} + +bool SdrMarkList::InsertPageView(const SdrPageView& rPV) +{ + bool bChgd(false); + DeletePageView(rPV); // delete all of them, then append the entire page + const SdrObjList* pOL = rPV.GetObjList(); + + for (const rtl::Reference& pObj : *pOL) + { + bool bDoIt(rPV.IsObjMarkable(pObj.get())); + + if(bDoIt) + { + maList.emplace_back(new SdrMark(pObj.get(), const_cast(&rPV))); + SetNameDirty(); + bChgd = true; + } + } + + return bChgd; +} + +const OUString& SdrMarkList::GetMarkDescription() const +{ + const size_t nCount(GetMarkCount()); + + if(mbNameOk && 1 == nCount) + { + // if it's a single selection, cache only text frame + const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj(); + const SdrTextObj* pTextObj = DynCastSdrTextObj( pObj ); + + if(!pTextObj || !pTextObj->IsTextFrame()) + { + const_cast(this)->mbNameOk = false; + } + } + + if(!mbNameOk) + { + SdrMark* pMark = GetMark(0); + OUString aNam; + + if(!nCount) + { + const_cast(this)->maMarkName = SvxResId(STR_ObjNameNoObj); + } + else if(1 == nCount) + { + if(pMark->GetMarkedSdrObj()) + { + aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul(); + } + } + else + { + if(pMark->GetMarkedSdrObj()) + { + aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural(); + bool bEq(true); + + for(size_t i = 1; i < GetMarkCount() && bEq; ++i) + { + SdrMark* pMark2 = GetMark(i); + OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural()); + bEq = aNam == aStr1; + } + + if(!bEq) + { + aNam = SvxResId(STR_ObjNamePlural); + } + } + + aNam = OUString::number( nCount ) + " " + aNam; + } + + const_cast(this)->maMarkName = aNam; + const_cast(this)->mbNameOk = true; + } + + return maMarkName; +} + +const OUString& SdrMarkList::GetPointMarkDescription(bool bGlue) const +{ + bool& rNameOk = const_cast(bGlue ? mbGluePointNameOk : mbPointNameOk); + OUString& rName = const_cast(bGlue ? maGluePointName : maPointName); + const size_t nMarkCount(GetMarkCount()); + size_t nMarkPtCnt(0); + size_t nMarkPtObjCnt(0); + size_t n1stMarkNum(SAL_MAX_SIZE); + + for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum) + { + const SdrMark* pMark = GetMark(nMarkNum); + const SdrUShortCont& rPts = bGlue ? pMark->GetMarkedGluePoints() : pMark->GetMarkedPoints(); + + if (!rPts.empty()) + { + if(n1stMarkNum == SAL_MAX_SIZE) + { + n1stMarkNum = nMarkNum; + } + + nMarkPtCnt += rPts.size(); + nMarkPtObjCnt++; + } + + if(nMarkPtObjCnt > 1 && rNameOk) + { + // preliminary decision + return rName; + } + } + + if(rNameOk && 1 == nMarkPtObjCnt) + { + // if it's a single selection, cache only text frame + const SdrObject* pObj = GetMark(0)->GetMarkedSdrObj(); + const SdrTextObj* pTextObj = DynCastSdrTextObj( pObj ); + + if(!pTextObj || !pTextObj->IsTextFrame()) + { + rNameOk = false; + } + } + + if(!nMarkPtObjCnt) + { + rName.clear(); + rNameOk = true; + } + else if(!rNameOk) + { + const SdrMark* pMark = GetMark(n1stMarkNum); + OUString aNam; + + if(1 == nMarkPtObjCnt) + { + if(pMark->GetMarkedSdrObj()) + { + aNam = pMark->GetMarkedSdrObj()->TakeObjNameSingul(); + } + } + else + { + if(pMark->GetMarkedSdrObj()) + { + aNam = pMark->GetMarkedSdrObj()->TakeObjNamePlural(); + } + + bool bEq(true); + + for(size_t i = n1stMarkNum + 1; i < GetMarkCount() && bEq; ++i) + { + const SdrMark* pMark2 = GetMark(i); + const SdrUShortCont& rPts = bGlue ? pMark2->GetMarkedGluePoints() : pMark2->GetMarkedPoints(); + + if (!rPts.empty() && pMark2->GetMarkedSdrObj()) + { + OUString aStr1(pMark2->GetMarkedSdrObj()->TakeObjNamePlural()); + bEq = aNam == aStr1; + } + } + + if(!bEq) + { + aNam = SvxResId(STR_ObjNamePlural); + } + + aNam = OUString::number( nMarkPtObjCnt ) + " " + aNam; + } + + OUString aStr1; + + if(1 == nMarkPtCnt) + { + aStr1 = SvxResId(bGlue ? STR_ViewMarkedGluePoint : STR_ViewMarkedPoint); + } + else + { + aStr1 = SvxResId(bGlue ? STR_ViewMarkedGluePoints : STR_ViewMarkedPoints); + aStr1 = aStr1.replaceFirst("%2", OUString::number( nMarkPtCnt )); + } + + aStr1 = aStr1.replaceFirst("%1", aNam); + rName = aStr1; + rNameOk = true; + } + + return rName; +} + +bool SdrMarkList::TakeBoundRect(SdrPageView const * pPV, tools::Rectangle& rRect) const +{ + bool bFnd(false); + tools::Rectangle aR; + + for(size_t i = 0; i < GetMarkCount(); ++i) + { + SdrMark* pMark = GetMark(i); + + if(!pPV || pMark->GetPageView() == pPV) + { + if(pMark->GetMarkedSdrObj()) + { + aR = pMark->GetMarkedSdrObj()->GetCurrentBoundRect(); + + if(bFnd) + { + rRect.Union(aR); + } + else + { + rRect = aR; + bFnd = true; + } + } + } + } + + return bFnd; +} + +bool SdrMarkList::TakeSnapRect(SdrPageView const * pPV, tools::Rectangle& rRect) const +{ + bool bFnd(false); + + for(size_t i = 0; i < GetMarkCount(); ++i) + { + SdrMark* pMark = GetMark(i); + + if(!pPV || pMark->GetPageView() == pPV) + { + if(pMark->GetMarkedSdrObj()) + { + tools::Rectangle aR(pMark->GetMarkedSdrObj()->GetSnapRect()); + + if(bFnd) + { + rRect.Union(aR); + } + else + { + rRect = aR; + bFnd = true; + } + } + } + } + + return bFnd; +} + + +namespace sdr +{ + ViewSelection::ViewSelection() + : mbEdgesOfMarkedNodesDirty(false) + { + } + + void ViewSelection::SetEdgesOfMarkedNodesDirty() + { + if(!mbEdgesOfMarkedNodesDirty) + { + mbEdgesOfMarkedNodesDirty = true; + maEdgesOfMarkedNodes.Clear(); + maMarkedEdgesOfMarkedNodes.Clear(); + maAllMarkedObjects.clear(); + } + } + + const SdrMarkList& ViewSelection::GetEdgesOfMarkedNodes() const + { + if(mbEdgesOfMarkedNodesDirty) + { + const_cast(this)->ImpForceEdgesOfMarkedNodes(); + } + + return maEdgesOfMarkedNodes; + } + + const SdrMarkList& ViewSelection::GetMarkedEdgesOfMarkedNodes() const + { + if(mbEdgesOfMarkedNodesDirty) + { + const_cast(this)->ImpForceEdgesOfMarkedNodes(); + } + + return maMarkedEdgesOfMarkedNodes; + } + + const std::vector& ViewSelection::GetAllMarkedObjects() const + { + if(mbEdgesOfMarkedNodesDirty) + const_cast(this)->ImpForceEdgesOfMarkedNodes(); + + return maAllMarkedObjects; + } + + void ViewSelection::ImplCollectCompleteSelection(SdrObject* pObj) + { + if(!pObj) + return; + + bool bIsGroup(pObj->IsGroupObject()); + + if(bIsGroup && DynCastE3dObject(pObj) != nullptr && DynCastE3dScene(pObj) == nullptr) + { + bIsGroup = false; + } + + if(bIsGroup) + { + SdrObjList* pList = pObj->GetSubList(); + + for (const rtl::Reference& pObj2 : *pList) + ImplCollectCompleteSelection(pObj2.get()); + } + + maAllMarkedObjects.push_back(pObj); + } + + void ViewSelection::ImpForceEdgesOfMarkedNodes() + { + if(!mbEdgesOfMarkedNodesDirty) + return; + + mbEdgesOfMarkedNodesDirty = false; + maMarkedObjectList.ForceSort(); + maEdgesOfMarkedNodes.Clear(); + maMarkedEdgesOfMarkedNodes.Clear(); + maAllMarkedObjects.clear(); + + // GetMarkCount after ForceSort + const size_t nMarkCount(maMarkedObjectList.GetMarkCount()); + + for(size_t a = 0; a < nMarkCount; ++a) + { + SdrObject* pCandidate = maMarkedObjectList.GetMark(a)->GetMarkedSdrObj(); + if(!pCandidate) + continue; + + // build transitive hull + ImplCollectCompleteSelection(pCandidate); + + // travel over broadcaster/listener to access edges connected to the selected object + const SfxBroadcaster* pBC = pCandidate->GetBroadcaster(); + if(!pBC) + continue; + + pBC->ForAllListeners( + [this, &pCandidate, &a] (SfxListener* pLst) + { + SdrEdgeObj* pEdge = dynamic_cast( pLst ); + + if(pEdge && pEdge->IsInserted() && pEdge->getSdrPageFromSdrObject() == pCandidate->getSdrPageFromSdrObject()) + { + SdrMark aM(pEdge, maMarkedObjectList.GetMark(a)->GetPageView()); + + if(pEdge->GetConnectedNode(true) == pCandidate) + { + aM.SetCon1(true); + } + + if(pEdge->GetConnectedNode(false) == pCandidate) + { + aM.SetCon2(true); + } + + if(SAL_MAX_SIZE == maMarkedObjectList.FindObject(pEdge)) + { + // check if it itself is selected + maEdgesOfMarkedNodes.InsertEntry(aM); + } + else + { + maMarkedEdgesOfMarkedNodes.InsertEntry(aM); + } + } + return false; + }); + } + maEdgesOfMarkedNodes.ForceSort(); + maMarkedEdgesOfMarkedNodes.ForceSort(); + } +} // end of namespace sdr + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdmodel.cxx b/svx/source/svdraw/svdmodel.cxx new file mode 100644 index 0000000000..90fc769e20 --- /dev/null +++ b/svx/source/svdraw/svdmodel.cxx @@ -0,0 +1,2009 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +using namespace ::com::sun::star; + +struct SdrModelImpl +{ + SfxUndoManager* mpUndoManager; + SdrUndoFactory* mpUndoFactory; + bool mbAnchoredTextOverflowLegacy; // tdf#99729 compatibility flag + bool mbLegacyFontwork; // tdf#148000 compatibility flag + bool mbConnectorUseSnapRect; // tdf#149756 compatibility flag + bool mbIgnoreBreakAfterMultilineField; ///< tdf#148966 compatibility flag + std::shared_ptr mpTheme; + std::shared_ptr mpThemeColorChanger; + + SdrModelImpl() + : mpUndoManager(nullptr) + , mpUndoFactory(nullptr) + , mbAnchoredTextOverflowLegacy(false) + , mbLegacyFontwork(false) + , mbConnectorUseSnapRect(false) + , mbIgnoreBreakAfterMultilineField(false) + , mpTheme(new model::Theme("Office")) + {} + + void initTheme() + { + auto const* pColorSet = svx::ColorSets::get().getColorSet(u"LibreOffice"); + if (pColorSet) + { + std::shared_ptr pDefaultColorSet(new model::ColorSet(*pColorSet)); + mpTheme->setColorSet(pDefaultColorSet); + } + } +}; + + +SdrModel::SdrModel(SfxItemPool* pPool, comphelper::IEmbeddedHelper* pEmbeddedHelper, bool bDisablePropertyFiles) + : m_eObjUnit(SdrEngineDefaults::GetMapUnit()) + , m_eUIUnit(FieldUnit::MM) + , m_aUIScale(Fraction(1,1)) + , m_nUIUnitDecimalMark(0) + , m_pLayerAdmin(new SdrLayerAdmin) + , m_pItemPool(pPool) + , m_pEmbeddedHelper(pEmbeddedHelper) + , mnDefTextHgt(SdrEngineDefaults::GetFontHeight()) + , m_pRefOutDev(nullptr) + , m_pDefaultStyleSheet(nullptr) + , mpDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(nullptr) + , m_pLinkManager(nullptr) + , m_nUndoLevel(0) + , m_bIsWriter(true) + , m_bThemedControls(true) + , mbUndoEnabled(true) + , mbChanged(false) + , m_bPagNumsDirty(false) + , m_bMPgNumsDirty(false) + , m_bTransportContainer(false) + , m_bReadOnly(false) + , m_bTransparentTextFrames(false) + , m_bSwapGraphics(false) + , m_bPasteResize(false) + , m_bStarDrawPreviewMode(false) + , mbDisableTextEditUsesCommonUndoManager(false) + , mbVOCInvalidationIsReliable(false) + , m_nDefaultTabulator(0) + , m_nMaxUndoCount(16) + , m_pTextChain(new TextChain) + , mpImpl(new SdrModelImpl) + , mnCharCompressType(CharCompressType::NONE) + , mnHandoutPageCount(0) + , mbModelLocked(false) + , mbKernAsianPunctuation(false) + , mbAddExtLeading(false) + , mbInDestruction(false) +{ + if (!utl::ConfigManager::IsFuzzing()) + { + mnCharCompressType = static_cast( + officecfg::Office::Common::AsianLayout::CompressCharacterDistance::get()); + } + + if (m_pItemPool == nullptr) + { + m_pItemPool = new SdrItemPool(nullptr); + // Outliner doesn't have its own Pool, so use the EditEngine's + rtl::Reference pOutlPool=EditEngine::CreatePool(); + // OutlinerPool as SecondaryPool of SdrPool + m_pItemPool->SetSecondaryPool(pOutlPool.get()); + // remember that I created both pools myself + m_bIsWriter = false; + } + m_pItemPool->SetDefaultMetric(m_eObjUnit); + +// using static SdrEngineDefaults only if default SvxFontHeight item is not available + const SfxPoolItem* pPoolItem = m_pItemPool->GetPoolDefaultItem( EE_CHAR_FONTHEIGHT ); + if (pPoolItem) + mnDefTextHgt = static_cast(pPoolItem)->GetHeight(); + + m_pItemPool->SetPoolDefaultItem( makeSdrTextWordWrapItem( false ) ); + + SetTextDefaults(); + m_pLayerAdmin->SetModel(this); + ImpSetUIUnit(); + + // can't create DrawOutliner OnDemand, because I can't get the Pool, + // then (only from 302 onwards!) + m_pDrawOutliner = SdrMakeOutliner(OutlinerMode::TextObject, *this); + ImpSetOutlinerDefaults(m_pDrawOutliner.get(), true); + + m_pHitTestOutliner = SdrMakeOutliner(OutlinerMode::TextObject, *this); + ImpSetOutlinerDefaults(m_pHitTestOutliner.get(), true); + + /* Start Text Chaining related code */ + // Initialize Chaining Outliner + m_pChainingOutliner = SdrMakeOutliner( OutlinerMode::TextObject, *this ); + ImpSetOutlinerDefaults(m_pChainingOutliner.get(), true); + + ImpCreateTables(bDisablePropertyFiles || utl::ConfigManager::IsFuzzing()); + + mpImpl->initTheme(); +} + +void SdrModel::implDtorClearModel() +{ + mbInDestruction = true; + + Broadcast(SdrHint(SdrHintKind::ModelCleared)); + + mpOutlinerCache.reset(); + + ClearUndoBuffer(); +#ifdef DBG_UTIL + SAL_WARN_IF(m_pCurrentUndoGroup, "svx", "In the Dtor of the SdrModel there is an open Undo left: \"" + << m_pCurrentUndoGroup->GetComment() << '\"'); +#endif + m_pCurrentUndoGroup.reset(); + + ClearModel(true); +} + +SdrModel::~SdrModel() +{ + implDtorClearModel(); + +#ifdef DBG_UTIL + // SdrObjectLifetimeWatchDog: + if(!maAllIncarnatedObjects.empty()) + { + SAL_WARN("svx", + "SdrModel::~SdrModel: Not all incarnations of SdrObjects deleted, possible memory leak"); + for (const auto & pObj : maAllIncarnatedObjects) + SAL_WARN("svx", "leaked instance of " << typeid(*pObj).name()); + } +#endif + + m_pLayerAdmin.reset(); + + m_pTextChain.reset(); + // Delete DrawOutliner only after deleting ItemPool, because ItemPool + // references Items of the DrawOutliner! + m_pChainingOutliner.reset(); + m_pHitTestOutliner.reset(); + m_pDrawOutliner.reset(); + + // delete StyleSheetPool, derived classes should not do this since + // the DrawingEngine may need it in its destructor + if( mxStyleSheetPool.is() ) + { + uno::Reference xComponent( getXWeak( mxStyleSheetPool.get() ), uno::UNO_QUERY ); + if( xComponent.is() ) try + { + xComponent->dispose(); + } + catch (uno::RuntimeException&) + { + } + mxStyleSheetPool.clear(); + } + + mpForbiddenCharactersTable.reset(); + + delete mpImpl->mpUndoFactory; +} + +void SdrModel::SetSwapGraphics() +{ + m_bSwapGraphics = true; +} + +bool SdrModel::IsReadOnly() const +{ + return m_bReadOnly; +} + +void SdrModel::SetReadOnly(bool bYes) +{ + m_bReadOnly=bYes; +} + + +void SdrModel::SetMaxUndoActionCount(sal_uInt32 nCount) +{ + if (nCount<1) nCount=1; + m_nMaxUndoCount=nCount; + while (m_aUndoStack.size()>m_nMaxUndoCount) + m_aUndoStack.pop_back(); +} + +void SdrModel::ClearUndoBuffer() +{ + m_aUndoStack.clear(); + m_aRedoStack.clear(); +} + +bool SdrModel::HasUndoActions() const +{ + return !m_aUndoStack.empty(); +} + +bool SdrModel::HasRedoActions() const +{ + return !m_aRedoStack.empty(); +} + +void SdrModel::Undo() +{ + if( mpImpl->mpUndoManager ) + { + OSL_FAIL("svx::SdrModel::Undo(), method not supported with application undo manager!"); + } + else + { + if(HasUndoActions()) + { + SfxUndoAction* pDo = m_aUndoStack.front().get(); + const bool bWasUndoEnabled = mbUndoEnabled; + mbUndoEnabled = false; + pDo->Undo(); + std::unique_ptr p = std::move(m_aUndoStack.front()); + m_aUndoStack.pop_front(); + m_aRedoStack.emplace_front(std::move(p)); + mbUndoEnabled = bWasUndoEnabled; + } + } +} + +void SdrModel::Redo() +{ + if( mpImpl->mpUndoManager ) + { + OSL_FAIL("svx::SdrModel::Redo(), method not supported with application undo manager!"); + } + else + { + if(HasRedoActions()) + { + SfxUndoAction* pDo = m_aRedoStack.front().get(); + const bool bWasUndoEnabled = mbUndoEnabled; + mbUndoEnabled = false; + pDo->Redo(); + std::unique_ptr p = std::move(m_aRedoStack.front()); + m_aRedoStack.pop_front(); + m_aUndoStack.emplace_front(std::move(p)); + mbUndoEnabled = bWasUndoEnabled; + } + } +} + +void SdrModel::Repeat(SfxRepeatTarget& rView) +{ + if( mpImpl->mpUndoManager ) + { + OSL_FAIL("svx::SdrModel::Redo(), method not supported with application undo manager!"); + } + else + { + if(HasUndoActions()) + { + SfxUndoAction* pDo = m_aUndoStack.front().get(); + if(pDo->CanRepeat(rView)) + { + pDo->Repeat(rView); + } + } + } +} + +void SdrModel::ImpPostUndoAction(std::unique_ptr pUndo) +{ + DBG_ASSERT( mpImpl->mpUndoManager == nullptr, "svx::SdrModel::ImpPostUndoAction(), method not supported with application undo manager!" ); + if( !IsUndoEnabled() ) + return; + + if (m_aUndoLink) + { + m_aUndoLink(std::move(pUndo)); + } + else + { + m_aUndoStack.emplace_front(std::move(pUndo)); + while (m_aUndoStack.size()>m_nMaxUndoCount) + { + m_aUndoStack.pop_back(); + } + m_aRedoStack.clear(); + } +} + +void SdrModel::BegUndo() +{ + if( mpImpl->mpUndoManager ) + { + ViewShellId nViewShellId(-1); + if (SfxViewShell* pViewShell = SfxViewShell::Current()) + nViewShellId = pViewShell->GetViewShellId(); + mpImpl->mpUndoManager->EnterListAction("","",0,nViewShellId); + m_nUndoLevel++; + } + else if( IsUndoEnabled() ) + { + if(!m_pCurrentUndoGroup) + { + m_pCurrentUndoGroup.reset(new SdrUndoGroup(*this)); + m_nUndoLevel=1; + } + else + { + m_nUndoLevel++; + } + } +} + +void SdrModel::BegUndo(const OUString& rComment) +{ + if( mpImpl->mpUndoManager ) + { + ViewShellId nViewShellId(-1); + if (SfxViewShell* pViewShell = SfxViewShell::Current()) + nViewShellId = pViewShell->GetViewShellId(); + mpImpl->mpUndoManager->EnterListAction( rComment, "", 0, nViewShellId ); + m_nUndoLevel++; + } + else if( IsUndoEnabled() ) + { + BegUndo(); + if (m_nUndoLevel==1) + { + m_pCurrentUndoGroup->SetComment(rComment); + } + } +} + +void SdrModel::BegUndo(const OUString& rComment, const OUString& rObjDescr, SdrRepeatFunc eFunc) +{ + if( mpImpl->mpUndoManager ) + { + OUString aComment(rComment); + if( !aComment.isEmpty() && !rObjDescr.isEmpty() ) + { + aComment = aComment.replaceFirst("%1", rObjDescr); + } + ViewShellId nViewShellId(-1); + if (SfxViewShell* pViewShell = SfxViewShell::Current()) + nViewShellId = pViewShell->GetViewShellId(); + mpImpl->mpUndoManager->EnterListAction( aComment,"",0,nViewShellId ); + m_nUndoLevel++; + } + else if( IsUndoEnabled() ) + { + BegUndo(); + if (m_nUndoLevel==1) + { + m_pCurrentUndoGroup->SetComment(rComment); + m_pCurrentUndoGroup->SetObjDescription(rObjDescr); + m_pCurrentUndoGroup->SetRepeatFunction(eFunc); + } + } +} + +void SdrModel::EndUndo() +{ + DBG_ASSERT(m_nUndoLevel!=0,"SdrModel::EndUndo(): UndoLevel is already 0!"); + if( mpImpl->mpUndoManager ) + { + if( m_nUndoLevel ) + { + m_nUndoLevel--; + mpImpl->mpUndoManager->LeaveListAction(); + } + } + else + { + if(m_pCurrentUndoGroup!=nullptr && IsUndoEnabled()) + { + m_nUndoLevel--; + if(m_nUndoLevel==0) + { + if(m_pCurrentUndoGroup->GetActionCount()!=0) + { + ImpPostUndoAction(std::move(m_pCurrentUndoGroup)); + } + else + { + // was empty + m_pCurrentUndoGroup.reset(); + } + } + } + } +} + +void SdrModel::SetUndoComment(const OUString& rComment) +{ + DBG_ASSERT(m_nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is already 0!"); + + if( mpImpl->mpUndoManager ) + { + OSL_FAIL("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" ); + } + else if( IsUndoEnabled() && m_nUndoLevel==1) + { + m_pCurrentUndoGroup->SetComment(rComment); + } +} + +void SdrModel::SetUndoComment(const OUString& rComment, const OUString& rObjDescr) +{ + DBG_ASSERT(m_nUndoLevel!=0,"SdrModel::SetUndoComment(): UndoLevel is already 0!"); + if( mpImpl->mpUndoManager ) + { + OSL_FAIL("svx::SdrModel::SetUndoComment(), method not supported with application undo manager!" ); + } + else + { + if (m_nUndoLevel==1) + { + m_pCurrentUndoGroup->SetComment(rComment); + m_pCurrentUndoGroup->SetObjDescription(rObjDescr); + } + } +} + +void SdrModel::AddUndo(std::unique_ptr pUndo) +{ + if( mpImpl->mpUndoManager ) + { + mpImpl->mpUndoManager->AddUndoAction( std::move(pUndo) ); + } + else if( IsUndoEnabled() ) + { + if (m_pCurrentUndoGroup) + { + m_pCurrentUndoGroup->AddAction(std::move(pUndo)); + } + else + { + ImpPostUndoAction(std::move(pUndo)); + } + } +} + +void SdrModel::EnableUndo( bool bEnable ) +{ + if( mpImpl->mpUndoManager ) + { + mpImpl->mpUndoManager->EnableUndo( bEnable ); + } + else + { + mbUndoEnabled = bEnable; + } +} + +bool SdrModel::IsUndoEnabled() const +{ + if( mpImpl->mpUndoManager ) + { + return mpImpl->mpUndoManager->IsUndoEnabled(); + } + else + { + return mbUndoEnabled; + } +} + +void SdrModel::ImpCreateTables(bool bDisablePropertyFiles) +{ + // use standard path for initial construction + const OUString aTablePath(!bDisablePropertyFiles ? SvtPathOptions().GetPalettePath() : ""); + + for( auto i : o3tl::enumrange() ) + { + maProperties[i] = XPropertyList::CreatePropertyList(i, aTablePath, ""/*TODO?*/ ); + } +} + +void SdrModel::ClearModel(bool bCalledFromDestructor) +{ + if(bCalledFromDestructor) + { + mbInDestruction = true; + } + + sal_Int32 i; + // delete all drawing pages + sal_Int32 nCount=GetPageCount(); + for (i=nCount-1; i>=0; i--) + { + DeletePage( static_cast(i) ); + } + maPages.clear(); + PageListChanged(); + + // delete all Masterpages + nCount=GetMasterPageCount(); + for(i=nCount-1; i>=0; i--) + { + DeleteMasterPage( static_cast(i) ); + } + maMasterPages.clear(); + MasterPageListChanged(); + + m_pLayerAdmin->ClearLayers(); +} + +SdrModel* SdrModel::AllocModel() const +{ + SdrModel* pModel=new SdrModel(); + pModel->SetScaleUnit(m_eObjUnit); + return pModel; +} + +rtl::Reference SdrModel::AllocPage(bool bMasterPage) +{ + return new SdrPage(*this,bMasterPage); +} + +void SdrModel::SetTextDefaults() const +{ + SetTextDefaults( m_pItemPool.get(), mnDefTextHgt ); +} + +void SdrModel::SetTextDefaults( SfxItemPool* pItemPool, sal_Int32 nDefTextHgt ) +{ + // set application-language specific dynamic pool language defaults + SvxFontItem aSvxFontItem( EE_CHAR_FONTINFO) ; + SvxFontItem aSvxFontItemCJK(EE_CHAR_FONTINFO_CJK); + SvxFontItem aSvxFontItemCTL(EE_CHAR_FONTINFO_CTL); + LanguageType nLanguage; + if (!utl::ConfigManager::IsFuzzing()) + nLanguage = Application::GetSettings().GetLanguageTag().getLanguageType(); + else + nLanguage = LANGUAGE_ENGLISH_US; + + // get DEFAULTFONT_LATIN_TEXT and set at pool as dynamic default + vcl::Font aFont(OutputDevice::GetDefaultFont(DefaultFontType::LATIN_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne)); + aSvxFontItem.SetFamily(aFont.GetFamilyType()); + aSvxFontItem.SetFamilyName(aFont.GetFamilyName()); + aSvxFontItem.SetStyleName(OUString()); + aSvxFontItem.SetPitch( aFont.GetPitch()); + aSvxFontItem.SetCharSet( aFont.GetCharSet() ); + pItemPool->SetPoolDefaultItem(aSvxFontItem); + + // get DEFAULTFONT_CJK_TEXT and set at pool as dynamic default + vcl::Font aFontCJK(OutputDevice::GetDefaultFont(DefaultFontType::CJK_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne)); + aSvxFontItemCJK.SetFamily( aFontCJK.GetFamilyType()); + aSvxFontItemCJK.SetFamilyName(aFontCJK.GetFamilyName()); + aSvxFontItemCJK.SetStyleName(OUString()); + aSvxFontItemCJK.SetPitch( aFontCJK.GetPitch()); + aSvxFontItemCJK.SetCharSet( aFontCJK.GetCharSet()); + pItemPool->SetPoolDefaultItem(aSvxFontItemCJK); + + // get DEFAULTFONT_CTL_TEXT and set at pool as dynamic default + vcl::Font aFontCTL(OutputDevice::GetDefaultFont(DefaultFontType::CTL_TEXT, nLanguage, GetDefaultFontFlags::OnlyOne)); + aSvxFontItemCTL.SetFamily(aFontCTL.GetFamilyType()); + aSvxFontItemCTL.SetFamilyName(aFontCTL.GetFamilyName()); + aSvxFontItemCTL.SetStyleName(OUString()); + aSvxFontItemCTL.SetPitch( aFontCTL.GetPitch() ); + aSvxFontItemCTL.SetCharSet( aFontCTL.GetCharSet()); + pItemPool->SetPoolDefaultItem(aSvxFontItemCTL); + + // set dynamic FontHeight defaults + pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT ) ); + pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CJK ) ); + pItemPool->SetPoolDefaultItem( SvxFontHeightItem(nDefTextHgt, 100, EE_CHAR_FONTHEIGHT_CTL ) ); + + // set FontColor defaults + pItemPool->SetPoolDefaultItem( SvxColorItem(SdrEngineDefaults::GetFontColor(), EE_CHAR_COLOR) ); +} + +SdrOutliner& SdrModel::GetDrawOutliner(const SdrTextObj* pObj) const +{ + m_pDrawOutliner->SetTextObj(pObj); + return *m_pDrawOutliner; +} + +SdrOutliner& SdrModel::GetChainingOutliner(const SdrTextObj* pObj) const +{ + m_pChainingOutliner->SetTextObj(pObj); + return *m_pChainingOutliner; +} + +const SdrTextObj* SdrModel::GetFormattingTextObj() const +{ + if (m_pDrawOutliner!=nullptr) { + return m_pDrawOutliner->GetTextObj(); + } + return nullptr; +} + +void SdrModel::ImpSetOutlinerDefaults( SdrOutliner* pOutliner, bool bInit ) +{ + // Initialization of the Outliners for drawing text and HitTest + if( bInit ) + { + pOutliner->EraseVirtualDevice(); + pOutliner->SetUpdateLayout(false); + pOutliner->SetEditTextObjectPool(m_pItemPool.get()); + pOutliner->SetDefTab(m_nDefaultTabulator); + } + + pOutliner->SetRefDevice(GetRefDevice()); + Outliner::SetForbiddenCharsTable(GetForbiddenCharsTable()); + pOutliner->SetAsianCompressionMode( mnCharCompressType ); + pOutliner->SetKernAsianPunctuation( IsKernAsianPunctuation() ); + pOutliner->SetAddExtLeading( IsAddExtLeading() ); + + if ( !GetRefDevice() ) + { + MapMode aMapMode(m_eObjUnit); + pOutliner->SetRefMapMode(aMapMode); + } +} + +void SdrModel::SetRefDevice(OutputDevice* pDev) +{ + m_pRefOutDev=pDev; + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); + RefDeviceChanged(); +} + +void SdrModel::ImpReformatAllTextObjects() +{ + if( isLocked() ) + return; + + sal_uInt16 nCount=GetMasterPageCount(); + sal_uInt16 nNum; + for (nNum=0; nNumReformatAllTextObjects(); + } + nCount=GetPageCount(); + for (nNum=0; nNumReformatAllTextObjects(); + } +} + +/* steps over all available pages and sends notify messages to + all edge objects that are connected to other objects so that + they may reposition themselves +*/ +void SdrModel::ImpReformatAllEdgeObjects() +{ + if( isLocked() ) + return; + + sal_uInt16 nCount=GetMasterPageCount(); + sal_uInt16 nNum; + for (nNum=0; nNumReformatAllEdgeObjects(); + } + nCount=GetPageCount(); + for (nNum=0; nNumReformatAllEdgeObjects(); + } +} + +uno::Reference SdrModel::GetDocumentStorage() const +{ + uno::Reference const xSBD( + const_cast(this)->getUnoModel(), uno::UNO_QUERY); + if (!xSBD.is()) + { + SAL_WARN("svx", "no UNO model"); + return nullptr; + } + return xSBD->getDocumentStorage(); +} + +uno::Reference +SdrModel::GetDocumentStream( OUString const& rURL, + ::comphelper::LifecycleProxy const & rProxy) const +{ + uno::Reference const xStorage(GetDocumentStorage()); + if (!xStorage.is()) + { + SAL_WARN("svx", "no storage?"); + return nullptr; + } + try { + uno::Reference const xStream( + ::comphelper::OStorageHelper::GetStreamAtPackageURL( + xStorage, rURL, embed::ElementModes::READ, rProxy)); + return (xStream.is()) ? xStream->getInputStream() : nullptr; + } + catch (container::NoSuchElementException const&) + { + SAL_INFO("svx", "not found"); + } + catch (uno::Exception const&) + { + TOOLS_WARN_EXCEPTION("svx", ""); + } + return nullptr; +} + +// convert template attributes from the string into "hard" attributes +void SdrModel::BurnInStyleSheetAttributes() +{ + sal_uInt16 nCount=GetMasterPageCount(); + sal_uInt16 nNum; + for (nNum=0; nNumBurnInStyleSheetAttributes(); + } + nCount=GetPageCount(); + for (nNum=0; nNumBurnInStyleSheetAttributes(); + } +} + +void SdrModel::RefDeviceChanged() +{ + Broadcast(SdrHint(SdrHintKind::RefDeviceChange)); + ImpReformatAllTextObjects(); +} + +void SdrModel::SetDefaultFontHeight(sal_Int32 nVal) +{ + if (nVal!=mnDefTextHgt) { + mnDefTextHgt=nVal; + ImpReformatAllTextObjects(); + } +} + +void SdrModel::SetDefaultTabulator(sal_uInt16 nVal) +{ + if (m_nDefaultTabulator!=nVal) { + m_nDefaultTabulator=nVal; + Outliner& rOutliner=GetDrawOutliner(); + rOutliner.SetDefTab(nVal); + Broadcast(SdrHint(SdrHintKind::DefaultTabChange)); + ImpReformatAllTextObjects(); + } +} + +void SdrModel::ImpSetUIUnit() +{ + if(0 == m_aUIScale.GetNumerator() || 0 == m_aUIScale.GetDenominator()) + { + m_aUIScale = Fraction(1,1); + } + + m_nUIUnitDecimalMark = 0; + + o3tl::Length eFrom = MapToO3tlLength(m_eObjUnit, o3tl::Length::invalid); + o3tl::Length eTo; + + switch (m_eUIUnit) + { + case FieldUnit::CHAR: + case FieldUnit::LINE: + eTo = o3tl::Length::invalid; + break; + case FieldUnit::PERCENT: + m_nUIUnitDecimalMark += 2; + [[fallthrough]]; + default: + eTo = FieldToO3tlLength(m_eUIUnit, o3tl::Length::invalid); + } // switch + + sal_Int32 nMul = 1, nDiv = 1; + if (eFrom != o3tl::Length::invalid && eTo != o3tl::Length::invalid) + { + const auto& [mul, div] = o3tl::getConversionMulDiv(eFrom, eTo); + nMul = mul; + nDiv = div; + } + // #i89872# take Unit of Measurement into account + if(1 != m_aUIScale.GetDenominator() || 1 != m_aUIScale.GetNumerator()) + { + // divide by UIScale + nMul *= m_aUIScale.GetDenominator(); + nDiv *= m_aUIScale.GetNumerator(); + } + + // shorten trailing zeros for dividend + while(0 == (nMul % 10)) + { + m_nUIUnitDecimalMark--; + nMul /= 10; + } + + // shorten trailing zeros for divisor + while(0 == (nDiv % 10)) + { + m_nUIUnitDecimalMark++; + nDiv /= 10; + } + + // end preparations, set member values + m_aUIUnitFact = Fraction(sal_Int32(nMul), sal_Int32(nDiv)); + m_aUIUnitStr = GetUnitString(m_eUIUnit); +} + +void SdrModel::SetScaleUnit(MapUnit eMap) +{ + if (m_eObjUnit!=eMap) { + m_eObjUnit=eMap; + m_pItemPool->SetDefaultMetric(m_eObjUnit); + ImpSetUIUnit(); + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); + ImpReformatAllTextObjects(); + } +} + +void SdrModel::SetUIUnit(FieldUnit eUnit) +{ + if (m_eUIUnit!=eUnit) { + m_eUIUnit=eUnit; + ImpSetUIUnit(); + ImpReformatAllTextObjects(); + } +} + +void SdrModel::SetUIScale(const Fraction& rScale) +{ + if (m_aUIScale!=rScale) { + m_aUIScale=rScale; + ImpSetUIUnit(); + ImpReformatAllTextObjects(); + } +} + +void SdrModel::SetUIUnit(FieldUnit eUnit, const Fraction& rScale) +{ + if (m_eUIUnit!=eUnit || m_aUIScale!=rScale) { + m_eUIUnit=eUnit; + m_aUIScale=rScale; + ImpSetUIUnit(); + ImpReformatAllTextObjects(); + } +} + +OUString SdrModel::GetUnitString(FieldUnit eUnit) +{ + switch(eUnit) + { + default: + case FieldUnit::NONE : + case FieldUnit::CUSTOM : + return OUString(); + case FieldUnit::MM_100TH: + return OUString{"/100mm"}; + case FieldUnit::MM : + return OUString{"mm"}; + case FieldUnit::CM : + return OUString{"cm"}; + case FieldUnit::M : + return OUString{"m"}; + case FieldUnit::KM : + return OUString{"km"}; + case FieldUnit::TWIP : + return OUString{"twip"}; + case FieldUnit::POINT : + return OUString{"pt"}; + case FieldUnit::PICA : + return OUString{"pica"}; + case FieldUnit::INCH : + return OUString{"\""}; + case FieldUnit::FOOT : + return OUString{"ft"}; + case FieldUnit::MILE : + return OUString{"mile(s)"}; + case FieldUnit::PERCENT: + return OUString{"%"}; + } +} + +OUString SdrModel::GetMetricString(tools::Long nVal, bool bNoUnitChars, sal_Int32 nNumDigits) const +{ + // #i22167# + // change to double precision usage to not lose decimal places + const bool bNegative(nVal < 0); + SvtSysLocale aSysLoc; + const LocaleDataWrapper& rLoc(aSysLoc.GetLocaleData()); + double fLocalValue(double(nVal) * double(m_aUIUnitFact)); + + if(bNegative) + { + fLocalValue = -fLocalValue; + } + + if( -1 == nNumDigits ) + { + nNumDigits = LocaleDataWrapper::getNumDigits(); + } + + sal_Int32 nDecimalMark(m_nUIUnitDecimalMark); + + if(nDecimalMark > nNumDigits) + { + const sal_Int32 nDiff(nDecimalMark - nNumDigits); + const double fFactor(pow(10.0, static_cast(nDiff))); + + fLocalValue /= fFactor; + nDecimalMark = nNumDigits; + } + else if(nDecimalMark < nNumDigits) + { + const sal_Int32 nDiff(nNumDigits - nDecimalMark); + const double fFactor(pow(10.0, static_cast(nDiff))); + + fLocalValue *= fFactor; + nDecimalMark = nNumDigits; + } + + OUStringBuffer aBuf = OUString::number(static_cast(fLocalValue + 0.5)); + + if(nDecimalMark < 0) + { + // negative nDecimalMark (decimal point) means: add zeros + sal_Int32 nCount(-nDecimalMark); + + for(sal_Int32 i=0; i 0 && aBuf.getLength() <= nDecimalMark) + { + // if necessary, add zeros before the decimal point + sal_Int32 nCount = nDecimalMark - aBuf.getLength(); + + if(nCount >= 0 && LocaleDataWrapper::isNumLeadingZero()) + nCount++; + + for(sal_Int32 i=0; i 0) + aBuf.insert(nBeforeDecimalMark, cDec); + + if(!LocaleDataWrapper::isNumTrailingZeros()) + { + sal_Int32 aPos=aBuf.getLength()-1; + + // Remove all trailing zeros. + while (aPos>=0 && aBuf[aPos]=='0') + --aPos; + + // Remove decimal if it's the last character. + if (aPos>=0 && aBuf[aPos]==cDec) + --aPos; + + // Adjust aPos to index first char to be truncated, if any + if (++aPos 3 ) + { + const OUString& aThoSep( rLoc.getNumThousandSep() ); + if ( !aThoSep.isEmpty() ) + { + sal_Unicode cTho( aThoSep[0] ); + sal_Int32 i(nBeforeDecimalMark - 3); + + while(i > 0) + { + aBuf.insert(i, cTho); + i -= 3; + } + } + } + + if (aBuf.isEmpty()) + aBuf.append("0"); + + if(bNegative) + { + aBuf.insert(0, "-"); + } + + if(!bNoUnitChars) + aBuf.append(m_aUIUnitStr); + + return aBuf.makeStringAndClear(); +} + +OUString SdrModel::GetAngleString(Degree100 nAngle) +{ + bool bNeg = nAngle < 0_deg100; + + if(bNeg) + nAngle = -nAngle; + + OUStringBuffer aBuf; + aBuf.append(static_cast(nAngle)); + + SvtSysLocale aSysLoc; + const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData(); + sal_Int32 nCount = 2; + + if(LocaleDataWrapper::isNumLeadingZero()) + nCount++; + + while(aBuf.getLength() < nCount) + aBuf.insert(0, '0'); + + aBuf.insert(aBuf.getLength()-2, rLoc.getNumDecimalSep()[0]); + + if(bNeg) + aBuf.insert(0, '-'); + + aBuf.append(DEGREE_CHAR); + + return aBuf.makeStringAndClear(); +} + +OUString SdrModel::GetPercentString(const Fraction& rVal) +{ + sal_Int32 nMul(rVal.GetNumerator()); + sal_Int32 nDiv(rVal.GetDenominator()); + bool bNeg {false}; + + if (nDiv < 0) + { + bNeg = !bNeg; + nDiv = -nDiv; + } + + if (nMul < 0) + { + bNeg = !bNeg; + nMul = -nMul; + } + + sal_Int32 nPct = ((nMul*100) + nDiv/2)/nDiv; + + if (bNeg) + nPct = -nPct; + + return OUString::number(nPct) + "%"; +} + +void SdrModel::SetChanged(bool bFlg) +{ + mbChanged = bFlg; +} + +void SdrModel::RecalcPageNums(bool bMaster) +{ + if(bMaster) + { + sal_uInt16 nCount=sal_uInt16(maMasterPages.size()); + sal_uInt16 i; + for (i=0; iSetPageNum(i); + } + m_bMPgNumsDirty=false; + } + else + { + sal_uInt16 nCount=sal_uInt16(maPages.size()); + sal_uInt16 i; + for (i=0; iSetPageNum(i); + } + m_bPagNumsDirty=false; + } +} + +void SdrModel::InsertPage(SdrPage* pPage, sal_uInt16 nPos) +{ + sal_uInt16 nCount = GetPageCount(); + if (nPos > nCount) + nPos = nCount; + + maPages.insert(maPages.begin() + nPos, pPage); + PageListChanged(); + pPage->SetInserted(); + pPage->SetPageNum(nPos); + + if (mbMakePageObjectsNamesUnique) + pPage->MakePageObjectsNamesUnique(); + + if (nPos SdrModel::RemovePage(sal_uInt16 nPgNum) +{ + rtl::Reference pPg = maPages[nPgNum]; + maPages.erase(maPages.begin()+nPgNum); + PageListChanged(); + if (pPg) { + pPg->SetInserted(false); + } + m_bPagNumsDirty=true; + SetChanged(); + SdrHint aHint(SdrHintKind::PageOrderChange, pPg.get()); + Broadcast(aHint); + return pPg; +} + +void SdrModel::MovePage(sal_uInt16 nPgNum, sal_uInt16 nNewPos) +{ + rtl::Reference pPg = std::move(maPages[nPgNum]); + if (pPg) { + maPages.erase(maPages.begin()+nPgNum); // shortcut to avoid two broadcasts + PageListChanged(); + pPg->SetInserted(false); + InsertPage(pPg.get(), nNewPos); + } + else + RemovePage(nPgNum); +} + +void SdrModel::InsertMasterPage(SdrPage* pPage, sal_uInt16 nPos) +{ + sal_uInt16 nCount=GetMasterPageCount(); + if (nPos>nCount) nPos=nCount; + maMasterPages.insert(maMasterPages.begin()+nPos,pPage); + MasterPageListChanged(); + pPage->SetInserted(); + pPage->SetPageNum(nPos); + + if (nPos SdrModel::RemoveMasterPage(sal_uInt16 nPgNum) +{ + rtl::Reference pRetPg = std::move(maMasterPages[nPgNum]); + maMasterPages.erase(maMasterPages.begin()+nPgNum); + MasterPageListChanged(); + + if(pRetPg) + { + // Now delete the links from the normal drawing pages to the deleted master page. + sal_uInt16 nPageCnt(GetPageCount()); + + for(sal_uInt16 np(0); np < nPageCnt; np++) + { + GetPage(np)->TRG_ImpMasterPageRemoved(*pRetPg); + } + + pRetPg->SetInserted(false); + } + + m_bMPgNumsDirty=true; + SetChanged(); + SdrHint aHint(SdrHintKind::PageOrderChange, pRetPg.get()); + Broadcast(aHint); + return pRetPg; +} + +void SdrModel::MoveMasterPage(sal_uInt16 nPgNum, sal_uInt16 nNewPos) +{ + rtl::Reference pPg = std::move(maMasterPages[nPgNum]); + maMasterPages.erase(maMasterPages.begin()+nPgNum); + MasterPageListChanged(); + if (pPg) { + pPg->SetInserted(false); + maMasterPages.insert(maMasterPages.begin()+nNewPos,pPg); + MasterPageListChanged(); + } + m_bMPgNumsDirty=true; + SetChanged(); + SdrHint aHint(SdrHintKind::PageOrderChange, pPg.get()); + Broadcast(aHint); +} + + +void SdrModel::CopyPages(sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum, + sal_uInt16 nDestPos, + bool bUndo, bool bMoveNoCopy) +{ + if( bUndo && !IsUndoEnabled() ) + bUndo = false; + + if( bUndo ) + BegUndo(SvxResId(STR_UndoMergeModel)); + + sal_uInt16 nPageCnt=GetPageCount(); + sal_uInt16 nMaxPage=nPageCnt; + + if (nMaxPage!=0) + nMaxPage--; + if (nFirstPageNum>nMaxPage) + nFirstPageNum=nMaxPage; + if (nLastPageNum>nMaxPage) + nLastPageNum =nMaxPage; + bool bReverse=nLastPageNumnPageCnt) + nDestPos=nPageCnt; + + // at first, save the pointers of the affected pages in an array + sal_uInt16 nPageNum=nFirstPageNum; + sal_uInt16 nCopyCnt=((!bReverse)?(nLastPageNum-nFirstPageNum):(nFirstPageNum-nLastPageNum))+1; + std::unique_ptr pPagePtrs(new SdrPage*[nCopyCnt]); + sal_uInt16 nCopyNum; + for(nCopyNum=0; nCopyNum pPg = pPagePtrs[nCopyNum]; + sal_uInt16 nPageNum2=pPg->GetPageNum(); + if (!bMoveNoCopy) + { + const SdrPage* pPg1=GetPage(nPageNum2); + + // Clone to local model + pPg = pPg1->CloneSdrPage(*this); + + InsertPage(pPg.get(), nDestNum); + if (bUndo) + AddUndo(GetSdrUndoFactory().CreateUndoCopyPage(*pPg)); + nDestNum++; + } + else + { + // TODO: Move is untested! + if (nDestNum>nPageNum2) + nDestNum--; + + if(bUndo) + AddUndo(GetSdrUndoFactory().CreateUndoSetPageNum(*GetPage(nPageNum2),nPageNum2,nDestNum)); + + pPg=RemovePage(nPageNum2); + InsertPage(pPg.get(), nDestNum); + nDestNum++; + } + + if(bReverse) + nPageNum2--; + else + nPageNum2++; + } + + pPagePtrs.reset(); + if(bUndo) + EndUndo(); +} + +void SdrModel::Merge(SdrModel& rSourceModel, + sal_uInt16 nFirstPageNum, sal_uInt16 nLastPageNum, + sal_uInt16 nDestPos, + bool bMergeMasterPages, bool bAllMasterPages, + bool bUndo, bool bTreadSourceAsConst) +{ + if (&rSourceModel==this) + { + CopyPages(nFirstPageNum,nLastPageNum,nDestPos,bUndo,!bTreadSourceAsConst); + return; + } + + if( bUndo && !IsUndoEnabled() ) + bUndo = false; + + if (bUndo) + BegUndo(SvxResId(STR_UndoMergeModel)); + + sal_uInt16 nSrcPageCnt=rSourceModel.GetPageCount(); + sal_uInt16 nSrcMasterPageCnt=rSourceModel.GetMasterPageCount(); + sal_uInt16 nDstMasterPageCnt=GetMasterPageCount(); + bool bInsPages=(nFirstPageNumnMaxSrcPage) nFirstPageNum=nMaxSrcPage; + if (nLastPageNum>nMaxSrcPage) nLastPageNum =nMaxSrcPage; + bool bReverse=nLastPageNum pMasterMap; + std::unique_ptr pMasterNeed; + sal_uInt16 nMasterNeed=0; + if (bMergeMasterPages && nSrcMasterPageCnt!=0) { + // determine which MasterPages from rSrcModel we need + pMasterMap.reset(new sal_uInt16[nSrcMasterPageCnt]); + pMasterNeed.reset(new bool[nSrcMasterPageCnt]); + memset(pMasterMap.get(),0xFF,nSrcMasterPageCnt*sizeof(sal_uInt16)); + if (bAllMasterPages) { + memset(pMasterNeed.get(), true, nSrcMasterPageCnt * sizeof(bool)); + } else { + memset(pMasterNeed.get(), false, nSrcMasterPageCnt * sizeof(bool)); + sal_uInt16 nStart= bReverse ? nLastPageNum : nFirstPageNum; + sal_uInt16 nEnd= bReverse ? nFirstPageNum : nLastPageNum; + for (sal_uInt16 i=nStart; i<=nEnd; i++) { + const SdrPage* pPg=rSourceModel.GetPage(i); + if(pPg->TRG_HasMasterPage()) + { + SdrPage& rMasterPage = pPg->TRG_GetMasterPage(); + sal_uInt16 nMPgNum(rMasterPage.GetPageNum()); + + if(nMPgNum < nSrcMasterPageCnt) + { + pMasterNeed[nMPgNum] = true; + } + } + } + } + // now determine the Mapping of the MasterPages + sal_uInt16 nCurrentMaPagNum=nDstMasterPageCnt; + for (sal_uInt16 i=0; i0;) { + i--; + if (pMasterNeed[i]) + { + // Always Clone to new model + const SdrPage* pPg1(rSourceModel.GetMasterPage(i)); + rtl::Reference pPg = pPg1->CloneSdrPage(*this); + + if(!bTreadSourceAsConst) + { + // if requested, delete original/modify original model + rSourceModel.RemoveMasterPage(i); + } + + if (pPg!=nullptr) { + // Now append all of them to the end of the DstModel. + // Don't use InsertMasterPage(), because everything is + // inconsistent until all are in. + maMasterPages.insert(maMasterPages.begin()+nDstMasterPageCnt, pPg); + MasterPageListChanged(); + pPg->SetInserted(); + m_bMPgNumsDirty=true; + if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg)); + } else { + OSL_FAIL("SdrModel::Merge(): MasterPage not found in SourceModel."); + } + } + } + } + + // get the drawing pages + if (bInsPages) { + sal_uInt16 nSourcePos=nFirstPageNum; + sal_uInt16 nMergeCount=sal_uInt16(std::abs(static_cast(static_cast(nFirstPageNum)-nLastPageNum))+1); + if (nDestPos>GetPageCount()) nDestPos=GetPageCount(); + while (nMergeCount>0) + { + // Always Clone to new model + const SdrPage* pPg1(rSourceModel.GetPage(nSourcePos)); + rtl::Reference pPg = pPg1->CloneSdrPage(*this); + + if(!bTreadSourceAsConst) + { + // if requested, delete original/modify original model + rSourceModel.RemovePage(nSourcePos); + } + + if (pPg!=nullptr) { + InsertPage(pPg.get(),nDestPos); + if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg)); + + if(pPg->TRG_HasMasterPage()) + { + SdrPage& rMasterPage = pPg->TRG_GetMasterPage(); + sal_uInt16 nMaPgNum(rMasterPage.GetPageNum()); + + if (bMergeMasterPages) + { + sal_uInt16 nNewNum(0xFFFF); + + if(pMasterMap) + { + nNewNum = pMasterMap[nMaPgNum]; + } + + if(nNewNum != 0xFFFF) + { + // tdf#90357 here pPg and the to-be-set new masterpage are parts of the new model + // already, but the currently set masterpage is part of the old model. Remove master + // page from already cloned page to prevent creating wrong undo action that can + // eventually crash the app. + // Do *not* remove it directly after cloning - the old masterpage is still needed + // later to find the new to-be-set masterpage. + pPg->TRG_ClearMasterPage(); + + if(bUndo) + { + AddUndo(GetSdrUndoFactory().CreateUndoPageChangeMasterPage(*pPg)); + } + + pPg->TRG_SetMasterPage(*GetMasterPage(nNewNum)); + } + DBG_ASSERT(nNewNum!=0xFFFF,"SdrModel::Merge(): Something is crooked with the mapping of the MasterPages."); + } else { + if (nMaPgNum>=nDstMasterPageCnt) { + // This is outside of the original area of the MasterPage of the DstModel. + pPg->TRG_ClearMasterPage(); + } + } + } + + } else { + OSL_FAIL("SdrModel::Merge(): Drawing page not found in SourceModel."); + } + nDestPos++; + if (bReverse) nSourcePos--; + else if (bTreadSourceAsConst) nSourcePos++; + nMergeCount--; + } + } + + pMasterMap.reset(); + pMasterNeed.reset(); + + m_bMPgNumsDirty=true; + m_bPagNumsDirty=true; + + SetChanged(); + // TODO: Missing: merging and mapping of layers + // at the objects as well as at the MasterPageDescriptors + if (bUndo) EndUndo(); +} + +void SdrModel::SetStarDrawPreviewMode(bool bPreview) +{ + if (!bPreview && m_bStarDrawPreviewMode && GetPageCount()) + { + // Resetting is not allowed, because the Model might not be loaded completely + SAL_WARN("svx", "SdrModel::SetStarDrawPreviewMode(): Resetting not allowed, because Model might not be complete."); + } + else + { + m_bStarDrawPreviewMode = bPreview; + } +} + +void SdrModel::setTheme(std::shared_ptr const& pTheme) +{ + mpImpl->mpTheme = pTheme; +} + +std::shared_ptr const& SdrModel::getTheme() const +{ + return mpImpl->mpTheme; +} + +uno::Reference< frame::XModel > const & SdrModel::getUnoModel() +{ + if( !mxUnoModel.is() ) + mxUnoModel = createUnoModel(); + + return mxUnoModel; +} + +void SdrModel::setUnoModel(const uno::Reference& xModel) +{ + mxUnoModel = xModel; +} + +void SdrModel::adaptSizeAndBorderForAllPages( + const Size& /*rNewSize*/, + tools::Long /*nLeft*/, + tools::Long /*nRight*/, + tools::Long /*nUpper*/, + tools::Long /*nLower*/) +{ + // base implementation does currently nothing. It may be added if needed, + // but we are on SdrModel level here, thus probably have not enough information + // to do this for higher-level (derived) Models (e.g. Draw/Impress) +} + +uno::Reference< frame::XModel > SdrModel::createUnoModel() +{ + OSL_FAIL( "SdrModel::createUnoModel() - base implementation should not be called!" ); + return nullptr; +} + +void SdrModel::setLock( bool bLock ) +{ + if( mbModelLocked != bLock ) + { + // #i120437# need to set first, else ImpReformatAllEdgeObjects will do nothing + mbModelLocked = bLock; + + if( !bLock ) + { + ImpReformatAllEdgeObjects(); + } + } +} + + +void SdrModel::MigrateItemSet( const SfxItemSet* pSourceSet, SfxItemSet* pDestSet, SdrModel* pNewModelel ) +{ + assert(pNewModelel != nullptr); + if( !(pSourceSet && pDestSet && (pSourceSet != pDestSet )) ) + return; + + SfxWhichIter aWhichIter(*pSourceSet); + sal_uInt16 nWhich(aWhichIter.FirstWhich()); + const SfxPoolItem *pPoolItem; + + while(nWhich) + { + if(SfxItemState::SET == aWhichIter.GetItemState(false, &pPoolItem)) + { + std::unique_ptr pResultItem; + + switch( nWhich ) + { + case XATTR_FILLBITMAP: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_LINEDASH: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_LINESTART: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_LINEEND: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_FILLGRADIENT: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_FILLFLOATTRANSPARENCE: + // allow all kinds of XFillFloatTransparenceItem to be set + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + case XATTR_FILLHATCH: + pResultItem = static_cast(pPoolItem)->checkForUniqueItem( pNewModelel ); + break; + } + + // set item + if( pResultItem ) + pDestSet->Put(std::move(pResultItem)); + else + pDestSet->Put(*pPoolItem); + } + nWhich = aWhichIter.NextWhich(); + } +} + + +void SdrModel::SetForbiddenCharsTable(const std::shared_ptr& xForbiddenChars) +{ + mpForbiddenCharactersTable = xForbiddenChars; + + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); +} + + +void SdrModel::SetCharCompressType( CharCompressType nType ) +{ + if( nType != mnCharCompressType ) + { + mnCharCompressType = nType; + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); + } +} + +void SdrModel::SetKernAsianPunctuation( bool bEnabled ) +{ + if( mbKernAsianPunctuation != bEnabled ) + { + mbKernAsianPunctuation = bEnabled; + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); + } +} + +void SdrModel::SetAddExtLeading( bool bEnabled ) +{ + if( mbAddExtLeading != bEnabled ) + { + mbAddExtLeading = bEnabled; + ImpSetOutlinerDefaults( m_pDrawOutliner.get() ); + ImpSetOutlinerDefaults( m_pHitTestOutliner.get() ); + } +} + +void SdrModel::SetCompatibilityFlag(SdrCompatibilityFlag eFlag, bool bEnabled) +{ + switch (eFlag) + { + case SdrCompatibilityFlag::AnchoredTextOverflowLegacy: + mpImpl->mbAnchoredTextOverflowLegacy = bEnabled; + break; + case SdrCompatibilityFlag::LegacyFontwork: + mpImpl->mbLegacyFontwork = bEnabled; + break; + case SdrCompatibilityFlag::ConnectorUseSnapRect: + mpImpl->mbConnectorUseSnapRect = bEnabled; + break; + case SdrCompatibilityFlag::IgnoreBreakAfterMultilineField: + mpImpl->mbIgnoreBreakAfterMultilineField = bEnabled; + break; + } +} + +bool SdrModel::GetCompatibilityFlag(SdrCompatibilityFlag eFlag) const +{ + switch (eFlag) + { + case SdrCompatibilityFlag::AnchoredTextOverflowLegacy: + return mpImpl->mbAnchoredTextOverflowLegacy; + case SdrCompatibilityFlag::LegacyFontwork: + return mpImpl->mbLegacyFontwork; + case SdrCompatibilityFlag::ConnectorUseSnapRect: + return mpImpl->mbConnectorUseSnapRect; + case SdrCompatibilityFlag::IgnoreBreakAfterMultilineField: + return mpImpl->mbIgnoreBreakAfterMultilineField; + default: + return false; + } +} + +void SdrModel::ReformatAllTextObjects() +{ + ImpReformatAllTextObjects(); +} + +std::unique_ptr SdrModel::createOutliner( OutlinerMode nOutlinerMode ) +{ + if( !mpOutlinerCache ) + mpOutlinerCache.reset(new SdrOutlinerCache(this)); + + return mpOutlinerCache->createOutliner( nOutlinerMode ); +} + +std::vector SdrModel::GetActiveOutliners() const +{ + std::vector< SdrOutliner* > aRet(mpOutlinerCache ? mpOutlinerCache->GetActiveOutliners() : std::vector< SdrOutliner* >()); + aRet.push_back(m_pDrawOutliner.get()); + aRet.push_back(m_pHitTestOutliner.get()); + + return aRet; +} + +void SdrModel::disposeOutliner( std::unique_ptr pOutliner ) +{ + if( mpOutlinerCache ) + mpOutlinerCache->disposeOutliner( std::move(pOutliner) ); +} + +SvxNumType SdrModel::GetPageNumType() const +{ + return SVX_NUM_ARABIC; +} + +void SdrModel::ReadUserDataSequenceValue(const beans::PropertyValue* pValue) +{ + if (pValue->Name == "AnchoredTextOverflowLegacy") + { + bool bBool = false; + if (pValue->Value >>= bBool) + { + mpImpl->mbAnchoredTextOverflowLegacy = bBool; + } + } + else if (pValue->Name == "ConnectorUseSnapRect") + { + bool bBool = false; + if (pValue->Value >>= bBool) + { + mpImpl->mbConnectorUseSnapRect = bBool; + } + } + else if (pValue->Name == "LegacySingleLineFontwork") + { + bool bBool = false; + if ((pValue->Value >>= bBool) && mpImpl->mbLegacyFontwork != bBool) + { + mpImpl->mbLegacyFontwork = bBool; + // tdf#148000 hack: reset all CustomShape geometry as they may depend on this property + // Ideally this ReadUserDataSequenceValue should be called before geometry creation + // Once the calling order will be fixed, this hack will not be needed. + for (size_t i = 0; i < maPages.size(); ++i) + { + if (const SdrPage* pPage = maPages[i].get()) + { + SdrObjListIter aIter(pPage, SdrIterMode::DeepWithGroups); + while (aIter.IsMore()) + { + SdrObject* pTempObj = aIter.Next(); + if (SdrObjCustomShape* pShape = dynamic_cast(pTempObj)) + { + pShape->InvalidateRenderGeometry(); + } + } + } + } + } + } + else if (pValue->Name == "IgnoreBreakAfterMultilineField") + { + bool bBool = false; + if (pValue->Value >>= bBool) + { + mpImpl->mbIgnoreBreakAfterMultilineField = bBool; + } + } +} + +void SdrModel::WriteUserDataSequence(uno::Sequence & rValues) +{ + std::vector< std::pair< OUString, uno::Any > > aUserData + { + { "AnchoredTextOverflowLegacy", uno::Any(GetCompatibilityFlag(SdrCompatibilityFlag::AnchoredTextOverflowLegacy)) }, + { "LegacySingleLineFontwork", uno::Any(GetCompatibilityFlag(SdrCompatibilityFlag::LegacyFontwork)) }, + { "ConnectorUseSnapRect", uno::Any(GetCompatibilityFlag(SdrCompatibilityFlag::ConnectorUseSnapRect)) }, + { "IgnoreBreakAfterMultilineField", uno::Any(GetCompatibilityFlag(SdrCompatibilityFlag::IgnoreBreakAfterMultilineField)) } + }; + + const sal_Int32 nOldLength = rValues.getLength(); + rValues.realloc(nOldLength + aUserData.size()); + + beans::PropertyValue* pValue = &(rValues.getArray()[nOldLength]); + + for (const auto &aIter : aUserData) + { + pValue->Name = aIter.first; + pValue->Value = aIter.second; + ++pValue; + } +} + +const SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum) const +{ + return nPgNum < maPages.size() ? maPages[nPgNum].get() : nullptr; +} + +SdrPage* SdrModel::GetPage(sal_uInt16 nPgNum) +{ + return nPgNum < maPages.size() ? maPages[nPgNum].get() : nullptr; +} + +sal_uInt16 SdrModel::GetPageCount() const +{ + return sal_uInt16(maPages.size()); +} + +void SdrModel::PageListChanged() +{ +} + +TextChain *SdrModel::GetTextChain() const +{ + return m_pTextChain.get(); +} + +const SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum) const +{ + DBG_ASSERT(nPgNum < maMasterPages.size(), "SdrModel::GetMasterPage: Access out of range (!)"); + return maMasterPages[nPgNum].get(); +} + +SdrPage* SdrModel::GetMasterPage(sal_uInt16 nPgNum) +{ + DBG_ASSERT(nPgNum < maMasterPages.size(), "SdrModel::GetMasterPage: Access out of range (!)"); + return maMasterPages[nPgNum].get(); +} + +sal_uInt16 SdrModel::GetMasterPageCount() const +{ + return sal_uInt16(maMasterPages.size()); +} + +void SdrModel::MasterPageListChanged() +{ +} + +void SdrModel::SetSdrUndoManager( SfxUndoManager* pUndoManager ) +{ + mpImpl->mpUndoManager = pUndoManager; +} + +SfxUndoManager* SdrModel::GetSdrUndoManager() const +{ + return mpImpl->mpUndoManager; +} + +SdrUndoFactory& SdrModel::GetSdrUndoFactory() const +{ + if( !mpImpl->mpUndoFactory ) + mpImpl->mpUndoFactory = new SdrUndoFactory; + return *mpImpl->mpUndoFactory; +} + +void SdrModel::SetSdrUndoFactory( SdrUndoFactory* pUndoFactory ) +{ + if( pUndoFactory && (pUndoFactory != mpImpl->mpUndoFactory) ) + { + delete mpImpl->mpUndoFactory; + mpImpl->mpUndoFactory = pUndoFactory; + } +} + +void SdrModel::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrModel")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("maMasterPages")); + for (size_t i = 0; i < maMasterPages.size(); ++i) + { + if (const SdrPage* pPage = maMasterPages[i].get()) + { + pPage->dumpAsXml(pWriter); + } + } + (void)xmlTextWriterEndElement(pWriter); + + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("maPages")); + for (size_t i = 0; i < maPages.size(); ++i) + { + if (const SdrPage* pPage = maPages[i].get()) + { + pPage->dumpAsXml(pWriter); + } + } + (void)xmlTextWriterEndElement(pWriter); + + if (mpImpl->mpTheme) + { + mpImpl->mpTheme->dumpAsXml(pWriter); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +const uno::Sequence& SdrModel::getUnoTunnelId() +{ + static const comphelper::UnoIdInit theSdrModelUnoTunnelImplementationId; + return theSdrModelUnoTunnelImplementationId.getSeq(); +} + + +SdrHint::SdrHint(SdrHintKind eNewHint) +: SfxHint(SfxHintId::ThisIsAnSdrHint), + meHint(eNewHint), + mpObj(nullptr), + mpPage(nullptr) +{ +} + +SdrHint::SdrHint(SdrHintKind eNewHint, const SdrObject& rNewObj) +: SfxHint(SfxHintId::ThisIsAnSdrHint), + meHint(eNewHint), + mpObj(&rNewObj), + mpPage(rNewObj.getSdrPageFromSdrObject()) +{ +} + +SdrHint::SdrHint(SdrHintKind eNewHint, const SdrPage* pPage) +: SfxHint(SfxHintId::ThisIsAnSdrHint), + meHint(eNewHint), + mpObj(nullptr), + mpPage(pPage) +{ +} + +SdrHint::SdrHint(SdrHintKind eNewHint, const SdrObject& rNewObj, const SdrPage* pPage) +: SfxHint(SfxHintId::ThisIsAnSdrHint), + meHint(eNewHint), + mpObj(&rNewObj), + mpPage(pPage) +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ 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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include "gradtrns.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include + +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 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 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& xTargetOverlay = pCandidate->GetOverlayManager(); + + if (xTargetOverlay.is()) + { + const Color aHighlightColor = SvtOptionsDrawinglayer::getHilightColor(); + + std::unique_ptr pNew = + std::make_unique( + 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(&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(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& 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(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; nMarkNumGetMarkedSdrObj(); + bFrmHdl=!pObj->IsPolyObj(); + } + } + } + if (!bFrmHdl) { + // FrameHandles, if at least 1 Obj can't do SpecialDrag + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + 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& 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(*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(pO)) + + "\",\"type\":" + + OString::number(static_cast(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& xChartController = aChartHelper.GetXController(); + css::uno::Reference 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 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 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(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(" 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()elem"; + + aExtraInfo.append(", \"svg\": \"" + + sSVGElem + + "\\n " + + sPolygonElem + + "\\n" + "\""); // 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(pHdl->GetKind()); + child.put("id", pHdl->GetObjHdlNum()); + child.put("kind", kind); + child.put("pointer", static_cast(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(SdrHdlKind::UpperLeft) && kind <= static_cast(SdrHdlKind::LowerRight)) + { + selectedNode = &rectangle; + } + else if (kind == static_cast(SdrHdlKind::Poly)) + { + selectedNode = &poly; + } + else if (kind == static_cast(SdrHdlKind::CustomShape1)) + { + selectedNode = &custom; + } + else if (kind == static_cast(SdrHdlKind::Anchor) || kind == static_cast(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(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(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(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; nMarkNumGetPageView()) + { + 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(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(*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(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + } + else if (!bStdDrag && (bWdt0 || bHgt0)) + { + maHdlList.AddHdl(std::make_unique(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + maHdlList.AddHdl(std::make_unique(aRect.BottomRight(), SdrHdlKind::LowerRight)); + } + else + { + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(aRect.TopLeft(), SdrHdlKind::UpperLeft)); + } + + if (!bLimitedRotation && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(aRect.TopCenter(), SdrHdlKind::Upper)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(aRect.TopRight(), SdrHdlKind::UpperRight)); + } + + if (!bLimitedRotation && !bWdt0) + { + maHdlList.AddHdl(std::make_unique(aRect.LeftCenter(), SdrHdlKind::Left )); + maHdlList.AddHdl(std::make_unique(aRect.RightCenter(), SdrHdlKind::Right)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(aRect.BottomLeft(), SdrHdlKind::LowerLeft)); + } + + if (!bLimitedRotation && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(aRect.BottomCenter(), SdrHdlKind::Lower)); + } + + if (!bWdt0 && !bHgt0) + { + maHdlList.AddHdl(std::make_unique(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; iSetObj(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; iSetObj(mpMarkedObj); + pHdl->SetPageView(mpMarkedPV); + pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0)); + } + + bDone = true; + } + + if(!bDone) + { + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + 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; iSetObj(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; nPlusNumSetObj(pObj); + pPlusHdl->SetPageView(pPV); + pPlusHdl->SetPlusHdl(true); + } + plusList.MoveTo(maHdlList); + } + } + } + } + } + } + + // GluePoint handles + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + 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 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(maRef1, SdrHdlKind::Ref1)); + break; + } + case SdrDragMode::Mirror: + { + // add axis of reflection + std::unique_ptr pHdl3(new SdrHdl(maRef2, SdrHdlKind::Ref2)); + std::unique_ptr pHdl2(new SdrHdl(maRef1, SdrHdlKind::Ref1)); + std::unique_ptr 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 pColHdl1(new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, SDR_HANDLE_COLOR_SIZE_NORMAL, true)); + std::unique_ptr pColHdl2(new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, SDR_HANDLE_COLOR_SIZE_NORMAL, true)); + std::unique_ptr 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 pColHdl1(new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, aHdlSize, false)); + std::unique_ptr pColHdl2(new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, aHdlSize, false)); + std::unique_ptr 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-nOutMinnMinLen) 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 (nHgtnOutHgt) nMinLen=nOutHgt; // TODO: maybe shorten this a little + + if (pOut!=nullptr) { // now move completely into the visible area + if (nY1nOutMax) { + 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(this)->IsEdgeTool(); + meEditMode0=meEditMode; + meEditMode=eMode; + bool bGlue1=meEditMode==SdrViewEditMode::GluePointEdit; + bool bEdge1=static_cast(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; nmGetMarkedSdrObj(),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(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 && nSearchObjNumGetObjectForNavigationPosition(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; nmGetPageView(); + 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 && noGetObj(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& 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 && 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(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(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( 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(this)->IsTextEditFrameHit(rPnt)) { + pObj=static_cast(this)->GetTextEditObject(); + pHitObj=pObj; + pPV=static_cast(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; nmGetMarkedSdrObj(); + 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(this)->mbMarkedObjRectDirty=false; + tools::Rectangle aRect; + for (size_t nm=0; nmGetMarkedSdrObj(); + if (!pO) + continue; + tools::Rectangle aR1(pO->GetSnapRect()); + if (aRect.IsEmpty()) aRect=aR1; + else aRect.Union(aR1); + } + const_cast(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: */ diff --git a/svx/source/svdraw/svdmrkv1.cxx b/svx/source/svdraw/svdmrkv1.cxx new file mode 100644 index 0000000000..9c732262bc --- /dev/null +++ b/svx/source/svdraw/svdmrkv1.cxx @@ -0,0 +1,547 @@ +/* -*- 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 +#include +#include + + +// Point Selection + + +bool SdrMarkView::HasMarkablePoints() const +{ + ForceUndirtyMrkPnt(); + bool bRet=false; + if (!ImpIsFrameHandles()) { + const size_t nMarkCount=GetMarkedObjectCount(); + if (nMarkCount<=static_cast(mnFrameHandlesLimit)) { + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + bRet=pObj->IsPolyObj(); + } + } + } + return bRet; +} + +sal_Int32 SdrMarkView::GetMarkablePointCount() const +{ + ForceUndirtyMrkPnt(); + sal_Int32 nCount=0; + if (!ImpIsFrameHandles()) { + const size_t nMarkCount=GetMarkedObjectCount(); + if (nMarkCount<=static_cast(mnFrameHandlesLimit)) { + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + if (pObj->IsPolyObj()) { + nCount+=pObj->GetPointCount(); + } + } + } + } + return nCount; +} + +bool SdrMarkView::HasMarkedPoints() const +{ + ForceUndirtyMrkPnt(); + bool bRet=false; + if (!ImpIsFrameHandles()) { + const size_t nMarkCount=GetMarkedObjectCount(); + if (nMarkCount<=static_cast(mnFrameHandlesLimit)) { + for (size_t nMarkNum=0; nMarkNumGetMarkedPoints(); + bRet = !rPts.empty(); + } + } + } + return bRet; +} + +bool SdrMarkView::IsPointMarkable(const SdrHdl& rHdl) const +{ + return !ImpIsFrameHandles() && !rHdl.IsPlusHdl() && rHdl.GetKind()!=SdrHdlKind::Glue && rHdl.GetKind()!=SdrHdlKind::SmartTag && rHdl.GetObj()!=nullptr && rHdl.GetObj()->IsPolyObj(); +} + +bool SdrMarkView::MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark) +{ + return ImpMarkPoint( pHdl, pMark, bUnmark ); +} + +bool SdrMarkView::ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark) +{ + if (pHdl==nullptr || pHdl->IsPlusHdl() || pHdl->GetKind()==SdrHdlKind::Glue) + return false; + + if (pHdl->IsSelected() != bUnmark) + return false; + + SdrObject* pObj=pHdl->GetObj(); + if (pObj==nullptr || !pObj->IsPolyObj()) + return false; + + if (pMark==nullptr) + { + const size_t nMarkNum=TryToFindMarkedObject(pObj); + if (nMarkNum==SAL_MAX_SIZE) + return false; + pMark=GetSdrMarkByIndex(nMarkNum); + } + const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum()); + SdrUShortCont& rPts=pMark->GetMarkedPoints(); + if (!bUnmark) + { + rPts.insert(static_cast(nHdlNum)); + } + else + { + SdrUShortCont::const_iterator it = rPts.find( static_cast(nHdlNum) ); + if (it != rPts.end()) + { + rPts.erase(it); + } + else + { + return false; // error case! + } + } + + pHdl->SetSelected(!bUnmark); + if (!mbPlusHdlAlways) + { + if (!bUnmark) + { + SdrHdlList plusList(nullptr); + pObj->AddToPlusHdlList(plusList, *pHdl); + sal_uInt32 nCount(plusList.GetHdlCount()); + for (sal_uInt32 i=0; iSetObj(pObj); + pPlusHdl->SetPageView(pMark->GetPageView()); + pPlusHdl->SetPlusHdl(true); + } + plusList.MoveTo(maHdlList); + } + else + { + for (size_t i = maHdlList.GetHdlCount(); i>0;) + { + --i; + SdrHdl* pPlusHdl=maHdlList.GetHdl(i); + if (pPlusHdl->IsPlusHdl() && pPlusHdl->GetSourceHdlNum()==nHdlNum) + { + maHdlList.RemoveHdl(i); + } + } + } + } + + maHdlList.Sort(); + + return true; +} + + +bool SdrMarkView::MarkPoint(SdrHdl& rHdl, bool bUnmark) +{ + ForceUndirtyMrkPnt(); + bool bRet=false; + const SdrObject* pObj=rHdl.GetObj(); + if (IsPointMarkable(rHdl) && rHdl.IsSelected()==bUnmark) { + const size_t nMarkNum=TryToFindMarkedObject(pObj); + if (nMarkNum!=SAL_MAX_SIZE) { + SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + if (ImpMarkPoint(&rHdl,pM,bUnmark)) { + MarkListHasChanged(); + bRet=true; + } + } + } + + return bRet; +} + +bool SdrMarkView::MarkPoints(const tools::Rectangle* pRect, bool bUnmark) +{ + ForceUndirtyMrkPnt(); + bool bChgd=false; + SortMarkedObjects(); + const SdrObject* pObj0=nullptr; + const SdrPageView* pPV0=nullptr; + SdrMark* pM=nullptr; + maHdlList.Sort(); + const size_t nHdlCnt=maHdlList.GetHdlCount(); + for (size_t nHdlNum=nHdlCnt; nHdlNum>0;) { + --nHdlNum; + SdrHdl* pHdl=maHdlList.GetHdl(nHdlNum); + if (IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark) { + const SdrObject* pObj=pHdl->GetObj(); + const SdrPageView* pPV=pHdl->GetPageView(); + if (pObj!=pObj0 || pPV!=pPV0 || pM==nullptr) { // This section is for optimization, + const size_t nMarkNum=TryToFindMarkedObject(pObj); // so ImpMarkPoint() doesn't always + if (nMarkNum!=SAL_MAX_SIZE) { // have to search the object in the MarkList. + pM=GetSdrMarkByIndex(nMarkNum); + pObj0=pObj; + pPV0=pPV; + } else { +#ifdef DBG_UTIL + if (pObj->IsInserted()) { + OSL_FAIL("SdrMarkView::MarkPoints(const Rectangle* pRect): Selected object not found."); + } +#endif + pM=nullptr; + } + } + Point aPos(pHdl->GetPos()); + if (pM!=nullptr && (pRect==nullptr || pRect->Contains(aPos))) { + if (ImpMarkPoint(pHdl,pM,bUnmark)) bChgd=true; + } + } + } + if (bChgd) { + MarkListHasChanged(); + } + + return bChgd; +} + +void SdrMarkView::MarkNextPoint() +{ + ForceUndirtyMrkPnt(); + SortMarkedObjects(); +} + +const tools::Rectangle& SdrMarkView::GetMarkedPointsRect() const +{ + ForceUndirtyMrkPnt(); + if (mbMarkedPointsRectsDirty) ImpSetPointsRects(); + return maMarkedPointsRect; +} + +void SdrMarkView::SetPlusHandlesAlwaysVisible(bool bOn) +{ // TODO: Optimize HandlePaint! + ForceUndirtyMrkPnt(); + if (bOn!=mbPlusHdlAlways) { + mbPlusHdlAlways=bOn; + SetMarkHandles(nullptr); + MarkListHasChanged(); + } +} + + +// ImpSetPointsRects() is for PolyPoints and GluePoints! + + +void SdrMarkView::ImpSetPointsRects() const +{ + tools::Rectangle aPnts; + tools::Rectangle aGlue; + const size_t nHdlCnt=maHdlList.GetHdlCount(); + for (size_t nHdlNum=0; nHdlNumGetKind(); + if ((eKind==SdrHdlKind::Poly && pHdl->IsSelected()) || eKind==SdrHdlKind::Glue) { + Point aPt(pHdl->GetPos()); + tools::Rectangle& rR=eKind==SdrHdlKind::Glue ? aGlue : aPnts; + if (rR.IsEmpty()) { + rR=tools::Rectangle(aPt,aPt); + } else { + if (aPt.X()rR.Right ()) rR.SetRight(aPt.X() ); + if (aPt.Y()rR.Bottom()) rR.SetBottom(aPt.Y() ); + } + } + } + const_cast(this)->maMarkedPointsRect=aPnts; + const_cast(this)->maMarkedGluePointsRect=aGlue; + const_cast(this)->mbMarkedPointsRectsDirty=false; +} + + +// UndirtyMrkPnt() is for PolyPoints and GluePoints! + + +void SdrMarkView::UndirtyMrkPnt() const +{ + bool bChg=false; + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + // PolyPoints + { + SdrUShortCont& rPts = pM->GetMarkedPoints(); + if (pObj->IsPolyObj()) { + // Remove invalid selected points, that is, all + // entries above the number of points in the object. + sal_uInt32 nMax(pObj->GetPointCount()); + + SdrUShortCont::const_iterator it = rPts.lower_bound(nMax); + if( it != rPts.end() ) + { + rPts.erase(it, rPts.end()); + bChg = true; + } + } + else + { + if (!rPts.empty()) + { + // only fail *if* there are marked points + OSL_FAIL("SdrMarkView::UndirtyMrkPnt(): Selected points on an object that is not a PolyObj!"); + rPts.clear(); + bChg = true; + } + } + } + + // GluePoints + { + SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + if (pGPL!=nullptr) { + // Remove invalid selected gluepoints, that is, all entries + // (IDs) that aren't contained in the GluePointList of the + // object + for(SdrUShortCont::const_iterator it = rPts.begin(); it != rPts.end(); ) + { + sal_uInt16 nId=*it; + if (pGPL->FindGluePoint(nId)==SDRGLUEPOINT_NOTFOUND) { + it = rPts.erase(it); + bChg=true; + } + else + ++it; + } + } else { + if (!rPts.empty()) { + rPts.clear(); // object doesn't have any gluepoints (any more) + bChg=true; + } + } + } + } + if (bChg) const_cast(this)->mbMarkedPointsRectsDirty=true; + const_cast(this)->mbMrkPntDirty=false; +} + + +bool SdrMarkView::HasMarkableGluePoints() const +{ + bool bRet=false; + if (IsGluePointEditMode()) { + ForceUndirtyMrkPnt(); + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + + // #i38892# + if(pGPL && pGPL->GetCount()) + { + for(sal_uInt16 a(0); !bRet && a < pGPL->GetCount(); a++) + { + if((*pGPL)[a].IsUserDefined()) + { + bRet = true; + } + } + } + } + } + return bRet; +} + +bool SdrMarkView::HasMarkedGluePoints() const +{ + ForceUndirtyMrkPnt(); + bool bRet=false; + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nMarkNum=0; nMarkNumGetMarkedGluePoints(); + bRet = !rPts.empty(); + } + return bRet; +} + +bool SdrMarkView::MarkGluePoints(const tools::Rectangle* pRect, bool bUnmark) +{ + if (!IsGluePointEditMode() && !bUnmark) return false; + ForceUndirtyMrkPnt(); + bool bChgd=false; + SortMarkedObjects(); + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nMarkNum=0; nMarkNumGetMarkedSdrObj(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + if (bUnmark && pRect==nullptr) { // UnmarkAll + if (!rPts.empty()) { + rPts.clear(); + bChgd=true; + } + } else { + if (pGPL!=nullptr) { + sal_uInt16 nGluePointCnt=pGPL->GetCount(); + for (sal_uInt16 nGPNum=0; nGPNumContains(aPos)) { + bool bContains = rPts.find( rGP.GetId() ) != rPts.end(); + if (!bUnmark && !bContains) { + bChgd=true; + rPts.insert(rGP.GetId()); + } + if (bUnmark && bContains) { + bChgd=true; + rPts.erase(rGP.GetId()); + } + } + } + } + } + } + } + if (bChgd) { + AdjustMarkHdl(); + MarkListHasChanged(); + } + return bChgd; +} + +bool SdrMarkView::PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV) const +{ + rpObj=nullptr; rpPV=nullptr; rnId=0; + if (!IsGluePointEditMode()) return false; + OutputDevice* pOut=mpActualOutDev.get(); + if (pOut==nullptr) pOut=GetFirstOutputDevice(); + if (pOut==nullptr) return false; + SortMarkedObjects(); + const size_t nMarkCount=GetMarkedObjectCount(); + size_t nMarkNum=nMarkCount; + while (nMarkNum>0) { + nMarkNum--; + const SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrPageView* pPV=pM->GetPageView(); + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + if (pGPL!=nullptr) { + sal_uInt16 nNum=pGPL->HitTest(rPnt,*pOut,pObj); + if (nNum!=SDRGLUEPOINT_NOTFOUND) + { + // #i38892# + const SdrGluePoint& rCandidate = (*pGPL)[nNum]; + + if(rCandidate.IsUserDefined()) + { + rpObj=pObj; + rnId=(*pGPL)[nNum].GetId(); + rpPV=pPV; + return true; + } + } + } + } + return false; +} + +bool SdrMarkView::MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, bool bUnmark) +{ + if (!IsGluePointEditMode()) return false; + ForceUndirtyMrkPnt(); + bool bChgd=false; + if (pObj!=nullptr) { + const size_t nMarkPos=TryToFindMarkedObject(pObj); + if (nMarkPos!=SAL_MAX_SIZE) { + SdrMark* pM=GetSdrMarkByIndex(nMarkPos); + SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + bool bContains = rPts.find( nId ) != rPts.end(); + if (!bUnmark && !bContains) { + bChgd=true; + rPts.insert(nId); + } + if (bUnmark && bContains) { + bChgd=true; + rPts.erase(nId); + } + } else { + // TODO: implement implicit selection of objects + } + } + if (bChgd) { + AdjustMarkHdl(); + MarkListHasChanged(); + } + return bChgd; +} + +bool SdrMarkView::IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const +{ + ForceUndirtyMrkPnt(); + bool bRet=false; + const size_t nPos=TryToFindMarkedObject(pObj); // casting to NonConst + if (nPos!=SAL_MAX_SIZE) { + const SdrMark* pM=GetSdrMarkByIndex(nPos); + const SdrUShortCont& rPts = pM->GetMarkedGluePoints(); + bRet = rPts.find( nId ) != rPts.end(); + } + return bRet; +} + +SdrHdl* SdrMarkView::GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const +{ + ForceUndirtyMrkPnt(); + const size_t nHdlCnt=maHdlList.GetHdlCount(); + for (size_t nHdlNum=0; nHdlNumGetObj()==pObj && + pHdl->GetKind()==SdrHdlKind::Glue && + pHdl->GetObjHdlNum()==nId ) return pHdl; + } + return nullptr; +} + +void SdrMarkView::MarkNextGluePoint() +{ + ForceUndirtyMrkPnt(); + SortMarkedObjects(); +} + +const tools::Rectangle& SdrMarkView::GetMarkedGluePointsRect() const +{ + ForceUndirtyMrkPnt(); + if (mbMarkedPointsRectsDirty) ImpSetPointsRects(); + return maMarkedGluePointsRect; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoashp.cxx b/svx/source/svdraw/svdoashp.cxx new file mode 100644 index 0000000000..eeaa557157 --- /dev/null +++ b/svx/source/svdraw/svdoashp.cxx @@ -0,0 +1,3267 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "presetooxhandleadjustmentrelations.hxx" +#include + +using namespace ::com::sun::star; + +static void lcl_ShapeSegmentFromBinary( drawing::EnhancedCustomShapeSegment& rSegInfo, sal_uInt16 nSDat ) +{ + switch( nSDat >> 8 ) + { + case 0x00 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::LINETO; + rSegInfo.Count = nSDat & 0xff; + if ( !rSegInfo.Count ) + rSegInfo.Count = 1; + break; + case 0x20 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::CURVETO; + rSegInfo.Count = nSDat & 0xff; + if ( !rSegInfo.Count ) + rSegInfo.Count = 1; + break; + case 0x40 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::MOVETO; + rSegInfo.Count = nSDat & 0xff; + if ( !rSegInfo.Count ) + rSegInfo.Count = 1; + break; + case 0x60 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH; + rSegInfo.Count = 0; + break; + case 0x80 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH; + rSegInfo.Count = 0; + break; + case 0xa1 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO; + rSegInfo.Count = ( nSDat & 0xff ) / 3; + break; + case 0xa2 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE; + rSegInfo.Count = ( nSDat & 0xff ) / 3; + break; + case 0xa3 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ARCTO; + rSegInfo.Count = ( nSDat & 0xff ) >> 2; + break; + case 0xa4 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ARC; + rSegInfo.Count = ( nSDat & 0xff ) >> 2; + break; + case 0xa5 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO; + rSegInfo.Count = ( nSDat & 0xff ) >> 2; + break; + case 0xa6 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC; + rSegInfo.Count = ( nSDat & 0xff ) >> 2; + break; + case 0xa7 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX; + rSegInfo.Count = nSDat & 0xff; + break; + case 0xa8 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY; + rSegInfo.Count = nSDat & 0xff; + break; + case 0xaa : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::NOFILL; + rSegInfo.Count = 0; + break; + case 0xab : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE; + rSegInfo.Count = 0; + break; + default: + case 0xf8 : + rSegInfo.Command = drawing::EnhancedCustomShapeSegmentCommand::UNKNOWN; + rSegInfo.Count = nSDat; + break; + } +} + +static MSO_SPT ImpGetCustomShapeType( const SdrObjCustomShape& rCustoShape ) +{ + MSO_SPT eRetValue = mso_sptNil; + + OUString aEngine( rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ).GetValue() ); + if ( aEngine.isEmpty() || aEngine == "com.sun.star.drawing.EnhancedCustomShapeEngine" ) + { + OUString sShapeType; + const SdrCustomShapeGeometryItem& rGeometryItem( rCustoShape.GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( "Type" ); + if ( pAny && ( *pAny >>= sShapeType ) ) + eRetValue = EnhancedCustomShapeTypeNames::Get( sShapeType ); + } + return eRetValue; +}; + +static bool ImpVerticalSwitch( const SdrObjCustomShape& rCustoShape ) +{ + bool bRet = false; + MSO_SPT eShapeType( ImpGetCustomShapeType( rCustoShape ) ); + switch( eShapeType ) + { + case mso_sptAccentBorderCallout90 : // 2 ortho + case mso_sptBorderCallout1 : // 2 diag + case mso_sptBorderCallout2 : // 3 + { + bRet = true; + } + break; + default: break; + } + return bRet; +} + +// #i37011# create a clone with all attributes changed to shadow attributes +// and translation executed, too. +static rtl::Reference ImpCreateShadowObjectClone(const SdrObject& rOriginal, const SfxItemSet& rOriginalSet) +{ + rtl::Reference pRetval; + const bool bShadow(rOriginalSet.Get(SDRATTR_SHADOW).GetValue()); + + if(bShadow) + { + // create a shadow representing object + const sal_Int32 nXDist(rOriginalSet.Get(SDRATTR_SHADOWXDIST).GetValue()); + const sal_Int32 nYDist(rOriginalSet.Get(SDRATTR_SHADOWYDIST).GetValue()); + const ::Color aShadowColor(rOriginalSet.Get(SDRATTR_SHADOWCOLOR).GetColorValue()); + const sal_uInt16 nShadowTransparence(rOriginalSet.Get(SDRATTR_SHADOWTRANSPARENCE).GetValue()); + pRetval = rOriginal.CloneSdrObject(rOriginal.getSdrModelFromSdrObject()); + DBG_ASSERT(pRetval, "ImpCreateShadowObjectClone: Could not clone object (!)"); + + // look for used stuff + SdrObjListIter aIterator(rOriginal); + bool bLineUsed(false); + bool bAllFillUsed(false); + bool bSolidFillUsed(false); + bool bGradientFillUsed(false); + bool bHatchFillUsed(false); + bool bBitmapFillUsed(false); + + while(aIterator.IsMore()) + { + SdrObject* pObj = aIterator.Next(); + drawing::FillStyle eFillStyle = pObj->GetMergedItem(XATTR_FILLSTYLE).GetValue(); + + if(!bLineUsed) + { + drawing::LineStyle eLineStyle = pObj->GetMergedItem(XATTR_LINESTYLE).GetValue(); + + if(drawing::LineStyle_NONE != eLineStyle) + { + bLineUsed = true; + } + } + + if(!bAllFillUsed) + { + if(!bSolidFillUsed && drawing::FillStyle_SOLID == eFillStyle) + { + bSolidFillUsed = true; + bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed); + } + if(!bGradientFillUsed && drawing::FillStyle_GRADIENT == eFillStyle) + { + bGradientFillUsed = true; + bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed); + } + if(!bHatchFillUsed && drawing::FillStyle_HATCH == eFillStyle) + { + bHatchFillUsed = true; + bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed); + } + if(!bBitmapFillUsed && drawing::FillStyle_BITMAP == eFillStyle) + { + bBitmapFillUsed = true; + bAllFillUsed = (bSolidFillUsed && bGradientFillUsed && bHatchFillUsed && bBitmapFillUsed); + } + } + } + + // translate to shadow coordinates + pRetval->NbcMove(Size(nXDist, nYDist)); + + // set items as needed + SfxItemSet aTempSet(rOriginalSet); + + // if a SvxWritingModeItem (Top->Bottom) is set the text object + // is creating a paraobject, but paraobjects can not be created without model. So + // we are preventing the crash by setting the writing mode always left to right, + // this is not bad since our shadow geometry does not contain text. + aTempSet.Put(SvxWritingModeItem(text::WritingMode_LR_TB, SDRATTR_TEXTDIRECTION)); + + // no shadow + aTempSet.Put(makeSdrShadowItem(false)); + aTempSet.Put(makeSdrShadowXDistItem(0)); + aTempSet.Put(makeSdrShadowYDistItem(0)); + + // line color and transparency like shadow + if(bLineUsed) + { + aTempSet.Put(XLineColorItem(OUString(), aShadowColor)); + aTempSet.Put(XLineTransparenceItem(nShadowTransparence)); + } + + // fill color and transparency like shadow + if(bSolidFillUsed) + { + aTempSet.Put(XFillColorItem(OUString(), aShadowColor)); + aTempSet.Put(XFillTransparenceItem(nShadowTransparence)); + } + + // gradient and transparency like shadow + if(bGradientFillUsed) + { + basegfx::BGradient aGradient(rOriginalSet.Get(XATTR_FILLGRADIENT).GetGradientValue()); + sal_uInt8 nStartLuminance(Color(aGradient.GetColorStops().front().getStopColor()).GetLuminance()); + sal_uInt8 nEndLuminance(Color(aGradient.GetColorStops().back().getStopColor()).GetLuminance()); + + if(aGradient.GetStartIntens() != 100) + { + nStartLuminance = static_cast(nStartLuminance * (static_cast(aGradient.GetStartIntens()) / 100.0)); + } + + if(aGradient.GetEndIntens() != 100) + { + nEndLuminance = static_cast(nEndLuminance * (static_cast(aGradient.GetEndIntens()) / 100.0)); + } + + ::Color aStartColor( + static_cast((nStartLuminance * aShadowColor.GetRed()) / 256), + static_cast((nStartLuminance * aShadowColor.GetGreen()) / 256), + static_cast((nStartLuminance * aShadowColor.GetBlue()) / 256)); + + ::Color aEndColor( + static_cast((nEndLuminance * aShadowColor.GetRed()) / 256), + static_cast((nEndLuminance * aShadowColor.GetGreen()) / 256), + static_cast((nEndLuminance * aShadowColor.GetBlue()) / 256)); + + aGradient.SetColorStops( + basegfx::BColorStops( + aStartColor.getBColor(), + aEndColor.getBColor())); + aTempSet.Put(XFillGradientItem(aGradient)); + aTempSet.Put(XFillTransparenceItem(nShadowTransparence)); + } + + // hatch and transparency like shadow + if(bHatchFillUsed) + { + XHatch aHatch(rOriginalSet.Get(XATTR_FILLHATCH).GetHatchValue()); + aHatch.SetColor(aShadowColor); + aTempSet.Put(XFillHatchItem(aHatch)); + aTempSet.Put(XFillTransparenceItem(nShadowTransparence)); + } + + // bitmap and transparency like shadow + if(bBitmapFillUsed) + { + GraphicObject aGraphicObject(rOriginalSet.Get(XATTR_FILLBITMAP).GetGraphicObject()); + BitmapEx aBitmapEx(aGraphicObject.GetGraphic().GetBitmapEx()); + + if(!aBitmapEx.IsEmpty()) + { + ScopedVclPtr pVirDev(VclPtr::Create()); + pVirDev->SetOutputSizePixel(aBitmapEx.GetSizePixel()); + BitmapFilter::Filter(aBitmapEx, BitmapShadowFilter(aShadowColor)); + pVirDev->DrawBitmapEx(Point(), aBitmapEx); + aGraphicObject.SetGraphic(Graphic(pVirDev->GetBitmapEx(Point(0,0), aBitmapEx.GetSizePixel()))); + } + + aTempSet.Put(XFillBitmapItem(aGraphicObject)); + aTempSet.Put(XFillTransparenceItem(nShadowTransparence)); + } + + // set attributes and paint shadow object + pRetval->SetMergedItemSet( aTempSet ); + } + return pRetval; +} + + +uno::Reference const & SdrObjCustomShape::GetCustomShapeEngine() const +{ + if (mxCustomShapeEngine.is()) + return mxCustomShapeEngine; + + uno::Reference aXShape = GetXShapeForSdrObject(const_cast(this)); + if ( !aXShape ) + return mxCustomShapeEngine; + + uno::Reference xContext( ::comphelper::getProcessComponentContext() ); + + OUString aEngine(GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ).GetValue()); + static constexpr OUStringLiteral sEnhancedCustomShapeEngine = u"com.sun.star.drawing.EnhancedCustomShapeEngine"; + if ( aEngine.isEmpty() ) + aEngine = sEnhancedCustomShapeEngine; + + { + static constexpr OUString sCustomShape = u"CustomShape"_ustr; + uno::Sequence aPropValues{ comphelper::makePropertyValue(sCustomShape, + aXShape) }; + uno::Sequence aArgument{ uno::Any(aPropValues) }; + try + { + uno::Reference xInterface(xContext->getServiceManager()->createInstanceWithArgumentsAndContext(aEngine, aArgument, xContext)); + if (xInterface.is()) + mxCustomShapeEngine.set(xInterface, uno::UNO_QUERY); + } + catch (const loader::CannotActivateFactoryException&) + { + } + } + + return mxCustomShapeEngine; +} + +const SdrObject* SdrObjCustomShape::GetSdrObjectFromCustomShape() const +{ + if ( !mXRenderedCustomShape.is() ) + { + uno::Reference xCustomShapeEngine( GetCustomShapeEngine() ); + if ( xCustomShapeEngine.is() ) + const_cast(this)->mXRenderedCustomShape = xCustomShapeEngine->render(); + } + SdrObject* pRenderedCustomShape = mXRenderedCustomShape.is() + ? SdrObject::getSdrObjectFromXShape( mXRenderedCustomShape ) + : nullptr; + return pRenderedCustomShape; +} + +// #i37011# Shadow geometry creation +const SdrObject* SdrObjCustomShape::GetSdrObjectShadowFromCustomShape() const +{ + if(!mpLastShadowGeometry) + { + const SdrObject* pSdrObject = GetSdrObjectFromCustomShape(); + if(pSdrObject) + { + const SfxItemSet& rOriginalSet = GetObjectItemSet(); + const bool bShadow(rOriginalSet.Get( SDRATTR_SHADOW ).GetValue()); + + if(bShadow) + { + // create a clone with all attributes changed to shadow attributes + // and translation executed, too. + const_cast(this)->mpLastShadowGeometry = + ImpCreateShadowObjectClone(*pSdrObject, rOriginalSet); + } + } + } + + return mpLastShadowGeometry.get(); +} + +bool SdrObjCustomShape::IsTextPath() const +{ + static constexpr OUString sTextPath( u"TextPath"_ustr ); + bool bTextPathOn = false; + const SdrCustomShapeGeometryItem& rGeometryItem = GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sTextPath, sTextPath ); + if ( pAny ) + *pAny >>= bTextPathOn; + return bTextPathOn; +} + +bool SdrObjCustomShape::UseNoFillStyle() const +{ + bool bRet = false; + OUString sShapeType; + static constexpr OUString sType( u"Type"_ustr ); + const SdrCustomShapeGeometryItem& rGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sType ); + if ( pAny ) + *pAny >>= sShapeType; + bRet = !IsCustomShapeFilledByDefault( EnhancedCustomShapeTypeNames::Get( sType ) ); + + return bRet; +} + +bool SdrObjCustomShape::IsMirroredX() const +{ + bool bMirroredX = false; + const SdrCustomShapeGeometryItem & rGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( "MirroredX" ); + if ( pAny ) + *pAny >>= bMirroredX; + return bMirroredX; +} +bool SdrObjCustomShape::IsMirroredY() const +{ + bool bMirroredY = false; + const SdrCustomShapeGeometryItem & rGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( "MirroredY" ); + if ( pAny ) + *pAny >>= bMirroredY; + return bMirroredY; +} +void SdrObjCustomShape::SetMirroredX( const bool bMirrorX ) +{ + SdrCustomShapeGeometryItem aGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + beans::PropertyValue aPropVal; + aPropVal.Name = "MirroredX"; + aPropVal.Value <<= bMirrorX; + aGeometryItem.SetPropertyValue( aPropVal ); + SetMergedItem( aGeometryItem ); +} +void SdrObjCustomShape::SetMirroredY( const bool bMirrorY ) +{ + SdrCustomShapeGeometryItem aGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + beans::PropertyValue aPropVal; + aPropVal.Name = "MirroredY"; + aPropVal.Value <<= bMirrorY; + aGeometryItem.SetPropertyValue( aPropVal ); + SetMergedItem( aGeometryItem ); +} + +double SdrObjCustomShape::GetExtraTextRotation( const bool bPreRotation ) const +{ + double fExtraTextRotateAngle = 0.0; + if (bPreRotation) + { + // textPreRotateAngle might be set by macro or diagram (SmartArt) import + const uno::Any* pAny; + const SdrCustomShapeGeometryItem& rGeometryItem = GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ); + pAny = rGeometryItem.GetPropertyValueByName(u"TextPreRotateAngle"_ustr); + if ( pAny ) + *pAny >>= fExtraTextRotateAngle; + + // As long as the edit engine is not able to render these text directions we + // emulate them by setting a suitable text pre-rotation. + const SvxFrameDirectionItem& rDirectionItem = GetMergedItem(SDRATTR_WRITINGMODE2); + if (rDirectionItem.GetValue() == SvxFrameDirection::Vertical_RL_TB90) + fExtraTextRotateAngle -= 90; + else if (rDirectionItem.GetValue() == SvxFrameDirection::Vertical_LR_BT) + fExtraTextRotateAngle -=270; + } + else + { + const uno::Any* pAny; + const SdrCustomShapeGeometryItem& rGeometryItem = GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ); + pAny = rGeometryItem.GetPropertyValueByName(u"TextRotateAngle"_ustr); + if ( pAny ) + *pAny >>= fExtraTextRotateAngle; + } + return fExtraTextRotateAngle; +} + +bool SdrObjCustomShape::GetTextBounds( tools::Rectangle& rTextBound ) const +{ + bool bRet = false; + + uno::Reference xCustomShapeEngine( GetCustomShapeEngine() ); + if ( xCustomShapeEngine.is() ) + { + awt::Rectangle aR( xCustomShapeEngine->getTextBounds() ); + if ( aR.Width > 1 && aR.Height > 1 ) + { + rTextBound = tools::Rectangle( Point( aR.X, aR.Y ), Size( aR.Width, aR.Height ) ); + bRet = true; + } + } + return bRet; +} +basegfx::B2DPolyPolygon SdrObjCustomShape::GetLineGeometry( const bool bBezierAllowed ) const +{ + basegfx::B2DPolyPolygon aRetval; + uno::Reference xCustomShapeEngine( GetCustomShapeEngine() ); + if ( xCustomShapeEngine.is() ) + { + drawing::PolyPolygonBezierCoords aBezierCoords = xCustomShapeEngine->getLineGeometry(); + try + { + aRetval = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( aBezierCoords ); + if ( !bBezierAllowed && aRetval.areControlPointsUsed()) + { + aRetval = basegfx::utils::adaptiveSubdivideByAngle(aRetval); + } + } + catch ( const lang::IllegalArgumentException & ) + { + } + } + return aRetval; +} + +std::vector< SdrCustomShapeInteraction > SdrObjCustomShape::GetInteractionHandles() const +{ + std::vector< SdrCustomShapeInteraction > aRet; + try + { + uno::Reference xCustomShapeEngine( GetCustomShapeEngine() ); + if ( xCustomShapeEngine.is() ) + { + int i; + uno::Sequence> xInteractionHandles( xCustomShapeEngine->getInteraction() ); + for ( i = 0; i < xInteractionHandles.getLength(); i++ ) + { + if ( xInteractionHandles[ i ].is() ) + { + SdrCustomShapeInteraction aSdrCustomShapeInteraction; + aSdrCustomShapeInteraction.xInteraction = xInteractionHandles[ i ]; + aSdrCustomShapeInteraction.aPosition = xInteractionHandles[ i ]->getPosition(); + + CustomShapeHandleModes nMode = CustomShapeHandleModes::NONE; + switch( ImpGetCustomShapeType( *this ) ) + { + case mso_sptAccentBorderCallout90 : // 2 ortho + { + if (i == 0) + nMode |= CustomShapeHandleModes::RESIZE_FIXED | CustomShapeHandleModes::CREATE_FIXED; + else if (i == 1) + nMode |= CustomShapeHandleModes::RESIZE_ABSOLUTE_X | CustomShapeHandleModes::RESIZE_ABSOLUTE_Y | CustomShapeHandleModes::MOVE_SHAPE | CustomShapeHandleModes::ORTHO4; + } + break; + + case mso_sptChevron : + case mso_sptHomePlate : + nMode |= CustomShapeHandleModes::RESIZE_ABSOLUTE_NEGX; + break; + + case mso_sptWedgeRectCallout : + case mso_sptWedgeRRectCallout : + case mso_sptCloudCallout : + case mso_sptWedgeEllipseCallout : + { + if (i == 0) + nMode |= CustomShapeHandleModes::RESIZE_FIXED; + } + break; + + case mso_sptBorderCallout1 : // 2 diag + { + if (i == 0) + nMode |= CustomShapeHandleModes::RESIZE_FIXED | CustomShapeHandleModes::CREATE_FIXED; + else if (i == 1) + nMode |= CustomShapeHandleModes::RESIZE_ABSOLUTE_X | CustomShapeHandleModes::RESIZE_ABSOLUTE_Y | CustomShapeHandleModes::MOVE_SHAPE; + } + break; + case mso_sptBorderCallout2 : // 3 + { + if (i == 0) + nMode |= CustomShapeHandleModes::RESIZE_FIXED | CustomShapeHandleModes::CREATE_FIXED; + else if (i == 2) + nMode |= CustomShapeHandleModes::RESIZE_ABSOLUTE_X | CustomShapeHandleModes::RESIZE_ABSOLUTE_Y | CustomShapeHandleModes::MOVE_SHAPE; + } + break; + case mso_sptCallout90 : + case mso_sptAccentCallout90 : + case mso_sptBorderCallout90 : + case mso_sptCallout1 : + case mso_sptCallout2 : + case mso_sptCallout3 : + case mso_sptAccentCallout1 : + case mso_sptAccentCallout2 : + case mso_sptAccentCallout3 : + case mso_sptBorderCallout3 : + case mso_sptAccentBorderCallout1 : + case mso_sptAccentBorderCallout2 : + case mso_sptAccentBorderCallout3 : + { + if (i == 0) + nMode |= CustomShapeHandleModes::RESIZE_FIXED | CustomShapeHandleModes::CREATE_FIXED; + } + break; + default: break; + } + aSdrCustomShapeInteraction.nMode = nMode; + aRet.push_back( aSdrCustomShapeInteraction ); + } + } + } + } + catch( const uno::RuntimeException& ) + { + } + return aRet; +} + + +// BaseProperties section +#define DEFAULT_MINIMUM_SIGNED_COMPARE (sal_Int32(0x80000000)) +#define DEFAULT_MAXIMUM_SIGNED_COMPARE (sal_Int32(0x7fffffff)) + +static sal_Int32 GetNumberOfProperties ( const SvxMSDffHandle* pData ) +{ + sal_Int32 nPropertiesNeeded=1; // position is always needed + SvxMSDffHandleFlags nFlags = pData->nFlags; + + if ( nFlags & SvxMSDffHandleFlags::MIRRORED_X ) + nPropertiesNeeded++; + if ( nFlags & SvxMSDffHandleFlags::MIRRORED_Y ) + nPropertiesNeeded++; + if ( nFlags & SvxMSDffHandleFlags::SWITCHED ) + nPropertiesNeeded++; + if ( nFlags & SvxMSDffHandleFlags::POLAR ) + { + nPropertiesNeeded++; + if ( nFlags & SvxMSDffHandleFlags::RADIUS_RANGE ) + { + if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + } + } + else if ( nFlags & SvxMSDffHandleFlags::RANGE ) + { + if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + nPropertiesNeeded++; + } + + return nPropertiesNeeded; +} + +static void lcl_ShapePropertiesFromDFF( const SvxMSDffHandle* pData, beans::PropertyValues& rPropValues ) +{ + SvxMSDffHandleFlags nFlags = pData->nFlags; + sal_Int32 n=0; + auto pPropValues = rPropValues.getArray(); + + // POSITION + { + drawing::EnhancedCustomShapeParameterPair aPosition; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.First, pData->nPositionX, true, true ); + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aPosition.Second, pData->nPositionY, true, false ); + pPropValues[ n ].Name = "Position"; + pPropValues[ n++ ].Value <<= aPosition; + } + if ( nFlags & SvxMSDffHandleFlags::MIRRORED_X ) + { + pPropValues[ n ].Name = "MirroredX"; + pPropValues[ n++ ].Value <<= true; + } + if ( nFlags & SvxMSDffHandleFlags::MIRRORED_Y ) + { + pPropValues[ n ].Name = "MirroredY"; + pPropValues[ n++ ].Value <<= true; + } + if ( nFlags & SvxMSDffHandleFlags::SWITCHED ) + { + pPropValues[ n ].Name = "Switched"; + pPropValues[ n++ ].Value <<= true; + } + if ( nFlags & SvxMSDffHandleFlags::POLAR ) + { + drawing::EnhancedCustomShapeParameterPair aCenter; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.First, pData->nCenterX, + bool( nFlags & SvxMSDffHandleFlags::CENTER_X_IS_SPECIAL ), true ); + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aCenter.Second, pData->nCenterY, + bool( nFlags & SvxMSDffHandleFlags::CENTER_Y_IS_SPECIAL ), false ); + pPropValues[ n ].Name = "Polar"; + pPropValues[ n++ ].Value <<= aCenter; + if ( nFlags & SvxMSDffHandleFlags::RADIUS_RANGE ) + { + if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMinimum, pData->nRangeXMin, + bool( nFlags & SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL ), true ); + pPropValues[ n ].Name = "RadiusRangeMinimum"; + pPropValues[ n++ ].Value <<= aRadiusRangeMinimum; + } + if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRadiusRangeMaximum, pData->nRangeXMax, + bool( nFlags & SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL ), false ); + pPropValues[ n ].Name = "RadiusRangeMaximum"; + pPropValues[ n++ ].Value <<= aRadiusRangeMaximum; + } + } + } + else if ( nFlags & SvxMSDffHandleFlags::RANGE ) + { + if ( pData->nRangeXMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRangeXMinimum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMinimum, pData->nRangeXMin, + bool( nFlags & SvxMSDffHandleFlags::RANGE_X_MIN_IS_SPECIAL ), true ); + pPropValues[ n ].Name = "RangeXMinimum"; + pPropValues[ n++ ].Value <<= aRangeXMinimum; + } + if ( pData->nRangeXMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRangeXMaximum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeXMaximum, pData->nRangeXMax, + bool( nFlags & SvxMSDffHandleFlags::RANGE_X_MAX_IS_SPECIAL ), false ); + pPropValues[ n ].Name = "RangeXMaximum"; + pPropValues[ n++ ].Value <<= aRangeXMaximum; + } + if ( pData->nRangeYMin != DEFAULT_MINIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRangeYMinimum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMinimum, pData->nRangeYMin, + bool( nFlags & SvxMSDffHandleFlags::RANGE_Y_MIN_IS_SPECIAL ), true ); + pPropValues[ n ].Name = "RangeYMinimum"; + pPropValues[ n++ ].Value <<= aRangeYMinimum; + } + if ( pData->nRangeYMax != DEFAULT_MAXIMUM_SIGNED_COMPARE ) + { + drawing::EnhancedCustomShapeParameter aRangeYMaximum; + EnhancedCustomShape2d::SetEnhancedCustomShapeHandleParameter( aRangeYMaximum, pData->nRangeYMax, + bool( nFlags & SvxMSDffHandleFlags::RANGE_Y_MAX_IS_SPECIAL ), false ); + pPropValues[ n ].Name = "RangeYMaximum"; + pPropValues[ n++ ].Value <<= aRangeYMaximum; + } + } +} + +std::unique_ptr SdrObjCustomShape::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + +SdrObjCustomShape::SdrObjCustomShape(SdrModel& rSdrModel) +: SdrTextObj(rSdrModel) + , m_fObjectRotation(0.0) + , mbAdjustingTextFrameWidthAndHeight(false) +{ + m_bClosedObj = true; // custom shapes may be filled + mbTextFrame = true; +} + +SdrObjCustomShape::SdrObjCustomShape(SdrModel& rSdrModel, SdrObjCustomShape const & rSource) +: SdrTextObj(rSdrModel, rSource) + , m_fObjectRotation(0.0) + , mbAdjustingTextFrameWidthAndHeight(false) +{ + m_bClosedObj = true; // custom shapes may be filled + mbTextFrame = true; + + m_fObjectRotation = rSource.m_fObjectRotation; + mbAdjustingTextFrameWidthAndHeight = rSource.mbAdjustingTextFrameWidthAndHeight; + assert(!mbAdjustingTextFrameWidthAndHeight); + InvalidateRenderGeometry(); +} + +SdrObjCustomShape::~SdrObjCustomShape() +{ + // delete buffered display geometry + InvalidateRenderGeometry(); +} + +void SdrObjCustomShape::MergeDefaultAttributes( const OUString* pType ) +{ + beans::PropertyValue aPropVal; + OUString sShapeType; + static constexpr OUString sType( u"Type"_ustr ); + SdrCustomShapeGeometryItem aGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + if ( pType && !pType->isEmpty() ) + { + sal_Int32 nType = pType->toInt32(); + if ( nType ) + sShapeType = EnhancedCustomShapeTypeNames::Get( static_cast< MSO_SPT >( nType ) ); + else + sShapeType = *pType; + + aPropVal.Name = sType; + aPropVal.Value <<= sShapeType; + aGeometryItem.SetPropertyValue( aPropVal ); + } + else + { + uno::Any *pAny = aGeometryItem.GetPropertyValueByName( sType ); + if ( pAny ) + *pAny >>= sShapeType; + } + MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType ); + + const sal_Int32* pDefData = nullptr; + const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType ); + if ( pDefCustomShape ) + pDefData = pDefCustomShape->pDefData; + + uno::Sequence seqAdjustmentValues; + + + // AdjustmentValues + + static constexpr OUString sAdjustmentValues( u"AdjustmentValues"_ustr ); + const uno::Any* pAny = aGeometryItem.GetPropertyValueByName( sAdjustmentValues ); + if ( pAny ) + *pAny >>= seqAdjustmentValues; + if ( pDefCustomShape && pDefData ) // now check if we have to default some adjustment values + { + // first check if there are adjustment values are to be appended + sal_Int32 i, nAdjustmentValues = seqAdjustmentValues.getLength(); + sal_Int32 nAdjustmentDefaults = *pDefData++; + if ( nAdjustmentDefaults > nAdjustmentValues ) + seqAdjustmentValues.realloc( nAdjustmentDefaults ); + auto pseqAdjustmentValues = seqAdjustmentValues.getArray(); + for ( i = nAdjustmentValues; i < nAdjustmentDefaults; i++ ) + { + pseqAdjustmentValues[ i ].Value <<= pDefData[ i ]; + pseqAdjustmentValues[ i ].State = beans::PropertyState_DIRECT_VALUE; + } + // check if there are defaulted adjustment values that should be filled the hard coded defaults (pDefValue) + sal_Int32 nCount = std::min(nAdjustmentValues, nAdjustmentDefaults); + for ( i = 0; i < nCount; i++ ) + { + if ( seqAdjustmentValues[ i ].State != beans::PropertyState_DIRECT_VALUE ) + { + pseqAdjustmentValues[ i ].Value <<= pDefData[ i ]; + pseqAdjustmentValues[ i ].State = beans::PropertyState_DIRECT_VALUE; + } + } + } + aPropVal.Name = sAdjustmentValues; + aPropVal.Value <<= seqAdjustmentValues; + aGeometryItem.SetPropertyValue( aPropVal ); + + + // Coordsize + + static constexpr OUString sViewBox( u"ViewBox"_ustr ); + const uno::Any* pViewBox = aGeometryItem.GetPropertyValueByName( sViewBox ); + awt::Rectangle aViewBox; + if ( !pViewBox || !(*pViewBox >>= aViewBox ) ) + { + if ( pDefCustomShape ) + { + aViewBox.X = 0; + aViewBox.Y = 0; + aViewBox.Width = pDefCustomShape->nCoordWidth; + aViewBox.Height= pDefCustomShape->nCoordHeight; + aPropVal.Name = sViewBox; + aPropVal.Value <<= aViewBox; + aGeometryItem.SetPropertyValue( aPropVal ); + } + } + + static constexpr OUString sPath( u"Path"_ustr ); + + + // Path/Coordinates + + static constexpr OUString sCoordinates( u"Coordinates"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sCoordinates ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices ) + { + sal_Int32 i, nCount = pDefCustomShape->nVertices; + uno::Sequence seqCoordinates( nCount ); + auto pseqCoordinates = seqCoordinates.getArray(); + for ( i = 0; i < nCount; i++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqCoordinates[ i ].First, pDefCustomShape->pVertices[ i ].nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqCoordinates[ i ].Second, pDefCustomShape->pVertices[ i ].nValB ); + } + aPropVal.Name = sCoordinates; + aPropVal.Value <<= seqCoordinates; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + + // Path/GluePoints + static constexpr OUString sGluePoints( u"GluePoints"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sGluePoints ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints ) + { + sal_Int32 i, nCount = pDefCustomShape->nGluePoints; + uno::Sequence seqGluePoints( nCount ); + auto pseqGluePoints = seqGluePoints.getArray(); + for ( i = 0; i < nCount; i++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqGluePoints[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqGluePoints[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB ); + } + aPropVal.Name = sGluePoints; + aPropVal.Value <<= seqGluePoints; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + + // Path/Segments + static constexpr OUString sSegments( u"Segments"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sSegments ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements ) + { + sal_Int32 i, nCount = pDefCustomShape->nElements; + uno::Sequence seqSegments( nCount ); + auto pseqSegments = seqSegments.getArray(); + for ( i = 0; i < nCount; i++ ) + { + drawing::EnhancedCustomShapeSegment& rSegInfo = pseqSegments[ i ]; + sal_uInt16 nSDat = pDefCustomShape->pElements[ i ]; + lcl_ShapeSegmentFromBinary( rSegInfo, nSDat ); + } + aPropVal.Name = sSegments; + aPropVal.Value <<= seqSegments; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + + // Path/StretchX + static constexpr OUString sStretchX( u"StretchX"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sStretchX ); + if ( !pAny && pDefCustomShape ) + { + sal_Int32 nXRef = pDefCustomShape->nXRef; + if ( nXRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) + { + aPropVal.Name = sStretchX; + aPropVal.Value <<= nXRef; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + } + + // Path/StretchY + static constexpr OUString sStretchY( u"StretchY"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sStretchY ); + if ( !pAny && pDefCustomShape ) + { + sal_Int32 nYRef = pDefCustomShape->nYRef; + if ( nYRef != DEFAULT_MINIMUM_SIGNED_COMPARE ) + { + aPropVal.Name = sStretchY; + aPropVal.Value <<= nYRef; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + } + + // Path/TextFrames + static constexpr OUString sTextFrames( u"TextFrames"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sPath, sTextFrames ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect ) + { + sal_Int32 i, nCount = pDefCustomShape->nTextRect; + uno::Sequence seqTextFrames( nCount ); + auto pseqTextFrames = seqTextFrames.getArray(); + const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect; + for ( i = 0; i < nCount; i++, pRectangles++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames[ i ].TopLeft.First, pRectangles->nPairA.nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames[ i ].TopLeft.Second, pRectangles->nPairA.nValB ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames[ i ].BottomRight.First, pRectangles->nPairB.nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames[ i ].BottomRight.Second, pRectangles->nPairB.nValB ); + } + aPropVal.Name = sTextFrames; + aPropVal.Value <<= seqTextFrames; + aGeometryItem.SetPropertyValue( sPath, aPropVal ); + } + + // Equations + static constexpr OUString sEquations( u"Equations"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sEquations ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation ) + { + sal_Int32 i, nCount = pDefCustomShape->nCalculation; + uno::Sequence< OUString > seqEquations( nCount ); + auto pseqEquations = seqEquations.getArray(); + const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation; + for ( i = 0; i < nCount; i++, pData++ ) + pseqEquations[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] ); + aPropVal.Name = sEquations; + aPropVal.Value <<= seqEquations; + aGeometryItem.SetPropertyValue( aPropVal ); + } + + // Handles + static constexpr OUString sHandles( u"Handles"_ustr ); + pAny = aGeometryItem.GetPropertyValueByName( sHandles ); + if ( !pAny && pDefCustomShape && pDefCustomShape->nHandles && pDefCustomShape->pHandles ) + { + sal_Int32 i, nCount = pDefCustomShape->nHandles; + const SvxMSDffHandle* pData = pDefCustomShape->pHandles; + uno::Sequence seqHandles( nCount ); + auto pseqHandles = seqHandles.getArray(); + for ( i = 0; i < nCount; i++, pData++ ) + { + sal_Int32 nPropertiesNeeded; + beans::PropertyValues& rPropValues = pseqHandles[ i ]; + nPropertiesNeeded = GetNumberOfProperties( pData ); + rPropValues.realloc( nPropertiesNeeded ); + lcl_ShapePropertiesFromDFF( pData, rPropValues ); + } + aPropVal.Name = sHandles; + aPropVal.Value <<= seqHandles; + aGeometryItem.SetPropertyValue( aPropVal ); + } + else if (pAny && sShapeType.startsWith("ooxml-") && sShapeType != "ooxml-non-primitive") + { + // ODF is not able to store the ooxml way of connecting handle to an adjustment + // value by name, e.g. attribute RefX="adj". So the information is lost, when exporting + // a pptx to odp, for example. This part reconstructs this information for the + // ooxml preset shapes from their definition. + uno::Sequence seqHandles; + *pAny >>= seqHandles; + auto seqHandlesRange = asNonConstRange(seqHandles); + bool bChanged(false); + for (sal_Int32 i = 0; i < seqHandles.getLength(); i++) + { + comphelper::SequenceAsHashMap aHandleProps(seqHandles[i]); + OUString sFirstRefType; + sal_Int32 nFirstAdjRef; + OUString sSecondRefType; + sal_Int32 nSecondAdjRef; + PresetOOXHandleAdj::GetOOXHandleAdjRelation(sShapeType, i, sFirstRefType, nFirstAdjRef, + sSecondRefType, nSecondAdjRef); + if (sFirstRefType != "na" && 0 <= nFirstAdjRef + && nFirstAdjRef < seqAdjustmentValues.getLength()) + { + bChanged |= aHandleProps.createItemIfMissing(sFirstRefType, nFirstAdjRef); + } + if (sSecondRefType != "na" && 0 <= nSecondAdjRef + && nSecondAdjRef < seqAdjustmentValues.getLength()) + { + bChanged |= aHandleProps.createItemIfMissing(sSecondRefType, nSecondAdjRef); + } + aHandleProps >> seqHandlesRange[i]; + } + if (bChanged) + { + aPropVal.Name = sHandles; + aPropVal.Value <<= seqHandles; + aGeometryItem.SetPropertyValue(aPropVal); + } + } + + SetMergedItem( aGeometryItem ); +} + +bool SdrObjCustomShape::IsDefaultGeometry( const DefaultType eDefaultType ) const +{ + bool bIsDefaultGeometry = false; + + OUString sShapeType; + const SdrCustomShapeGeometryItem & rGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + + const uno::Any *pAny = rGeometryItem.GetPropertyValueByName( "Type" ); + if ( pAny ) + *pAny >>= sShapeType; + + MSO_SPT eSpType = EnhancedCustomShapeTypeNames::Get( sShapeType ); + + const mso_CustomShape* pDefCustomShape = GetCustomShapeContent( eSpType ); + static constexpr OUString sPath( u"Path"_ustr ); + switch( eDefaultType ) + { + case DefaultType::Viewbox : + { + const uno::Any* pViewBox = rGeometryItem.GetPropertyValueByName( "ViewBox" ); + awt::Rectangle aViewBox; + if (pViewBox && (*pViewBox >>= aViewBox) && pDefCustomShape) + { + if ( ( aViewBox.Width == pDefCustomShape->nCoordWidth ) + && ( aViewBox.Height == pDefCustomShape->nCoordHeight ) ) + bIsDefaultGeometry = true; + } + } + break; + + case DefaultType::Path : + { + pAny = rGeometryItem.GetPropertyValueByName( sPath, "Coordinates" ); + if ( pAny && pDefCustomShape && pDefCustomShape->nVertices && pDefCustomShape->pVertices ) + { + uno::Sequence seqCoordinates1; + if ( *pAny >>= seqCoordinates1 ) + { + sal_Int32 i, nCount = pDefCustomShape->nVertices; + uno::Sequence seqCoordinates2( nCount ); + auto pseqCoordinates2 = seqCoordinates2.getArray(); + for ( i = 0; i < nCount; i++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqCoordinates2[ i ].First, pDefCustomShape->pVertices[ i ].nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqCoordinates2[ i ].Second, pDefCustomShape->pVertices[ i ].nValB ); + } + if ( seqCoordinates1 == seqCoordinates2 ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( ( pDefCustomShape->nVertices == 0 ) || ( pDefCustomShape->pVertices == nullptr ) ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::Gluepoints : + { + pAny = rGeometryItem.GetPropertyValueByName( sPath, "GluePoints" ); + if ( pAny && pDefCustomShape && pDefCustomShape->nGluePoints && pDefCustomShape->pGluePoints ) + { + uno::Sequence seqGluePoints1; + if ( *pAny >>= seqGluePoints1 ) + { + sal_Int32 i, nCount = pDefCustomShape->nGluePoints; + uno::Sequence seqGluePoints2( nCount ); + auto pseqGluePoints2 = seqGluePoints2.getArray(); + for ( i = 0; i < nCount; i++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqGluePoints2[ i ].First, pDefCustomShape->pGluePoints[ i ].nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqGluePoints2[ i ].Second, pDefCustomShape->pGluePoints[ i ].nValB ); + } + if ( seqGluePoints1 == seqGluePoints2 ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( pDefCustomShape->nGluePoints == 0 ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::Segments : + { + // Path/Segments + pAny = rGeometryItem.GetPropertyValueByName( sPath, "Segments" ); + if ( pAny ) + { + uno::Sequence seqSegments1; + if ( *pAny >>= seqSegments1 ) + { + if ( pDefCustomShape && pDefCustomShape->nElements && pDefCustomShape->pElements ) + { + sal_Int32 i, nCount = pDefCustomShape->nElements; + if ( nCount ) + { + uno::Sequence seqSegments2( nCount ); + auto pseqSegments2 = seqSegments2.getArray(); + for ( i = 0; i < nCount; i++ ) + { + drawing::EnhancedCustomShapeSegment& rSegInfo = pseqSegments2[ i ]; + sal_uInt16 nSDat = pDefCustomShape->pElements[ i ]; + lcl_ShapeSegmentFromBinary( rSegInfo, nSDat ); + } + if ( seqSegments1 == seqSegments2 ) + bIsDefaultGeometry = true; + } + } + else + { + // check if it's the default segment description ( M L Z N ) + if ( seqSegments1.getLength() == 4 ) + { + if ( ( seqSegments1[ 0 ].Command == drawing::EnhancedCustomShapeSegmentCommand::MOVETO ) + && ( seqSegments1[ 1 ].Command == drawing::EnhancedCustomShapeSegmentCommand::LINETO ) + && ( seqSegments1[ 2 ].Command == drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH ) + && ( seqSegments1[ 3 ].Command == drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH ) ) + bIsDefaultGeometry = true; + } + } + } + } + else if ( pDefCustomShape && ( ( pDefCustomShape->nElements == 0 ) || ( pDefCustomShape->pElements == nullptr ) ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::StretchX : + { + pAny = rGeometryItem.GetPropertyValueByName( sPath, "StretchX" ); + if ( pAny && pDefCustomShape ) + { + sal_Int32 nStretchX = 0; + if ( *pAny >>= nStretchX ) + { + if ( pDefCustomShape->nXRef == nStretchX ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( pDefCustomShape->nXRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::StretchY : + { + pAny = rGeometryItem.GetPropertyValueByName( sPath, "StretchY" ); + if ( pAny && pDefCustomShape ) + { + sal_Int32 nStretchY = 0; + if ( *pAny >>= nStretchY ) + { + if ( pDefCustomShape->nYRef == nStretchY ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( pDefCustomShape->nYRef == DEFAULT_MINIMUM_SIGNED_COMPARE ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::Equations : + { + pAny = rGeometryItem.GetPropertyValueByName( "Equations" ); + if ( pAny && pDefCustomShape && pDefCustomShape->nCalculation && pDefCustomShape->pCalculation ) + { + uno::Sequence seqEquations1; + if ( *pAny >>= seqEquations1 ) + { + sal_Int32 i, nCount = pDefCustomShape->nCalculation; + uno::Sequence seqEquations2( nCount ); + auto pseqEquations2 = seqEquations2.getArray(); + + const SvxMSDffCalculationData* pData = pDefCustomShape->pCalculation; + for ( i = 0; i < nCount; i++, pData++ ) + pseqEquations2[ i ] = EnhancedCustomShape2d::GetEquation( pData->nFlags, pData->nVal[ 0 ], pData->nVal[ 1 ], pData->nVal[ 2 ] ); + + if ( seqEquations1 == seqEquations2 ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( ( pDefCustomShape->nCalculation == 0 ) || ( pDefCustomShape->pCalculation == nullptr ) ) ) + bIsDefaultGeometry = true; + } + break; + + case DefaultType::TextFrames : + { + pAny = rGeometryItem.GetPropertyValueByName( sPath, "TextFrames" ); + if ( pAny && pDefCustomShape && pDefCustomShape->nTextRect && pDefCustomShape->pTextRect ) + { + uno::Sequence seqTextFrames1; + if ( *pAny >>= seqTextFrames1 ) + { + sal_Int32 i, nCount = pDefCustomShape->nTextRect; + uno::Sequence seqTextFrames2( nCount ); + auto pseqTextFrames2 = seqTextFrames2.getArray(); + const SvxMSDffTextRectangles* pRectangles = pDefCustomShape->pTextRect; + for ( i = 0; i < nCount; i++, pRectangles++ ) + { + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames2[ i ].TopLeft.First, pRectangles->nPairA.nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames2[ i ].TopLeft.Second, pRectangles->nPairA.nValB ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames2[ i ].BottomRight.First, pRectangles->nPairB.nValA ); + EnhancedCustomShape2d::SetEnhancedCustomShapeParameter( pseqTextFrames2[ i ].BottomRight.Second, pRectangles->nPairB.nValB ); + } + if ( seqTextFrames1 == seqTextFrames2 ) + bIsDefaultGeometry = true; + } + } + else if ( pDefCustomShape && ( ( pDefCustomShape->nTextRect == 0 ) || ( pDefCustomShape->pTextRect == nullptr ) ) ) + bIsDefaultGeometry = true; + } + break; + } + return bIsDefaultGeometry; +} + +void SdrObjCustomShape::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bResizeFreeAllowed=m_fObjectRotation == 0.0; + rInfo.bResizePropAllowed=true; + rInfo.bRotateFreeAllowed=true; + rInfo.bRotate90Allowed =true; + rInfo.bMirrorFreeAllowed=true; + rInfo.bMirror45Allowed =true; + rInfo.bMirror90Allowed =true; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =true; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bNoContortion =true; + + // #i37011# + if ( !mXRenderedCustomShape.is() ) + return; + + const SdrObject* pRenderedCustomShape = SdrObject::getSdrObjectFromXShape( mXRenderedCustomShape ); + if ( !pRenderedCustomShape ) + return; + + // #i37262# + // Iterate self over the contained objects, since there are combinations of + // polygon and curve objects. In that case, aInfo.bCanConvToPath and + // aInfo.bCanConvToPoly would be false. What is needed here is an or, not an and. + SdrObjListIter aIterator(*pRenderedCustomShape); + while(aIterator.IsMore()) + { + SdrObject* pCandidate = aIterator.Next(); + SdrObjTransformInfoRec aInfo; + pCandidate->TakeObjInfo(aInfo); + + // set path and poly conversion if one is possible since + // this object will first be broken + const bool bCanConvToPathOrPoly(aInfo.bCanConvToPath || aInfo.bCanConvToPoly); + if(rInfo.bCanConvToPath != bCanConvToPathOrPoly) + { + rInfo.bCanConvToPath = bCanConvToPathOrPoly; + } + + if(rInfo.bCanConvToPoly != bCanConvToPathOrPoly) + { + rInfo.bCanConvToPoly = bCanConvToPathOrPoly; + } + + if(rInfo.bCanConvToContour != aInfo.bCanConvToContour) + { + rInfo.bCanConvToContour = aInfo.bCanConvToContour; + } + + if(rInfo.bShearAllowed != aInfo.bShearAllowed) + { + rInfo.bShearAllowed = aInfo.bShearAllowed; + } + } +} + +SdrObjKind SdrObjCustomShape::GetObjIdentifier() const +{ + return SdrObjKind::CustomShape; +} + +// #115391# This implementation is based on the TextFrame size of the CustomShape and the +// state of the ResizeShapeToFitText flag to correctly set TextMinFrameWidth/Height +void SdrObjCustomShape::AdaptTextMinSize() +{ + if (getSdrModelFromSdrObject().IsCreatingDataObj() || getSdrModelFromSdrObject().IsPasteResize()) + return; + + // check if we need to change anything before creating an SfxItemSet, because that is expensive + const bool bResizeShapeToFitText(GetObjectItem(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue()); + tools::Rectangle aTextBound(getRectangle()); + bool bChanged(false); + if(bResizeShapeToFitText) + bChanged = true; + else if(GetTextBounds(aTextBound)) + bChanged = true; + if (!bChanged) + return; + + SfxItemSetFixed // contains SDRATTR_TEXT_MAXFRAMEWIDTH + aSet(*GetObjectItemSet().GetPool()); + + if(bResizeShapeToFitText) + { + // always reset MinWidthHeight to zero to only rely on text size and frame size + // to allow resizing being completely dependent on text size only + aSet.Put(makeSdrTextMinFrameWidthItem(0)); + aSet.Put(makeSdrTextMinFrameHeightItem(0)); + } + else + { + // recreate from CustomShape-specific TextBounds + const tools::Long nHDist(GetTextLeftDistance() + GetTextRightDistance()); + const tools::Long nVDist(GetTextUpperDistance() + GetTextLowerDistance()); + const tools::Long nTWdt(std::max(tools::Long(0), static_cast(aTextBound.GetWidth() - 1 - nHDist))); + const tools::Long nTHgt(std::max(tools::Long(0), static_cast(aTextBound.GetHeight() - 1 - nVDist))); + + aSet.Put(makeSdrTextMinFrameWidthItem(nTWdt)); + aSet.Put(makeSdrTextMinFrameHeightItem(nTHgt)); + } + + SetObjectItemSet(aSet); +} + +void SdrObjCustomShape::NbcSetSnapRect(const tools::Rectangle& rRectangle) +{ + tools::Rectangle aRectangle(rRectangle); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + InvalidateRenderGeometry(); + + AdaptTextMinSize(); + + ImpCheckShear(); + SetBoundAndSnapRectsDirty(); + SetChanged(); +} + +void SdrObjCustomShape::SetSnapRect( const tools::Rectangle& rRect ) +{ + tools::Rectangle aBoundRect0; + if ( m_pUserCall ) + aBoundRect0 = GetLastBoundRect(); + NbcSetSnapRect( rRect ); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObjCustomShape::NbcSetLogicRect(const tools::Rectangle& rRectangle) +{ + tools::Rectangle aRectangle(rRectangle); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + InvalidateRenderGeometry(); + + AdaptTextMinSize(); + + SetBoundAndSnapRectsDirty(); + SetChanged(); +} + +void SdrObjCustomShape::SetLogicRect( const tools::Rectangle& rRect ) +{ + tools::Rectangle aBoundRect0; + if ( m_pUserCall ) + aBoundRect0 = GetLastBoundRect(); + NbcSetLogicRect(rRect); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObjCustomShape::Move( const Size& rSiz ) +{ + if ( rSiz.Width() || rSiz.Height() ) + { + tools::Rectangle aBoundRect0; + if ( m_pUserCall ) + aBoundRect0 = GetLastBoundRect(); + NbcMove(rSiz); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} +void SdrObjCustomShape::NbcMove( const Size& rSiz ) +{ + SdrTextObj::NbcMove( rSiz ); + if ( mXRenderedCustomShape.is() ) + { + SdrObject* pRenderedCustomShape = SdrObject::getSdrObjectFromXShape(mXRenderedCustomShape); + if ( pRenderedCustomShape ) + { + // #i97149# the visualisation shape needs to be informed + // about change, too + pRenderedCustomShape->ActionChanged(); + pRenderedCustomShape->NbcMove( rSiz ); + } + } + + // #i37011# adapt geometry shadow + if(mpLastShadowGeometry) + { + mpLastShadowGeometry->NbcMove( rSiz ); + } +} + +void SdrObjCustomShape::NbcResize( const Point& rRef, const Fraction& rxFact, const Fraction& ryFact ) +{ + // taking care of handles that should not been changed + tools::Rectangle aOld(getRectangle()); + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + + SdrTextObj::NbcResize( rRef, rxFact, ryFact ); + + if ( ( rxFact.GetNumerator() != rxFact.GetDenominator() ) + || ( ryFact.GetNumerator()!= ryFact.GetDenominator() ) ) + { + if ( ( ( rxFact.GetNumerator() < 0 ) && ( rxFact.GetDenominator() > 0 ) ) || + ( ( rxFact.GetNumerator() > 0 ) && ( rxFact.GetDenominator() < 0 ) ) ) + { + SetMirroredX( !IsMirroredX() ); + } + if ( ( ( ryFact.GetNumerator() < 0 ) && ( ryFact.GetDenominator() > 0 ) ) || + ( ( ryFact.GetNumerator() > 0 ) && ( ryFact.GetDenominator() < 0 ) ) ) + { + SetMirroredY( !IsMirroredY() ); + } + } + + for (const auto& rInteraction : aInteractionHandles) + { + try + { + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_FIXED ) + rInteraction.xInteraction->setControllerPosition( rInteraction.aPosition ); + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_X ) + { + sal_Int32 nX = ( rInteraction.aPosition.X - aOld.Left() ) + getRectangle().Left(); + rInteraction.xInteraction->setControllerPosition(awt::Point(nX, rInteraction.xInteraction->getPosition().Y)); + } + else if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_NEGX ) + { + sal_Int32 nX = getRectangle().Right() - (aOld.Right() - rInteraction.aPosition.X); + rInteraction.xInteraction->setControllerPosition(awt::Point(nX, rInteraction.xInteraction->getPosition().Y)); + } + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_Y ) + { + sal_Int32 nY = ( rInteraction.aPosition.Y - aOld.Top() ) + getRectangle().Top(); + rInteraction.xInteraction->setControllerPosition(awt::Point(rInteraction.xInteraction->getPosition().X, nY)); + } + } + catch ( const uno::RuntimeException& ) + { + } + } + + // updating fObjectRotation + Degree100 nTextObjRotation = maGeo.m_nRotationAngle; + double fAngle = toDegrees(nTextObjRotation); + if (IsMirroredX()) + { + if (IsMirroredY()) + m_fObjectRotation = fAngle - 180.0; + else + m_fObjectRotation = -fAngle; + } + else + { + if (IsMirroredY()) + m_fObjectRotation = 180.0 - fAngle; + else + m_fObjectRotation = fAngle; + } + while (m_fObjectRotation < 0) + m_fObjectRotation += 360.0; + while (m_fObjectRotation >= 360.0) + m_fObjectRotation -= 360.0; + + InvalidateRenderGeometry(); +} + +void SdrObjCustomShape::NbcRotate( const Point& rRef, Degree100 nAngle, double sn, double cs ) +{ + bool bMirroredX = IsMirroredX(); + bool bMirroredY = IsMirroredY(); + + m_fObjectRotation = fmod( m_fObjectRotation, 360.0 ); + if ( m_fObjectRotation < 0 ) + m_fObjectRotation = 360 + m_fObjectRotation; + + // the rotation angle for ashapes is stored in fObjectRotation, this rotation + // has to be applied to the text object (which is internally using maGeo.nAngle). + SdrTextObj::NbcRotate( getRectangle().TopLeft(), -maGeo.m_nRotationAngle, // retrieving the unrotated text object + -maGeo.mfSinRotationAngle, + maGeo.mfCosRotationAngle ); + maGeo.m_nRotationAngle = 0_deg100; // resetting aGeo data + maGeo.RecalcSinCos(); + + Degree100 nW(static_cast( m_fObjectRotation * 100 )); // applying our object rotation + if ( bMirroredX ) + nW = 36000_deg100 - nW; + if ( bMirroredY ) + nW = 18000_deg100 - nW; + nW = nW % 36000_deg100; + if ( nW < 0_deg100 ) + nW = 36000_deg100 + nW; + SdrTextObj::NbcRotate( getRectangle().TopLeft(), nW, // applying text rotation + sin( toRadians(nW) ), + cos( toRadians(nW) ) ); + + int nSwap = 0; + if ( bMirroredX ) + nSwap ^= 1; + if ( bMirroredY ) + nSwap ^= 1; + + double fAngle = toDegrees(nAngle); // updating to our new object rotation + m_fObjectRotation = fmod( nSwap ? m_fObjectRotation - fAngle : m_fObjectRotation + fAngle, 360.0 ); + if ( m_fObjectRotation < 0 ) + m_fObjectRotation = 360 + m_fObjectRotation; + + SdrTextObj::NbcRotate( rRef, nAngle, sn, cs ); // applying text rotation + InvalidateRenderGeometry(); +} + +void SdrObjCustomShape::NbcMirror( const Point& rRef1, const Point& rRef2 ) +{ + // TTTT: Fix for old mirroring, can be removed again in aw080 + // storing horizontal and vertical flipping without modifying the rotate angle + // decompose other flipping to rotation and MirrorX. + tools::Long ndx = rRef2.X()-rRef1.X(); + tools::Long ndy = rRef2.Y()-rRef1.Y(); + + if(!ndx) // MirroredX + { + SetMirroredX(!IsMirroredX()); + SdrTextObj::NbcMirror( rRef1, rRef2 ); + } + else + { + if(!ndy) // MirroredY + { + SetMirroredY(!IsMirroredY()); + SdrTextObj::NbcMirror( rRef1, rRef2 ); + } + else // neither horizontal nor vertical + { + SetMirroredX(!IsMirroredX()); + + // call parent + SdrTextObj::NbcMirror( rRef1, rRef2 ); + + // update fObjectRotation + Degree100 nTextObjRotation = maGeo.m_nRotationAngle; + double fAngle = toDegrees(nTextObjRotation); + + bool bSingleFlip = (IsMirroredX()!= IsMirroredY()); + + m_fObjectRotation = fmod( bSingleFlip ? -fAngle : fAngle, 360.0 ); + + if ( m_fObjectRotation < 0 ) + { + m_fObjectRotation = 360.0 + m_fObjectRotation; + } + } + } + + InvalidateRenderGeometry(); +} + +void SdrObjCustomShape::Shear( const Point& rRef, Degree100 nAngle, double tn, bool bVShear ) +{ + SdrTextObj::Shear( rRef, nAngle, tn, bVShear ); + InvalidateRenderGeometry(); +} +void SdrObjCustomShape::NbcShear( const Point& rRef, Degree100 nAngle, double tn, bool bVShear ) +{ + // TTTT: Fix for old mirroring, can be removed again in aw080 + SdrTextObj::NbcShear(rRef,nAngle,tn,bVShear); + + // updating fObjectRotation + Degree100 nTextObjRotation = maGeo.m_nRotationAngle; + double fAngle = toDegrees(nTextObjRotation); + if (IsMirroredX()) + { + if (IsMirroredY()) + m_fObjectRotation = fAngle - 180.0; + else + m_fObjectRotation = -fAngle; + } + else + { + if (IsMirroredY()) + m_fObjectRotation = 180.0 - fAngle; + else + m_fObjectRotation = fAngle; + } + while (m_fObjectRotation < 0) + m_fObjectRotation += 360.0; + while (m_fObjectRotation >= 360.0) + m_fObjectRotation -= 360.0; + + InvalidateRenderGeometry(); +} + +SdrGluePoint SdrObjCustomShape::GetVertexGluePoint(sal_uInt16 nPosNum) const +{ + sal_Int32 nWdt = ImpGetLineWdt(); // #i25616# + + // #i25616# + if(!LineIsOutsideGeometry()) + { + nWdt++; + nWdt /= 2; + } + + Point aPt; + tools::Rectangle aRectangle = getRectangle(); + switch (nPosNum) + { + case 0: aPt = aRectangle.TopCenter(); aPt.AdjustY( -nWdt ); break; + case 1: aPt = aRectangle.RightCenter(); aPt.AdjustX(nWdt ); break; + case 2: aPt = aRectangle.BottomCenter(); aPt.AdjustY(nWdt ); break; + case 3: aPt = aRectangle.LeftCenter(); aPt.AdjustX( -nWdt ); break; + } + if (maGeo.m_nShearAngle != 0_deg100) + ShearPoint(aPt, aRectangle.TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle != 0_deg100) + RotatePoint(aPt, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aPt-=GetSnapRect().Center(); + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + return aGP; +} + + +// #i38892# +void SdrObjCustomShape::ImpCheckCustomGluePointsAreAdded() +{ + const SdrObject* pSdrObject = GetSdrObjectFromCustomShape(); + + if(!pSdrObject) + return; + + const SdrGluePointList* pSource = pSdrObject->GetGluePointList(); + + if(!(pSource && pSource->GetCount())) + return; + + if(!SdrTextObj::GetGluePointList()) + { + SdrTextObj::ForceGluePointList(); + } + + const SdrGluePointList* pList = SdrTextObj::GetGluePointList(); + + if(!pList) + return; + + SdrGluePointList aNewList; + sal_uInt16 a; + + for(a = 0; a < pSource->GetCount(); a++) + { + SdrGluePoint aCopy((*pSource)[a]); + aCopy.SetUserDefined(false); + aNewList.Insert(aCopy); + } + + bool bMirroredX = IsMirroredX(); + bool bMirroredY = IsMirroredY(); + + Degree100 nShearAngle = maGeo.m_nShearAngle; + double fTan = maGeo.mfTanShearAngle; + + if (maGeo.m_nRotationAngle || nShearAngle || bMirroredX || bMirroredY) + { + tools::Polygon aPoly(getRectangle()); + if( nShearAngle ) + { + sal_uInt16 nPointCount=aPoly.GetSize(); + for (sal_uInt16 i=0; i(maGeo.m_nRotationAngle) ); + + tools::Rectangle aBoundRect( aPoly.GetBoundRect() ); + sal_Int32 nXDiff = aBoundRect.Left() - getRectangle().Left(); + sal_Int32 nYDiff = aBoundRect.Top() - getRectangle().Top(); + + if (nShearAngle && bMirroredX != bMirroredY) + { + nShearAngle = -nShearAngle; + fTan = -fTan; + } + + Point aRef( getRectangle().GetWidth() / 2, getRectangle().GetHeight() / 2 ); + for ( a = 0; a < aNewList.GetCount(); a++ ) + { + SdrGluePoint& rPoint = aNewList[ a ]; + Point aGlue( rPoint.GetPos() ); + if ( nShearAngle ) + ShearPoint( aGlue, aRef, fTan ); + + RotatePoint(aGlue, aRef, sin(basegfx::deg2rad(m_fObjectRotation)), + cos(basegfx::deg2rad(m_fObjectRotation))); + if ( bMirroredX ) + aGlue.setX( getRectangle().GetWidth() - aGlue.X() ); + if ( bMirroredY ) + aGlue.setY( getRectangle().GetHeight() - aGlue.Y() ); + aGlue.AdjustX( -nXDiff ); + aGlue.AdjustY( -nYDiff ); + rPoint.SetPos( aGlue ); + } + } + + for(a = 0; a < pList->GetCount(); a++) + { + const SdrGluePoint& rCandidate = (*pList)[a]; + + if(rCandidate.IsUserDefined()) + { + aNewList.Insert(rCandidate); + } + } + + // copy new list to local. This is NOT very convenient behavior, the local + // GluePointList should not be set, but we delivered by using GetGluePointList(), + // maybe on demand. Since the local object is changed here, this is assumed to + // be a result of GetGluePointList and thus the list is copied + if(m_pPlusData) + { + m_pPlusData->SetGluePoints(aNewList); + } +} + +// #i38892# +const SdrGluePointList* SdrObjCustomShape::GetGluePointList() const +{ + const_cast(this)->ImpCheckCustomGluePointsAreAdded(); + return SdrTextObj::GetGluePointList(); +} + +// #i38892# +SdrGluePointList* SdrObjCustomShape::ForceGluePointList() +{ + if(SdrTextObj::ForceGluePointList()) + { + ImpCheckCustomGluePointsAreAdded(); + return SdrTextObj::ForceGluePointList(); + } + else + { + return nullptr; + } +} + + +sal_uInt32 SdrObjCustomShape::GetHdlCount() const +{ + const sal_uInt32 nBasicHdlCount(SdrTextObj::GetHdlCount()); + return ( GetInteractionHandles().size() + nBasicHdlCount ); +} + +void SdrObjCustomShape::AddToHdlList(SdrHdlList& rHdlList) const +{ + SdrTextObj::AddToHdlList(rHdlList); + + int nCustomShapeHdlNum = 0; + for (SdrCustomShapeInteraction const & rInteraction : GetInteractionHandles()) + { + if ( rInteraction.xInteraction.is() ) + { + try + { + awt::Point aPosition( rInteraction.xInteraction->getPosition() ); + std::unique_ptr pH(new SdrHdl( Point( aPosition.X, aPosition.Y ), SdrHdlKind::CustomShape1 )); + pH->SetPointNum( nCustomShapeHdlNum ); + pH->SetObj( const_cast(this) ); + rHdlList.AddHdl(std::move(pH)); + } + catch ( const uno::RuntimeException& ) + { + } + } + ++nCustomShapeHdlNum; + } +} + +bool SdrObjCustomShape::hasSpecialDrag() const +{ + return true; +} + +bool SdrObjCustomShape::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + + if(pHdl && SdrHdlKind::CustomShape1 == pHdl->GetKind()) + { + rDrag.SetEndDragChangesAttributes(true); + rDrag.SetNoSnap(); + } + else + { + const SdrHdl* pHdl2 = rDrag.GetHdl(); + const SdrHdlKind eHdl((pHdl2 == nullptr) ? SdrHdlKind::Move : pHdl2->GetKind()); + + switch( eHdl ) + { + case SdrHdlKind::UpperLeft : + case SdrHdlKind::Upper : + case SdrHdlKind::UpperRight : + case SdrHdlKind::Left : + case SdrHdlKind::Right : + case SdrHdlKind::LowerLeft : + case SdrHdlKind::Lower : + case SdrHdlKind::LowerRight : + case SdrHdlKind::Move : + { + break; + } + default: + { + return false; + } + } + } + + return true; +} + +void SdrObjCustomShape::DragResizeCustomShape( const tools::Rectangle& rNewRect ) +{ + tools::Rectangle aOld(getRectangle()); + bool bOldMirroredX( IsMirroredX() ); + bool bOldMirroredY( IsMirroredY() ); + + tools::Rectangle aNewRect( rNewRect ); + aNewRect.Normalize(); + + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + + GeoStat aGeoStat( GetGeoStat() ); + if ( aNewRect.TopLeft() != getRectangle().TopLeft() && + ( maGeo.m_nRotationAngle || maGeo.m_nShearAngle ) ) + { + Point aNewPos( aNewRect.TopLeft() ); + if ( maGeo.m_nShearAngle ) ShearPoint( aNewPos, aOld.TopLeft(), aGeoStat.mfTanShearAngle ); + if ( maGeo.m_nRotationAngle ) RotatePoint(aNewPos, aOld.TopLeft(), aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle ); + aNewRect.SetPos( aNewPos ); + } + if (aNewRect == getRectangle()) + return; + + SetLogicRect( aNewRect ); + InvalidateRenderGeometry(); + + if ( rNewRect.Left() > rNewRect.Right() ) + { + Point aTop( ( GetSnapRect().Left() + GetSnapRect().Right() ) >> 1, GetSnapRect().Top() ); + Point aBottom( aTop.X(), aTop.Y() + 1000 ); + NbcMirror( aTop, aBottom ); + } + if ( rNewRect.Top() > rNewRect.Bottom() ) + { + Point aLeft( GetSnapRect().Left(), ( GetSnapRect().Top() + GetSnapRect().Bottom() ) >> 1 ); + Point aRight( aLeft.X() + 1000, aLeft.Y() ); + NbcMirror( aLeft, aRight ); + } + + for (const auto& rInteraction : aInteractionHandles) + { + try + { + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_FIXED ) + rInteraction.xInteraction->setControllerPosition( rInteraction.aPosition ); + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_X || + rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_NEGX ) + { + if (rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_NEGX) + bOldMirroredX = !bOldMirroredX; + + sal_Int32 nX; + if ( bOldMirroredX ) + { + nX = ( rInteraction.aPosition.X - aOld.Right() ); + if ( rNewRect.Left() > rNewRect.Right() ) + nX = getRectangle().Left() - nX; + else + nX += getRectangle().Right(); + } + else + { + nX = ( rInteraction.aPosition.X - aOld.Left() ); + if ( rNewRect.Left() > rNewRect.Right() ) + nX = getRectangle().Right() - nX; + else + nX += getRectangle().Left(); + } + rInteraction.xInteraction->setControllerPosition(awt::Point(nX, rInteraction.xInteraction->getPosition().Y)); + } + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_ABSOLUTE_Y ) + { + sal_Int32 nY; + if ( bOldMirroredY ) + { + nY = ( rInteraction.aPosition.Y - aOld.Bottom() ); + if ( rNewRect.Top() > rNewRect.Bottom() ) + nY = getRectangle().Top() - nY; + else + nY += getRectangle().Bottom(); + } + else + { + nY = ( rInteraction.aPosition.Y - aOld.Top() ); + if ( rNewRect.Top() > rNewRect.Bottom() ) + nY = getRectangle().Bottom() - nY; + else + nY += getRectangle().Top(); + } + rInteraction.xInteraction->setControllerPosition(awt::Point(rInteraction.xInteraction->getPosition().X, nY)); + } + } + catch ( const uno::RuntimeException& ) + { + } + } +} + +void SdrObjCustomShape::DragMoveCustomShapeHdl( const Point& rDestination, + const sal_uInt16 nCustomShapeHdlNum, bool bMoveCalloutRectangle ) +{ + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + if ( nCustomShapeHdlNum >= aInteractionHandles.size() ) + return; + + SdrCustomShapeInteraction aInteractionHandle( aInteractionHandles[ nCustomShapeHdlNum ] ); + if ( !aInteractionHandle.xInteraction.is() ) + return; + + try + { + awt::Point aPt( rDestination.X(), rDestination.Y() ); + if ( aInteractionHandle.nMode & CustomShapeHandleModes::MOVE_SHAPE && bMoveCalloutRectangle ) + { + sal_Int32 nXDiff = aPt.X - aInteractionHandle.aPosition.X; + sal_Int32 nYDiff = aPt.Y - aInteractionHandle.aPosition.Y; + + moveRectangle(nXDiff, nYDiff); + moveOutRectangle(nXDiff, nYDiff); + maSnapRect.Move( nXDiff, nYDiff ); + SetBoundAndSnapRectsDirty(/*bNotMyself*/true); + InvalidateRenderGeometry(); + + for (const auto& rInteraction : aInteractionHandles) + { + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_FIXED ) + { + if ( rInteraction.xInteraction.is() ) + rInteraction.xInteraction->setControllerPosition( rInteraction.aPosition ); + } + } + } + aInteractionHandle.xInteraction->setControllerPosition( aPt ); + } + catch ( const uno::RuntimeException& ) + { + } +} + +bool SdrObjCustomShape::applySpecialDrag(SdrDragStat& rDrag) +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + const SdrHdlKind eHdl((pHdl == nullptr) ? SdrHdlKind::Move : pHdl->GetKind()); + + switch(eHdl) + { + case SdrHdlKind::CustomShape1 : + { + rDrag.SetEndDragChangesGeoAndAttributes(true); + DragMoveCustomShapeHdl( rDrag.GetNow(), static_cast(pHdl->GetPointNum()), !rDrag.GetDragMethod()->IsShiftPressed() ); + SetBoundAndSnapRectsDirty(); + InvalidateRenderGeometry(); + SetChanged(); + break; + } + + case SdrHdlKind::UpperLeft : + case SdrHdlKind::Upper : + case SdrHdlKind::UpperRight : + case SdrHdlKind::Left : + case SdrHdlKind::Right : + case SdrHdlKind::LowerLeft : + case SdrHdlKind::Lower : + case SdrHdlKind::LowerRight : + { + DragResizeCustomShape( ImpDragCalcRect(rDrag) ); + break; + } + case SdrHdlKind::Move : + { + Move(Size(rDrag.GetDX(), rDrag.GetDY())); + break; + } + default: break; + } + + return true; +} + + +void SdrObjCustomShape::DragCreateObject( SdrDragStat& rStat ) +{ + tools::Rectangle aRect1; + rStat.TakeCreateRect( aRect1 ); + + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + + constexpr sal_uInt32 nDefaultObjectSizeWidth = 3000; // default width from SDOptions ? + constexpr sal_uInt32 nDefaultObjectSizeHeight= 3000; + + if ( ImpVerticalSwitch( *this ) ) + { + SetMirroredX( aRect1.Left() > aRect1.Right() ); + + aRect1 = tools::Rectangle( rStat.GetNow(), Size( nDefaultObjectSizeWidth, nDefaultObjectSizeHeight ) ); + // subtracting the horizontal difference of the latest handle from shape position + if ( !aInteractionHandles.empty() ) + { + sal_Int32 nHandlePos = aInteractionHandles[ aInteractionHandles.size() - 1 ].xInteraction->getPosition().X; + aRect1.Move(getRectangle().Left() - nHandlePos, 0); + } + } + ImpJustifyRect( aRect1 ); + rStat.SetActionRect( aRect1 ); + setRectangle(aRect1); + SetBoundAndSnapRectsDirty(); + + for (const auto& rInteraction : aInteractionHandles) + { + try + { + if ( rInteraction.nMode & CustomShapeHandleModes::CREATE_FIXED ) + rInteraction.xInteraction->setControllerPosition( awt::Point( rStat.GetStart().X(), rStat.GetStart().Y() ) ); + } + catch ( const uno::RuntimeException& ) + { + } + } + + SetBoundRectDirty(); + m_bSnapRectDirty=true; +} + +bool SdrObjCustomShape::MovCreate(SdrDragStat& rStat) +{ + SdrView* pView = rStat.GetView(); // #i37448# + if( pView && pView->IsSolidDragging() ) + { + InvalidateRenderGeometry(); + } + DragCreateObject( rStat ); + SetBoundAndSnapRectsDirty(); + return true; +} + +bool SdrObjCustomShape::EndCreate( SdrDragStat& rStat, SdrCreateCmd eCmd ) +{ + DragCreateObject( rStat ); + + AdaptTextMinSize(); + + SetBoundAndSnapRectsDirty(); + return ( eCmd == SdrCreateCmd::ForceEnd || rStat.GetPointCount() >= 2 ); +} + +basegfx::B2DPolyPolygon SdrObjCustomShape::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const +{ + return GetLineGeometry( false ); +} + + +// in context with the SdrObjCustomShape the SdrTextAutoGrowHeightItem == true -> Resize Shape to fit text, +// the SdrTextAutoGrowWidthItem == true -> Word wrap text in Shape +bool SdrObjCustomShape::IsAutoGrowHeight() const +{ + const SfxItemSet& rSet = GetMergedItemSet(); + bool bIsAutoGrowHeight = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + if ( bIsAutoGrowHeight && IsVerticalWriting() ) + bIsAutoGrowHeight = !rSet.Get(SDRATTR_TEXT_WORDWRAP).GetValue(); + return bIsAutoGrowHeight; +} +bool SdrObjCustomShape::IsAutoGrowWidth() const +{ + const SfxItemSet& rSet = GetMergedItemSet(); + bool bIsAutoGrowWidth = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + if ( bIsAutoGrowWidth && !IsVerticalWriting() ) + bIsAutoGrowWidth = !rSet.Get(SDRATTR_TEXT_WORDWRAP).GetValue(); + return bIsAutoGrowWidth; +} + +/* The following method is identical to the SdrTextObj::SetVerticalWriting method, the only difference + is that the SdrAutoGrowWidthItem and SdrAutoGrowHeightItem are not exchanged if the vertical writing + mode has been changed */ + +void SdrObjCustomShape::SetVerticalWriting( bool bVertical ) +{ + ForceOutlinerParaObject(); + + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + + DBG_ASSERT( pOutlinerParaObject, "SdrTextObj::SetVerticalWriting() without OutlinerParaObject!" ); + + if( !pOutlinerParaObject || + (pOutlinerParaObject->IsEffectivelyVertical() == bVertical) ) + return; + + // get item settings + const SfxItemSet& rSet = GetObjectItemSet(); + + // Also exchange horizontal and vertical adjust items + SdrTextHorzAdjust eHorz = rSet.Get(SDRATTR_TEXT_HORZADJUST).GetValue(); + SdrTextVertAdjust eVert = rSet.Get(SDRATTR_TEXT_VERTADJUST).GetValue(); + + // rescue object size, SetSnapRect below expects logic rect, + // not snap rect. + tools::Rectangle aObjectRect = GetLogicRect(); + + // prepare ItemSet to set exchanged width and height items + SfxItemSetFixed aNewSet(*rSet.GetPool()); + + aNewSet.Put(rSet); + + // Exchange horizontal and vertical adjusts + switch(eVert) + { + case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break; + case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break; + case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break; + case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break; + } + switch(eHorz) + { + case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break; + case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break; + case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break; + case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break; + } + + pOutlinerParaObject = GetOutlinerParaObject(); + if ( pOutlinerParaObject ) + pOutlinerParaObject->SetVertical(bVertical); + SetObjectItemSet( aNewSet ); + + // restore object size + SetSnapRect(aObjectRect); +} + +void SdrObjCustomShape::SuggestTextFrameSize(Size aSuggestedTextFrameSize) +{ + m_aSuggestedTextFrameSize = aSuggestedTextFrameSize; +} + +bool SdrObjCustomShape::AdjustTextFrameWidthAndHeight(tools::Rectangle& rR, bool bHgt, bool bWdt) const +{ + // Either we have text or the application has native text and suggested its size to us. + bool bHasText = HasText() || !m_aSuggestedTextFrameSize.IsEmpty(); + if ( bHasText && !rR.IsEmpty() ) + { + bool bWdtGrow=bWdt && IsAutoGrowWidth(); + bool bHgtGrow=bHgt && IsAutoGrowHeight(); + if ( bWdtGrow || bHgtGrow ) + { + tools::Rectangle aR0(rR); + tools::Long nHgt=0,nMinHgt=0,nMaxHgt=0; + tools::Long nWdt=0,nMinWdt=0,nMaxWdt=0; + Size aSiz(rR.GetSize()); aSiz.AdjustWidth( -1 ); aSiz.AdjustHeight( -1 ); + Size aMaxSiz(100000,100000); + Size aTmpSiz(getSdrModelFromSdrObject().GetMaxObjSize()); + if (aTmpSiz.Width()!=0) aMaxSiz.setWidth(aTmpSiz.Width() ); + if (aTmpSiz.Height()!=0) aMaxSiz.setHeight(aTmpSiz.Height() ); + if (bWdtGrow) + { + nMinWdt=GetMinTextFrameWidth(); + nMaxWdt=GetMaxTextFrameWidth(); + if (nMaxWdt==0 || nMaxWdt>aMaxSiz.Width()) nMaxWdt=aMaxSiz.Width(); + if (nMinWdt<=0) nMinWdt=1; + aSiz.setWidth(nMaxWdt ); + } + if (bHgtGrow) + { + nMinHgt=GetMinTextFrameHeight(); + nMaxHgt=GetMaxTextFrameHeight(); + if (nMaxHgt==0 || nMaxHgt>aMaxSiz.Height()) nMaxHgt=aMaxSiz.Height(); + if (nMinHgt<=0) nMinHgt=1; + aSiz.setHeight(nMaxHgt ); + } + tools::Long nHDist=GetTextLeftDistance()+GetTextRightDistance(); + tools::Long nVDist=GetTextUpperDistance()+GetTextLowerDistance(); + aSiz.AdjustWidth( -nHDist ); + aSiz.AdjustHeight( -nVDist ); + if ( aSiz.Width() < 2 ) + aSiz.setWidth( 2 ); // minimum size=2 + if ( aSiz.Height() < 2 ) + aSiz.setHeight( 2 ); // minimum size=2 + + if (HasText()) + { + if(mpEditingOutliner) + { + mpEditingOutliner->SetMaxAutoPaperSize( aSiz ); + if (bWdtGrow) + { + Size aSiz2(mpEditingOutliner->CalcTextSize()); + nWdt=aSiz2.Width()+1; // a little more tolerance + if (bHgtGrow) nHgt=aSiz2.Height()+1; // a little more tolerance + } else + { + nHgt=mpEditingOutliner->GetTextHeight()+1; // a little more tolerance + } + } + else + { + Outliner& rOutliner=ImpGetDrawOutliner(); + rOutliner.SetPaperSize(aSiz); + rOutliner.SetUpdateLayout(true); + // TODO: add the optimization with bPortionInfoChecked again. + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if( pOutlinerParaObject != nullptr ) + { + rOutliner.SetText(*pOutlinerParaObject); + rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + } + if ( bWdtGrow ) + { + Size aSiz2(rOutliner.CalcTextSize()); + nWdt=aSiz2.Width()+1; // a little more tolerance + if ( bHgtGrow ) + nHgt=aSiz2.Height()+1; // a little more tolerance + } + else + { + nHgt = rOutliner.GetTextHeight()+1; // a little more tolerance + + sal_Int16 nColumns = GetMergedItem(SDRATTR_TEXTCOLUMNS_NUMBER).GetValue(); + if (bHgtGrow && nColumns > 1) + { + // Both 'resize shape to fix text' and multiple columns are enabled. The + // first means a dynamic height, the second expects a fixed height. + // Resolve this conflict by going with the original height. + nHgt = rR.getOpenHeight(); + } + } + rOutliner.Clear(); + } + } + else + { + nHgt = m_aSuggestedTextFrameSize.Height(); + nWdt = m_aSuggestedTextFrameSize.Width(); + } + if ( nWdt < nMinWdt ) + nWdt = nMinWdt; + if ( nWdt > nMaxWdt ) + nWdt = nMaxWdt; + nWdt += nHDist; + if ( nWdt < 1 ) + nWdt = 1; // nHDist may also be negative + if ( nHgt < nMinHgt ) + nHgt = nMinHgt; + if ( nHgt > nMaxHgt ) + nHgt = nMaxHgt; + nHgt+=nVDist; + if ( nHgt < 1 ) + nHgt = 1; // nVDist may also be negative + tools::Long nWdtGrow = nWdt-(rR.Right()-rR.Left()); + tools::Long nHgtGrow = nHgt-(rR.Bottom()-rR.Top()); + if ( nWdtGrow == 0 ) + bWdtGrow = false; + if ( nHgtGrow == 0 ) + bHgtGrow=false; + if ( bWdtGrow || bHgtGrow || !m_aSuggestedTextFrameSize.IsEmpty()) + { + if ( bWdtGrow || m_aSuggestedTextFrameSize.Width() ) + { + SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust(); + if (m_aSuggestedTextFrameSize.Width()) + { + rR.SetRight(rR.Left() + m_aSuggestedTextFrameSize.Width()); + } + else if ( eHAdj == SDRTEXTHORZADJUST_LEFT ) + rR.AdjustRight(nWdtGrow ); + else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT ) + rR.AdjustLeft( -nWdtGrow ); + else + { + tools::Long nWdtGrow2=nWdtGrow/2; + rR.AdjustLeft( -nWdtGrow2 ); + rR.SetRight(rR.Left()+nWdt ); + } + } + if ( bHgtGrow || m_aSuggestedTextFrameSize.Height() ) + { + SdrTextVertAdjust eVAdj=GetTextVerticalAdjust(); + if (m_aSuggestedTextFrameSize.Height()) + { + rR.SetBottom(rR.Top() + m_aSuggestedTextFrameSize.Height()); + } + else if ( eVAdj == SDRTEXTVERTADJUST_TOP ) + rR.AdjustBottom(nHgtGrow ); + else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM ) + rR.AdjustTop( -nHgtGrow ); + else + { + tools::Long nHgtGrow2=nHgtGrow/2; + rR.AdjustTop( -nHgtGrow2 ); + rR.SetBottom(rR.Top()+nHgt ); + } + } + if ( maGeo.m_nRotationAngle ) + { + Point aD1(rR.TopLeft()); + aD1-=aR0.TopLeft(); + Point aD2(aD1); + RotatePoint(aD2,Point(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aD2-=aD1; + rR.Move(aD2.X(),aD2.Y()); + } + return true; + } + } + } + return false; +} + +tools::Rectangle SdrObjCustomShape::ImpCalculateTextFrame( const bool bHgt, const bool bWdt ) +{ + tools::Rectangle aReturnValue; + + tools::Rectangle aOldTextRect(getRectangle()); // <- initial text rectangle + + tools::Rectangle aNewTextRect(getRectangle()); // <- new text rectangle returned from the custom shape renderer, + GetTextBounds( aNewTextRect ); // it depends to the current logical shape size + + tools::Rectangle aAdjustedTextRect( aNewTextRect ); // <- new text rectangle is being tested by AdjustTextFrameWidthAndHeight to ensure + if ( AdjustTextFrameWidthAndHeight( aAdjustedTextRect, bHgt, bWdt ) ) // that the new text rectangle is matching the current text size from the outliner + { + if (aAdjustedTextRect != aNewTextRect && aOldTextRect != aAdjustedTextRect && + aNewTextRect.GetWidth() && aNewTextRect.GetHeight()) + { + aReturnValue = getRectangle(); + double fXScale = static_cast(aOldTextRect.GetWidth()) / static_cast(aNewTextRect.GetWidth()); + double fYScale = static_cast(aOldTextRect.GetHeight()) / static_cast(aNewTextRect.GetHeight()); + double fRightDiff = static_cast( aAdjustedTextRect.Right() - aNewTextRect.Right() ) * fXScale; + double fLeftDiff = static_cast( aAdjustedTextRect.Left() - aNewTextRect.Left() ) * fXScale; + double fTopDiff = static_cast( aAdjustedTextRect.Top() - aNewTextRect.Top() ) * fYScale; + double fBottomDiff= static_cast( aAdjustedTextRect.Bottom()- aNewTextRect.Bottom()) * fYScale; + aReturnValue.AdjustLeft(static_cast(fLeftDiff) ); + aReturnValue.AdjustRight(static_cast(fRightDiff) ); + aReturnValue.AdjustTop(static_cast(fTopDiff) ); + aReturnValue.AdjustBottom(static_cast(fBottomDiff) ); + } + } + return aReturnValue; +} + +bool SdrObjCustomShape::NbcAdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt) +{ + tools::Rectangle aNewTextRect = ImpCalculateTextFrame(bHgt, bWdt); + const bool bRet = !aNewTextRect.IsEmpty() && aNewTextRect != getRectangle(); + if (bRet && !mbAdjustingTextFrameWidthAndHeight) + { + mbAdjustingTextFrameWidthAndHeight = true; + + // taking care of handles that should not been changed + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + + setRectangle(aNewTextRect); + SetBoundAndSnapRectsDirty(); + SetChanged(); + + for (const auto& rInteraction : aInteractionHandles) + { + try + { + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_FIXED ) + rInteraction.xInteraction->setControllerPosition( rInteraction.aPosition ); + } + catch ( const uno::RuntimeException& ) + { + } + } + InvalidateRenderGeometry(); + + mbAdjustingTextFrameWidthAndHeight = false; + } + return bRet; +} + +bool SdrObjCustomShape::AdjustTextFrameWidthAndHeight() +{ + tools::Rectangle aNewTextRect = ImpCalculateTextFrame( true/*bHgt*/, true/*bWdt*/ ); + bool bRet = !aNewTextRect.IsEmpty() && ( aNewTextRect != getRectangle()); + if ( bRet ) + { + tools::Rectangle aBoundRect0; + if ( m_pUserCall ) + aBoundRect0 = GetCurrentBoundRect(); + + // taking care of handles that should not been changed + std::vector< SdrCustomShapeInteraction > aInteractionHandles( GetInteractionHandles() ); + + setRectangle(aNewTextRect); + SetBoundAndSnapRectsDirty(); + + for (const auto& rInteraction : aInteractionHandles) + { + try + { + if ( rInteraction.nMode & CustomShapeHandleModes::RESIZE_FIXED ) + rInteraction.xInteraction->setControllerPosition( rInteraction.aPosition ); + } + catch ( const uno::RuntimeException& ) + { + } + } + + InvalidateRenderGeometry(); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } + return bRet; +} +void SdrObjCustomShape::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, tools::Rectangle* pViewInit, tools::Rectangle* pViewMin) const +{ + tools::Rectangle aViewInit; + TakeTextAnchorRect( aViewInit ); + if (maGeo.m_nRotationAngle) + { + Point aCenter(aViewInit.Center()); + aCenter-=aViewInit.TopLeft(); + Point aCenter0(aCenter); + RotatePoint(aCenter, Point(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aCenter-=aCenter0; + aViewInit.Move(aCenter.X(),aCenter.Y()); + } + Size aAnkSiz(aViewInit.GetSize()); + aAnkSiz.AdjustWidth( -1 ); aAnkSiz.AdjustHeight( -1 ); // because GetSize() adds 1 + Size aMaxSiz(1000000,1000000); + { + Size aTmpSiz(getSdrModelFromSdrObject().GetMaxObjSize()); + if (aTmpSiz.Width()!=0) aMaxSiz.setWidth(aTmpSiz.Width() ); + if (aTmpSiz.Height()!=0) aMaxSiz.setHeight(aTmpSiz.Height() ); + } + SdrTextHorzAdjust eHAdj(GetTextHorizontalAdjust()); + SdrTextVertAdjust eVAdj(GetTextVerticalAdjust()); + + tools::Long nMinWdt = GetMinTextFrameWidth(); + tools::Long nMinHgt = GetMinTextFrameHeight(); + tools::Long nMaxWdt = GetMaxTextFrameWidth(); + tools::Long nMaxHgt = GetMaxTextFrameHeight(); + if (nMinWdt<1) nMinWdt=1; + if (nMinHgt<1) nMinHgt=1; + if ( nMaxWdt == 0 || nMaxWdt > aMaxSiz.Width() ) + nMaxWdt = aMaxSiz.Width(); + if ( nMaxHgt == 0 || nMaxHgt > aMaxSiz.Height() ) + nMaxHgt=aMaxSiz.Height(); + + if (GetMergedItem(SDRATTR_TEXT_WORDWRAP).GetValue()) + { + if ( IsVerticalWriting() ) + { + nMaxHgt = aAnkSiz.Height(); + nMinHgt = nMaxHgt; + } + else + { + nMaxWdt = aAnkSiz.Width(); + nMinWdt = nMaxWdt; + } + } + Size aPaperMax(nMaxWdt, nMaxHgt); + Size aPaperMin(nMinWdt, nMinHgt); + + if ( pViewMin ) + { + *pViewMin = aViewInit; + + tools::Long nXFree = aAnkSiz.Width() - aPaperMin.Width(); + if ( eHAdj == SDRTEXTHORZADJUST_LEFT ) + pViewMin->AdjustRight( -nXFree ); + else if ( eHAdj == SDRTEXTHORZADJUST_RIGHT ) + pViewMin->AdjustLeft(nXFree ); + else { pViewMin->AdjustLeft(nXFree / 2 ); pViewMin->SetRight( pViewMin->Left() + aPaperMin.Width() ); } + + tools::Long nYFree = aAnkSiz.Height() - aPaperMin.Height(); + if ( eVAdj == SDRTEXTVERTADJUST_TOP ) + pViewMin->AdjustBottom( -nYFree ); + else if ( eVAdj == SDRTEXTVERTADJUST_BOTTOM ) + pViewMin->AdjustTop(nYFree ); + else { pViewMin->AdjustTop(nYFree / 2 ); pViewMin->SetBottom( pViewMin->Top() + aPaperMin.Height() ); } + } + + if( IsVerticalWriting() ) + aPaperMin.setWidth( 0 ); + else + aPaperMin.setHeight( 0 ); + + if( eHAdj != SDRTEXTHORZADJUST_BLOCK ) + aPaperMin.setWidth(0 ); + + // For complete vertical adjust support, set paper min height to 0, here. + if(SDRTEXTVERTADJUST_BLOCK != eVAdj ) + aPaperMin.setHeight( 0 ); + + if (pPaperMin!=nullptr) *pPaperMin=aPaperMin; + if (pPaperMax!=nullptr) *pPaperMax=aPaperMax; + if (pViewInit!=nullptr) *pViewInit=aViewInit; +} +void SdrObjCustomShape::EndTextEdit( SdrOutliner& rOutl ) +{ + SdrTextObj::EndTextEdit( rOutl ); + InvalidateRenderGeometry(); +} +void SdrObjCustomShape::TakeTextAnchorRect( tools::Rectangle& rAnchorRect ) const +{ + if ( GetTextBounds( rAnchorRect ) ) + { + Point aRotateRef( maSnapRect.Center() ); + AdjustRectToTextDistance(rAnchorRect); + + if ( rAnchorRect.GetWidth() < 2 ) + rAnchorRect.SetRight( rAnchorRect.Left() + 1 ); // minimal width is 2 + if ( rAnchorRect.GetHeight() < 2 ) + rAnchorRect.SetBottom( rAnchorRect.Top() + 1 ); // minimal height is 2 + if (maGeo.m_nRotationAngle) + { + Point aP( rAnchorRect.TopLeft() ); + RotatePoint(aP, aRotateRef, maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + rAnchorRect.SetPos( aP ); + } + } + else + SdrTextObj::TakeTextAnchorRect( rAnchorRect ); +} +void SdrObjCustomShape::TakeTextRect( SdrOutliner& rOutliner, tools::Rectangle& rTextRect, bool bNoEditText, + tools::Rectangle* pAnchorRect, bool /*bLineWidth*/) const +{ + tools::Rectangle aAnkRect; // Rect in which we anchor + TakeTextAnchorRect(aAnkRect); + SdrTextVertAdjust eVAdj=GetTextVerticalAdjust(); + SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust(); + EEControlBits nStat0=rOutliner.GetControlWord(); + Size aNullSize; + + rOutliner.SetControlWord(nStat0|EEControlBits::AUTOPAGESIZE); + rOutliner.SetMinAutoPaperSize(aNullSize); + sal_Int32 nMaxAutoPaperWidth = 1000000; + sal_Int32 nMaxAutoPaperHeight= 1000000; + + tools::Long nAnkWdt=aAnkRect.GetWidth(); + tools::Long nAnkHgt=aAnkRect.GetHeight(); + + if (GetMergedItem(SDRATTR_TEXT_WORDWRAP).GetValue()) + { + if ( IsVerticalWriting() ) + nMaxAutoPaperHeight = nAnkHgt; + else + nMaxAutoPaperWidth = nAnkWdt; + } + if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting()) + { + rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0)); + } + + if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting()) + { + rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt)); + } + rOutliner.SetMaxAutoPaperSize( Size( nMaxAutoPaperWidth, nMaxAutoPaperHeight ) ); + rOutliner.SetPaperSize( aNullSize ); + + // put text into the Outliner - if necessary the use the text from the EditOutliner + std::optional pPara; + if (GetOutlinerParaObject()) + pPara = *GetOutlinerParaObject(); + if (mpEditingOutliner && !bNoEditText) + pPara=mpEditingOutliner->CreateParaObject(); + + if (pPara) + { + bool bHitTest(&getSdrModelFromSdrObject().GetHitTestOutliner() == &rOutliner); + const SdrTextObj* pTestObj = rOutliner.GetTextObj(); + + if( !pTestObj || !bHitTest || pTestObj != this || + pTestObj->GetOutlinerParaObject() != GetOutlinerParaObject() ) + { + if( bHitTest ) + rOutliner.SetTextObj( this ); + + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(*pPara); + } + } + else + { + rOutliner.SetTextObj( nullptr ); + } + + rOutliner.SetUpdateLayout(true); + rOutliner.SetControlWord(nStat0); + + SdrText* pText = getActiveText(); + if( pText ) + pText->CheckPortionInfo( rOutliner ); + + Point aTextPos(aAnkRect.TopLeft()); + Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() has a little added tolerance, no? + + // For draw objects containing text correct horizontal/vertical alignment if text is bigger + // than the object itself. Without that correction, the text would always be + // formatted to the left edge (or top edge when vertical) of the draw object. + + if( !IsTextFrame() ) + { + if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting()) + { + // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTHORZADJUST_BLOCK == eHAdj) + { + SvxAdjust eAdjust = GetObjectItemSet().Get(EE_PARA_JUST).GetAdjust(); + switch (eAdjust) + { + case SvxAdjust::Left: eHAdj = SDRTEXTHORZADJUST_LEFT; break; + case SvxAdjust::Right: eHAdj = SDRTEXTHORZADJUST_RIGHT; break; + case SvxAdjust::Center: eHAdj = SDRTEXTHORZADJUST_CENTER; break; + default: break; + } + } + } + + if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting()) + { + // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTVERTADJUST_BLOCK == eVAdj) + { + eVAdj = SDRTEXTVERTADJUST_CENTER; + } + } + } + + if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT) + { + tools::Long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width(); + if (eHAdj==SDRTEXTHORZADJUST_CENTER) + aTextPos.AdjustX(nFreeWdt/2 ); + if (eHAdj==SDRTEXTHORZADJUST_RIGHT) + aTextPos.AdjustX(nFreeWdt ); + } + if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM) + { + tools::Long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height(); + if (eVAdj==SDRTEXTVERTADJUST_CENTER) + aTextPos.AdjustY(nFreeHgt/2 ); + if (eVAdj==SDRTEXTVERTADJUST_BOTTOM) + aTextPos.AdjustY(nFreeHgt ); + } + if (maGeo.m_nRotationAngle != 0_deg100) + RotatePoint(aTextPos,aAnkRect.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + if (pAnchorRect) + *pAnchorRect=aAnkRect; + + // using rTextRect together with ContourFrame doesn't always work correctly + rTextRect=tools::Rectangle(aTextPos,aTextSiz); +} + +void SdrObjCustomShape::NbcSetOutlinerParaObject(std::optional pTextObject) +{ + SdrTextObj::NbcSetOutlinerParaObject( std::move(pTextObject) ); + SetBoundRectDirty(); + SetBoundAndSnapRectsDirty(true); + InvalidateRenderGeometry(); +} + +rtl::Reference SdrObjCustomShape::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrObjCustomShape(rTargetModel, *this); +} + +OUString SdrObjCustomShape::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulCUSTOMSHAPE)); + OUString aNm(GetName()); + if (!aNm.isEmpty()) + sName += " '" + aNm + "'"; + return sName; +} + +OUString SdrObjCustomShape::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralCUSTOMSHAPE); +} + +basegfx::B2DPolyPolygon SdrObjCustomShape::TakeXorPoly() const +{ + return GetLineGeometry( false ); +} + +basegfx::B2DPolyPolygon SdrObjCustomShape::TakeContour() const +{ + const SdrObject* pSdrObject = GetSdrObjectFromCustomShape(); + if ( pSdrObject ) + return pSdrObject->TakeContour(); + return basegfx::B2DPolyPolygon(); +} + +rtl::Reference SdrObjCustomShape::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + // #i37011# + rtl::Reference pRetval; + SdrObject* pRenderedCustomShape = nullptr; + + if ( !mXRenderedCustomShape.is() ) + { + // force CustomShape + GetSdrObjectFromCustomShape(); + } + + if ( mXRenderedCustomShape.is() ) + { + pRenderedCustomShape = SdrObject::getSdrObjectFromXShape(mXRenderedCustomShape); + } + + if ( pRenderedCustomShape ) + { + // Clone to same SdrModel + rtl::Reference pCandidate(pRenderedCustomShape->CloneSdrObject(pRenderedCustomShape->getSdrModelFromSdrObject())); + DBG_ASSERT(pCandidate, "SdrObjCustomShape::DoConvertToPolyObj: Could not clone SdrObject (!)"); + pRetval = pCandidate->DoConvertToPolyObj(bBezier, bAddText); + pCandidate.clear(); + + if(pRetval) + { + const bool bShadow(GetMergedItem(SDRATTR_SHADOW).GetValue()); + if(bShadow) + { + pRetval->SetMergedItem(makeSdrShadowItem(true)); + } + } + + if(bAddText && HasText() && !IsTextPath()) + { + pRetval = ImpConvertAddText(std::move(pRetval), bBezier); + } + } + + return pRetval; +} + +void SdrObjCustomShape::InternalSetStyleSheet( SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr, bool bBroadcast ) +{ + // #i40944# + InvalidateRenderGeometry(); + SdrObject::InternalSetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr, bBroadcast ); +} + +void SdrObjCustomShape::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + // call parent + SdrTextObj::handlePageChange(pOldPage, pNewPage); + + if(nullptr != pNewPage) + { + // invalidating rectangles by SetRectsDirty is not sufficient, + // AdjustTextFrameWidthAndHeight() also has to be made, both + // actions are done by NbcSetSnapRect + tools::Rectangle aRectangle(getRectangle()); //creating temporary rectangle #i61108# + NbcSetSnapRect(aRectangle); + } +} + +std::unique_ptr SdrObjCustomShape::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrObjCustomShape::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrTextObj::SaveGeoData( rGeo ); + SdrAShapeObjGeoData& rAGeo=static_cast(rGeo); + rAGeo.fObjectRotation = m_fObjectRotation; + rAGeo.bMirroredX = IsMirroredX(); + rAGeo.bMirroredY = IsMirroredY(); + + const uno::Any* pAny = GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ).GetPropertyValueByName( "AdjustmentValues" ); + if ( pAny ) + *pAny >>= rAGeo.aAdjustmentSeq; +} + +void SdrObjCustomShape::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrTextObj::RestoreGeoData( rGeo ); + const SdrAShapeObjGeoData& rAGeo=static_cast(rGeo); + m_fObjectRotation = rAGeo.fObjectRotation; + SetMirroredX( rAGeo.bMirroredX ); + SetMirroredY( rAGeo.bMirroredY ); + + SdrCustomShapeGeometryItem rGeometryItem = GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ); + beans::PropertyValue aPropVal; + aPropVal.Name = "AdjustmentValues"; + aPropVal.Value <<= rAGeo.aAdjustmentSeq; + rGeometryItem.SetPropertyValue( aPropVal ); + SetMergedItem( rGeometryItem ); + + InvalidateRenderGeometry(); +} + +void SdrObjCustomShape::AdjustToMaxRect(const tools::Rectangle& rMaxRect, bool bShrinkOnly /* = false */) +{ + SAL_INFO_IF(bShrinkOnly, "svx", "Case bShrinkOnly == true is not implemented yet."); + + if (rMaxRect.IsEmpty() || rMaxRect == GetSnapRect()) + return; + + // Get a matrix, that would produce the existing shape, when applied to a unit square + basegfx::B2DPolyPolygon aPolyPolygon; //not used, but formal needed + basegfx::B2DHomMatrix aMatrix; + TRGetBaseGeometry(aMatrix, aPolyPolygon); + // Using TRSetBaseGeometry(aMatrix, aPolyPolygon) would regenerate the current shape. But + // applying aMatrix to a unit square will not generate the current shape. Scaling, + // rotation and translation are correct, but shear angle has wrong sign. So break up + // matrix and create a mathematically correct new one. + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + aMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + basegfx::B2DHomMatrix aMathMatrix; + aMathMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, + basegfx::fTools::equalZero(fShearX) ? 0.0 : -fShearX, + basegfx::fTools::equalZero(fRotate) ? 0.0 : fRotate, + aTranslate); + + // Calculate scaling factors from size of the transformed unit polygon as ersatz for the not + // usable current snap rectangle. + basegfx::B2DPolygon aB2DPolygon(basegfx::utils::createUnitPolygon()); + aB2DPolygon.transform(aMathMatrix); + basegfx::B2DRange aB2DRange(aB2DPolygon.getB2DRange()); + double fPolygonWidth = aB2DRange.getWidth(); + if (fPolygonWidth == 0) + fPolygonWidth = 1; + double fPolygonHeight = aB2DRange.getHeight(); + if (fPolygonHeight == 0) + fPolygonHeight = 1; + const double aFactorX = static_cast(rMaxRect.GetWidth()) / fPolygonWidth; + const double aFactorY = static_cast(rMaxRect.GetHeight()) / fPolygonHeight; + + // Generate matrix, that would produce the desired rMaxRect when applied to unit square + aMathMatrix.scale(aFactorX, aFactorY); + aB2DPolygon = basegfx::utils::createUnitPolygon(); + aB2DPolygon.transform(aMathMatrix); + aB2DRange = aB2DPolygon.getB2DRange(); + const double fPolygonLeft = aB2DRange.getMinX(); + const double fPolygonTop = aB2DRange.getMinY(); + aMathMatrix.translate(rMaxRect.Left() - fPolygonLeft, rMaxRect.Top() - fPolygonTop); + + // Create a Matrix from aMathMatrix, which is usable with TRSetBaseGeometry + aMathMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + aMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, + basegfx::fTools::equalZero(fShearX) ? 0.0 : -fShearX, + basegfx::fTools::equalZero(fRotate) ? 0.0 : fRotate, + aTranslate); + + // Now use TRSetBaseGeometry to actually perform scale, shear, rotate and translate + // on the shape. That considers gluepoints, interaction handles and text area, and includes + // setting rectangles dirty and broadcast. + TRSetBaseGeometry(aMatrix, aPolyPolygon); +} + +void SdrObjCustomShape::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/) +{ + // The shape might have already flipping in its enhanced geometry. LibreOffice applies + // such after all transformations. We remove it, but remember it to apply them later. + bool bIsMirroredX = IsMirroredX(); + bool bIsMirroredY = IsMirroredY(); + if (bIsMirroredX || bIsMirroredY) + { + Point aCurrentCenter = GetSnapRect().Center(); + if (bIsMirroredX) // mirror on the y-axis + { + Mirror(aCurrentCenter, Point(aCurrentCenter.X(), aCurrentCenter.Y() + 1000)); + } + if (bIsMirroredY) // mirror on the x-axis + { + Mirror(aCurrentCenter, Point(aCurrentCenter.X() + 1000, aCurrentCenter.Y())); + } + } + + // break up matrix + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + rMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // reset object shear and rotations + m_fObjectRotation = 0.0; + maGeo.m_nRotationAngle = 0_deg100; + maGeo.RecalcSinCos(); + maGeo.m_nShearAngle = 0_deg100; + maGeo.RecalcTan(); + + // if anchor is used, make position relative to it + if(getSdrModelFromSdrObject().IsWriter()) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // scale + Size aSize(FRound(fabs(aScale.getX())), FRound(fabs(aScale.getY()))); + // fdo#47434 We need a valid rectangle here + if( !aSize.Height() ) aSize.setHeight( 1 ); + if( !aSize.Width() ) aSize.setWidth( 1 ); + tools::Rectangle aBaseRect(Point(), aSize); + SetLogicRect(aBaseRect); + + // Apply flipping from Matrix, which is a transformation relative to origin + if (basegfx::fTools::less(aScale.getX(), 0.0)) + Mirror(Point(0, 0), Point(0, 1000)); // mirror on the y-axis + if (basegfx::fTools::less(aScale.getY(), 0.0)) + Mirror(Point(0, 0), Point(1000, 0)); // mirror on the x-axis + + // shear? + if(!basegfx::fTools::equalZero(fShearX)) + { + GeoStat aGeoStat; + // #i123181# The fix for #121932# here was wrong, the trunk version does not correct the + // mirrored shear values, neither at the object level, nor on the API or XML level. Taking + // back the mirroring of the shear angle + aGeoStat.m_nShearAngle = Degree100(FRound(basegfx::rad2deg<100>(atan(fShearX)))); + aGeoStat.RecalcTan(); + Shear(Point(), aGeoStat.m_nShearAngle, aGeoStat.mfTanShearAngle, false); + } + + // rotation? + if(!basegfx::fTools::equalZero(fRotate)) + { + GeoStat aGeoStat; + + // #i78696# + // fRotate is mathematically correct, but aGeoStat.nRotationAngle is + // mirrored -> mirror value here + aGeoStat.m_nRotationAngle = NormAngle36000(Degree100(FRound(-basegfx::rad2deg<100>(fRotate)))); + aGeoStat.RecalcSinCos(); + Rotate(Point(), aGeoStat.m_nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle); + } + + // translate? + if(!aTranslate.equalZero()) + { + Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY()))); + } + + // Apply flipping from enhanced geometry at center of the shape. + if (!(bIsMirroredX || bIsMirroredY)) + return; + + // create mathematically matrix for the applied transformations + // aScale was in most cases built from a rectangle including edge + // and is therefore mathematically too large by 1 + if (aScale.getX() > 2.0 && aScale.getY() > 2.0) + aScale -= basegfx::B2DTuple(1.0, 1.0); + basegfx::B2DHomMatrix aMathMat = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, -fShearX, basegfx::fTools::equalZero(fRotate) ? 0.0 : fRotate, + aTranslate); + // Use matrix to get current center + basegfx::B2DPoint aCenter(0.5,0.5); + aCenter = aMathMat * aCenter; + double fCenterX = aCenter.getX(); + double fCenterY = aCenter.getY(); + if (bIsMirroredX) // vertical axis + Mirror(Point(FRound(fCenterX),FRound(fCenterY)), + Point(FRound(fCenterX), FRound(fCenterY + 1000.0))); + if (bIsMirroredY) // horizontal axis + Mirror(Point(FRound(fCenterX),FRound(fCenterY)), + Point(FRound(fCenterX + 1000.0), FRound(fCenterY))); +} + +// taking fObjectRotation instead of aGeo.nAngle +bool SdrObjCustomShape::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const +{ + // get turn and shear + double fRotate = basegfx::deg2rad(m_fObjectRotation); + double fShearX = toRadians(maGeo.m_nShearAngle); + + // get aRectangle, this is the unrotated snaprect + tools::Rectangle aRectangle(getRectangle()); + + bool bMirroredX = IsMirroredX(); + bool bMirroredY = IsMirroredY(); + if ( bMirroredX || bMirroredY ) + { // we have to retrieve the unmirrored rect + + GeoStat aNewGeo(maGeo); + + if ( bMirroredX ) + { + fShearX = -fShearX; + tools::Polygon aPol = Rect2Poly(getRectangle(), aNewGeo); + tools::Rectangle aBoundRect( aPol.GetBoundRect() ); + + Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() ); + Point aRef2( aRef1.X(), aRef1.Y() + 1000 ); + sal_uInt16 i; + sal_uInt16 nPointCount=aPol.GetSize(); + for (i=0; i> 1 ); + Point aRef2( aRef1.X() + 1000, aRef1.Y() ); + sal_uInt16 i; + sal_uInt16 nPointCount=aPol.GetSize(); + for (i=0; i SdrObjCustomShape::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +// #i33136# +bool SdrObjCustomShape::doConstructOrthogonal(std::u16string_view rName) +{ + bool bRetval(false); + + if(o3tl::equalsIgnoreAsciiCase(rName, u"quadrat")) + { + bRetval = true; + } + else if(o3tl::equalsIgnoreAsciiCase(rName, u"round-quadrat")) + { + bRetval = true; + } + else if(o3tl::equalsIgnoreAsciiCase(rName, u"circle")) + { + bRetval = true; + } + else if(o3tl::equalsIgnoreAsciiCase(rName, u"circle-pie")) + { + bRetval = true; + } + else if(o3tl::equalsIgnoreAsciiCase(rName, u"ring")) + { + bRetval = true; + } + + return bRetval; +} + +// #i37011# centralize throw-away of render geometry +void SdrObjCustomShape::InvalidateRenderGeometry() +{ + mXRenderedCustomShape = nullptr; + mpLastShadowGeometry = nullptr; +} + +void SdrObjCustomShape::setUnoShape(const uno::Reference& rxUnoShape) +{ + SdrTextObj::setUnoShape(rxUnoShape); + + // The shape engine is created with _current_ shape. This means we + // _must_ reset it when the shape changes. + mxCustomShapeEngine.clear(); +} + +OUString SdrObjCustomShape::GetCustomShapeName() const +{ + OUString sShapeName; + OUString aEngine( GetMergedItem( SDRATTR_CUSTOMSHAPE_ENGINE ).GetValue() ); + if ( aEngine.isEmpty() + || aEngine == "com.sun.star.drawing.EnhancedCustomShapeEngine" ) + { + OUString sShapeType; + const SdrCustomShapeGeometryItem& rGeometryItem( GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); + const uno::Any* pAny = rGeometryItem.GetPropertyValueByName( "Type" ); + if ( pAny && ( *pAny >>= sShapeType ) ) + sShapeName = EnhancedCustomShapeTypeNames::GetAccName( sShapeType ); + } + return sShapeName; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoattr.cxx b/svx/source/svdraw/svdoattr.cxx new file mode 100644 index 0000000000..ae4f59baa5 --- /dev/null +++ b/svx/source/svdraw/svdoattr.cxx @@ -0,0 +1,98 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +SdrAttrObj::SdrAttrObj(SdrModel& rSdrModel) + : SdrObject(rSdrModel) +{ +} + +SdrAttrObj::SdrAttrObj(SdrModel& rSdrModel, SdrAttrObj const& rSource) + : SdrObject(rSdrModel, rSource) +{ +} + +SdrAttrObj::~SdrAttrObj() {} + +const tools::Rectangle& SdrAttrObj::GetSnapRect() const +{ + if (m_bSnapRectDirty) + { + const_cast(this)->RecalcSnapRect(); + const_cast(this)->m_bSnapRectDirty = false; + } + + return maSnapRect; +} + +// syntactical sugar for ItemSet accesses +void SdrAttrObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint) +{ + bool bDataChg(SfxHintId::DataChanged == rHint.GetId()); + + if (bDataChg) + { + tools::Rectangle aBoundRect = GetLastBoundRect(); + SetBoundRectDirty(); + SetBoundAndSnapRectsDirty(/*bNotMyself*/ true); + + // This may have led to object change + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::ChangeAttr, aBoundRect); + } +} + +sal_Int32 SdrAttrObj::ImpGetLineWdt() const +{ + sal_Int32 nRetval(0); + + if (drawing::LineStyle_NONE != GetObjectItem(XATTR_LINESTYLE).GetValue()) + { + nRetval = GetObjectItem(XATTR_LINEWIDTH).GetValue(); + } + + return nRetval; +} + +bool SdrAttrObj::HasFill() const +{ + return m_bClosedObj + && GetProperties().GetObjectItemSet().Get(XATTR_FILLSTYLE).GetValue() + != drawing::FillStyle_NONE; +} + +bool SdrAttrObj::HasLine() const +{ + return GetProperties().GetObjectItemSet().Get(XATTR_LINESTYLE).GetValue() + != drawing::LineStyle_NONE; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdobj.cxx b/svx/source/svdraw/svdobj.cxx new file mode 100644 index 0000000000..f4d13219db --- /dev/null +++ b/svx/source/svdraw/svdobj.cxx @@ -0,0 +1,3434 @@ +/* -*- 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 +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include +#include +#include +#include + +using namespace ::com::sun::star; + + +SdrObjUserCall::~SdrObjUserCall() +{ +} + +void SdrObjUserCall::Changed(const SdrObject& /*rObj*/, SdrUserCallType /*eType*/, const tools::Rectangle& /*rOldBoundRect*/) +{ +} + +void const* SdrObjUserCall::GetPDFAnchorStructureElementKey(SdrObject const&) +{ + return nullptr; +} + +SdrObjMacroHitRec::SdrObjMacroHitRec() : + pVisiLayer(nullptr), + pPageView(nullptr), + nTol(0) {} + + +SdrObjUserData::SdrObjUserData(SdrInventor nInv, sal_uInt16 nId) : + m_nInventor(nInv), + m_nIdentifier(nId) {} + +SdrObjUserData::SdrObjUserData(const SdrObjUserData& rData) : + m_nInventor(rData.m_nInventor), + m_nIdentifier(rData.m_nIdentifier) {} + +SdrObjUserData::~SdrObjUserData() {} + +SdrObjGeoData::SdrObjGeoData(): + bMovProt(false), + bSizProt(false), + bNoPrint(false), + bClosedObj(false), + mbVisible(true), + mnLayerID(0) +{ +} + +SdrObjGeoData::~SdrObjGeoData() +{ +} + +SdrObjTransformInfoRec::SdrObjTransformInfoRec() : + bMoveAllowed(true), + bResizeFreeAllowed(true), + bResizePropAllowed(true), + bRotateFreeAllowed(true), + bRotate90Allowed(true), + bMirrorFreeAllowed(true), + bMirror45Allowed(true), + bMirror90Allowed(true), + bTransparenceAllowed(true), + bShearAllowed(true), + bEdgeRadiusAllowed(true), + bNoOrthoDesired(true), + bNoContortion(true), + bCanConvToPath(true), + bCanConvToPoly(true), + bCanConvToContour(false), + bCanConvToPathLineToArea(true), + bCanConvToPolyLineToArea(true) {} + +struct SdrObject::Impl +{ + sdr::ObjectUserVector maObjectUsers; + std::optional mnRelativeWidth; + std::optional mnRelativeHeight; + sal_Int16 meRelativeWidthRelation; + sal_Int16 meRelativeHeightRelation; + + Impl() : + meRelativeWidthRelation(text::RelOrientation::PAGE_FRAME), + meRelativeHeightRelation(text::RelOrientation::PAGE_FRAME) {} +}; + +const std::shared_ptr< svx::diagram::IDiagramHelper >& SdrObject::getDiagramHelper() const +{ + static std::shared_ptr< svx::diagram::IDiagramHelper > aEmpty; + return aEmpty; +} + +// BaseProperties section + +sdr::properties::BaseProperties& SdrObject::GetProperties() const +{ + if(!mpProperties) + { + // CAUTION(!) Do *not* call this during SdrObject construction, + // that will lead to wrong type-casts (dependent on constructor-level) + // and thus eventually create the wrong sdr::properties (!). Is there + // a way to check if on the stack is a SdrObject-constructor (?) + const_cast< SdrObject* >(this)->mpProperties = + const_cast< SdrObject* >(this)->CreateObjectSpecificProperties(); + } + + return *mpProperties; +} + + +// ObjectUser section + +void SdrObject::AddObjectUser(sdr::ObjectUser& rNewUser) +{ + mpImpl->maObjectUsers.push_back(&rNewUser); +} + +void SdrObject::RemoveObjectUser(sdr::ObjectUser& rOldUser) +{ + const sdr::ObjectUserVector::iterator aFindResult = + std::find(mpImpl->maObjectUsers.begin(), mpImpl->maObjectUsers.end(), &rOldUser); + if (aFindResult != mpImpl->maObjectUsers.end()) + { + mpImpl->maObjectUsers.erase(aFindResult); + } +} + + +// DrawContact section + +std::unique_ptr SdrObject::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +sdr::contact::ViewContact& SdrObject::GetViewContact() const +{ + if(!mpViewContact) + { + const_cast< SdrObject* >(this)->mpViewContact = + const_cast< SdrObject* >(this)->CreateObjectSpecificViewContact(); + } + + return *mpViewContact; +} + +// DrawContact support: Methods for handling Object changes +void SdrObject::ActionChanged() const +{ + // Do necessary ViewContact actions + GetViewContact().ActionChanged(); +} + +SdrPage* SdrObject::getSdrPageFromSdrObject() const +{ + if (SdrObjList* pParentList = getParentSdrObjListFromSdrObject()) + { + return pParentList->getSdrPageFromSdrObjList(); + } + + return nullptr; +} + +SdrModel& SdrObject::getSdrModelFromSdrObject() const +{ + return mrSdrModelFromSdrObject; +} + +void SdrObject::setParentOfSdrObject(SdrObjList* pNewObjList) +{ + assert(!pNewObjList || mpParentOfSdrObject != pNewObjList); + if(mpParentOfSdrObject == pNewObjList) + return; + // we need to be removed from the old parent before we are attached to the new parent + assert(bool(mpParentOfSdrObject) != bool(pNewObjList) && "may only transition empty->full or full->empty"); + + // remember current page + SdrPage* pOldPage(getSdrPageFromSdrObject()); + + // set new parent + mpParentOfSdrObject = pNewObjList; + + // get new page + SdrPage* pNewPage(getSdrPageFromSdrObject()); + + // broadcast page change over objects if needed + if(pOldPage != pNewPage) + { + handlePageChange(pOldPage, pNewPage); + } +} + +SdrObjList* SdrObject::getParentSdrObjListFromSdrObject() const +{ + return mpParentOfSdrObject; +} + +SdrObjList* SdrObject::getChildrenOfSdrObject() const +{ + // default has no children + return nullptr; +} + +void SdrObject::SetBoundRectDirty() +{ + resetOutRectangle(); +} + +#ifdef DBG_UTIL +// SdrObjectLifetimeWatchDog: +void impAddIncarnatedSdrObjectToSdrModel(SdrObject& rSdrObject, SdrModel& rSdrModel) +{ + rSdrModel.maAllIncarnatedObjects.insert(&rSdrObject); +} +void impRemoveIncarnatedSdrObjectToSdrModel(SdrObject& rSdrObject, SdrModel& rSdrModel) +{ + if(!rSdrModel.maAllIncarnatedObjects.erase(&rSdrObject)) + { + assert(false && "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"); + } +} +#endif + +SdrObject::SdrObject(SdrModel& rSdrModel) +: mpFillGeometryDefiningShape(nullptr) + ,mrSdrModelFromSdrObject(rSdrModel) + ,m_pUserCall(nullptr) + ,mpImpl(new Impl) + ,mpParentOfSdrObject(nullptr) + ,m_nOrdNum(0) + ,mnNavigationPosition(SAL_MAX_UINT32) + ,mnLayerID(0) + ,mpSvxShape( nullptr ) + ,mbDoNotInsertIntoPageAutomatically(false) +{ + m_bVirtObj =false; + m_bSnapRectDirty =true; + m_bMovProt =false; + m_bSizProt =false; + m_bNoPrint =false; + m_bEmptyPresObj =false; + m_bNotVisibleAsMaster=false; + m_bClosedObj =false; + mbVisible = true; + + // #i25616# + mbLineIsOutsideGeometry = false; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; + + m_bIsEdge=false; + m_bIs3DObj=false; + m_bMarkProt=false; + m_bIsUnoObj=false; +#ifdef DBG_UTIL + // SdrObjectLifetimeWatchDog: + impAddIncarnatedSdrObjectToSdrModel(*this, getSdrModelFromSdrObject()); +#endif +} + +SdrObject::SdrObject(SdrModel& rSdrModel, SdrObject const & rSource) +: mpFillGeometryDefiningShape(nullptr) + ,mrSdrModelFromSdrObject(rSdrModel) + ,m_pUserCall(nullptr) + ,mpImpl(new Impl) + ,mpParentOfSdrObject(nullptr) + ,m_nOrdNum(0) + ,mnNavigationPosition(SAL_MAX_UINT32) + ,mnLayerID(0) + ,mpSvxShape( nullptr ) + ,mbDoNotInsertIntoPageAutomatically(false) +{ + m_bVirtObj =false; + m_bSnapRectDirty =true; + m_bMovProt =false; + m_bSizProt =false; + m_bNoPrint =false; + m_bEmptyPresObj =false; + m_bNotVisibleAsMaster=false; + m_bClosedObj =false; + mbVisible = true; + + // #i25616# + mbLineIsOutsideGeometry = false; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; + + m_bIsEdge=false; + m_bIs3DObj=false; + m_bMarkProt=false; + m_bIsUnoObj=false; + + mpProperties.reset(); + mpViewContact.reset(); + + // The CloneSdrObject() method uses the local copy constructor from the individual + // sdr::properties::BaseProperties class. Since the target class maybe for another + // draw object, an SdrObject needs to be provided, as in the normal constructor. + mpProperties = rSource.GetProperties().Clone(*this); + + setOutRectangle(rSource.getOutRectangle()); + mnLayerID = rSource.mnLayerID; + m_aAnchor =rSource.m_aAnchor; + m_bVirtObj=rSource.m_bVirtObj; + m_bSizProt=rSource.m_bSizProt; + m_bMovProt=rSource.m_bMovProt; + m_bNoPrint=rSource.m_bNoPrint; + mbVisible=rSource.mbVisible; + m_bMarkProt=rSource.m_bMarkProt; + m_bEmptyPresObj =rSource.m_bEmptyPresObj; + m_bNotVisibleAsMaster=rSource.m_bNotVisibleAsMaster; + m_bSnapRectDirty=true; + m_pPlusData.reset(); + if (rSource.m_pPlusData!=nullptr) { + m_pPlusData.reset(rSource.m_pPlusData->Clone(this)); + } + if (m_pPlusData!=nullptr && m_pPlusData->pBroadcast!=nullptr) { + m_pPlusData->pBroadcast.reset(); // broadcaster isn't copied + } + + m_pGrabBagItem.reset(); + if (rSource.m_pGrabBagItem!=nullptr) + m_pGrabBagItem.reset(rSource.m_pGrabBagItem->Clone()); +#ifdef DBG_UTIL + // SdrObjectLifetimeWatchDog: + impAddIncarnatedSdrObjectToSdrModel(*this, getSdrModelFromSdrObject()); +#endif +} + +SdrObject::~SdrObject() +{ +#ifdef DBG_UTIL + // see logic in SdrObject::release + assert(m_refCount == -1); +#endif + // Tell all the registered ObjectUsers that the page is in destruction. + // And clear the vector. This means that user do not need to call RemoveObjectUser() + // when they get called from ObjectInDestruction(). + sdr::ObjectUserVector aList; + aList.swap(mpImpl->maObjectUsers); + for(sdr::ObjectUser* pObjectUser : aList) + { + DBG_ASSERT(pObjectUser, "SdrObject::~SdrObject: corrupt ObjectUser list (!)"); + pObjectUser->ObjectInDestruction(*this); + } + + // UserCall + SendUserCall(SdrUserCallType::Delete, GetLastBoundRect()); + o3tl::reset_preserve_ptr_during(m_pPlusData); + + m_pGrabBagItem.reset(); + mpProperties.reset(); + mpViewContact.reset(); +#ifdef DBG_UTIL + // SdrObjectLifetimeWatchDog: + impRemoveIncarnatedSdrObjectToSdrModel(*this, getSdrModelFromSdrObject()); +#endif +} + +void SdrObject::acquire() noexcept +{ +#ifdef DBG_UTIL + assert(m_refCount != -1); +#endif + osl_atomic_increment( &m_refCount ); +} + +void SdrObject::release() noexcept +{ + oslInterlockedCount x = osl_atomic_decrement( &m_refCount ); + if ( x == 0 ) + { + disposeWeakConnectionPoint(); +#ifdef DBG_UTIL + // make sure it doesn't accidentally come back to life, see assert in acquire() + osl_atomic_decrement( &m_refCount ); +#endif + delete this; + } +} + +void SdrObject::SetBoundAndSnapRectsDirty(bool bNotMyself, bool bRecursive) +{ + if (!bNotMyself) + { + SetBoundRectDirty(); + m_bSnapRectDirty=true; + } + + if (bRecursive && nullptr != getParentSdrObjListFromSdrObject()) + { + getParentSdrObjListFromSdrObject()->SetSdrObjListRectsDirty(); + } +} + +void SdrObject::handlePageChange(SdrPage*, SdrPage* ) +{ +} + + +// global static ItemPool for not-yet-inserted items +static rtl::Reference mpGlobalItemPool; + +/** If we let the libc runtime clean us up, we trigger a crash */ +namespace +{ +class TerminateListener : public ::cppu::WeakImplHelper< css::frame::XTerminateListener > +{ + void SAL_CALL queryTermination( const lang::EventObject& ) override + {} + void SAL_CALL notifyTermination( const lang::EventObject& ) override + { + mpGlobalItemPool.clear(); + } + virtual void SAL_CALL disposing( const ::css::lang::EventObject& ) override + {} +}; +}; + +// init global static itempool +SdrItemPool& SdrObject::GetGlobalDrawObjectItemPool() +{ + if(!mpGlobalItemPool) + { + mpGlobalItemPool = new SdrItemPool(); + rtl::Reference pGlobalOutlPool = EditEngine::CreatePool(); + mpGlobalItemPool->SetSecondaryPool(pGlobalOutlPool.get()); + mpGlobalItemPool->SetDefaultMetric(SdrEngineDefaults::GetMapUnit()); + mpGlobalItemPool->FreezeIdRanges(); + if (utl::ConfigManager::IsFuzzing()) + mpGlobalItemPool->acquire(); + else + { + uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getProcessComponentContext()); + uno::Reference< frame::XTerminateListener > xListener( new TerminateListener ); + xDesktop->addTerminateListener( xListener ); + } + } + + return *mpGlobalItemPool; +} + +void SdrObject::SetRelativeWidth( double nValue ) +{ + mpImpl->mnRelativeWidth = nValue; +} + +void SdrObject::SetRelativeWidthRelation( sal_Int16 eValue ) +{ + mpImpl->meRelativeWidthRelation = eValue; +} + +void SdrObject::SetRelativeHeight( double nValue ) +{ + mpImpl->mnRelativeHeight = nValue; +} + +void SdrObject::SetRelativeHeightRelation( sal_Int16 eValue ) +{ + mpImpl->meRelativeHeightRelation = eValue; +} + +const double* SdrObject::GetRelativeWidth( ) const +{ + if (!mpImpl->mnRelativeWidth) + return nullptr; + + return &*mpImpl->mnRelativeWidth; +} + +sal_Int16 SdrObject::GetRelativeWidthRelation() const +{ + return mpImpl->meRelativeWidthRelation; +} + +const double* SdrObject::GetRelativeHeight( ) const +{ + if (!mpImpl->mnRelativeHeight) + return nullptr; + + return &*mpImpl->mnRelativeHeight; +} + +sal_Int16 SdrObject::GetRelativeHeightRelation() const +{ + return mpImpl->meRelativeHeightRelation; +} + +SfxItemPool& SdrObject::GetObjectItemPool() const +{ + return getSdrModelFromSdrObject().GetItemPool(); +} + +SdrInventor SdrObject::GetObjInventor() const +{ + return SdrInventor::Default; +} + +SdrObjKind SdrObject::GetObjIdentifier() const +{ + return SdrObjKind::NONE; +} + +void SdrObject::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bRotateFreeAllowed=false; + rInfo.bMirrorFreeAllowed=false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =false; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bCanConvToPath =false; + rInfo.bCanConvToPoly =false; + rInfo.bCanConvToContour = false; + rInfo.bCanConvToPathLineToArea=false; + rInfo.bCanConvToPolyLineToArea=false; +} + +SdrLayerID SdrObject::GetLayer() const +{ + return mnLayerID; +} + +bool SdrObject::isVisibleOnAnyOfTheseLayers(const SdrLayerIDSet& rSet) const +{ + if (rSet.IsSet(GetLayer())) + return true; + SdrObjList* pOL=GetSubList(); + if (!pOL) + return false; + for (const rtl::Reference& pObject : *pOL) + if (pObject->isVisibleOnAnyOfTheseLayers(rSet)) + return true; + return false; +} + +void SdrObject::NbcSetLayer(SdrLayerID nLayer) +{ + mnLayerID = nLayer; +} + +void SdrObject::SetLayer(SdrLayerID nLayer) +{ + NbcSetLayer(nLayer); + SetChanged(); + BroadcastObjectChange(); +} + +void SdrObject::AddListener(SfxListener& rListener) +{ + ImpForcePlusData(); + if (m_pPlusData->pBroadcast==nullptr) m_pPlusData->pBroadcast.reset(new SfxBroadcaster); + + // SdrEdgeObj may be connected to same SdrObject on both ends so allow it + // to listen twice + SdrEdgeObj const*const pEdge(dynamic_cast(&rListener)); + rListener.StartListening(*m_pPlusData->pBroadcast, pEdge ? DuplicateHandling::Allow : DuplicateHandling::Unexpected); +} + +void SdrObject::RemoveListener(SfxListener& rListener) +{ + if (m_pPlusData!=nullptr && m_pPlusData->pBroadcast!=nullptr) { + rListener.EndListening(*m_pPlusData->pBroadcast); + if (!m_pPlusData->pBroadcast->HasListeners()) { + m_pPlusData->pBroadcast.reset(); + } + } +} + +const SfxBroadcaster* SdrObject::GetBroadcaster() const +{ + return m_pPlusData!=nullptr ? m_pPlusData->pBroadcast.get() : nullptr; +} + +void SdrObject::AddReference(SdrVirtObj& rVrtObj) +{ + AddListener(rVrtObj); +} + +void SdrObject::DelReference(SdrVirtObj& rVrtObj) +{ + RemoveListener(rVrtObj); +} + +bool SdrObject::IsGroupObject() const +{ + return GetSubList()!=nullptr; +} + +SdrObjList* SdrObject::GetSubList() const +{ + return nullptr; +} + +SdrObject* SdrObject::getParentSdrObjectFromSdrObject() const +{ + SdrObjList* pParent(getParentSdrObjListFromSdrObject()); + + if(nullptr == pParent) + { + return nullptr; + } + + return pParent->getSdrObjectFromSdrObjList(); +} + +void SdrObject::SetName(const OUString& rStr, const bool bSetChanged) +{ + if (!rStr.isEmpty() && !m_pPlusData) + { + ImpForcePlusData(); + } + + if(!(m_pPlusData && m_pPlusData->aObjName != rStr)) + return; + + // Undo/Redo for setting object's name (#i73249#) + bool bUndo( false ); + if ( getSdrModelFromSdrObject().IsUndoEnabled() ) + { + bUndo = true; + std::unique_ptr pUndoAction = + SdrUndoFactory::CreateUndoObjectStrAttr( + *this, + SdrUndoObjStrAttr::ObjStrAttrType::Name, + GetName(), + rStr ); + getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() ); + getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) ); + } + m_pPlusData->aObjName = rStr; + // Undo/Redo for setting object's name (#i73249#) + if ( bUndo ) + { + getSdrModelFromSdrObject().EndUndo(); + } + if (bSetChanged) + { + SetChanged(); + BroadcastObjectChange(); + } +} + +const OUString & SdrObject::GetName() const +{ + static const OUString EMPTY = u""_ustr; + + if(m_pPlusData) + { + return m_pPlusData->aObjName; + } + + return EMPTY; +} + +void SdrObject::SetTitle(const OUString& rStr) +{ + if (!rStr.isEmpty() && !m_pPlusData) + { + ImpForcePlusData(); + } + + if(!(m_pPlusData && m_pPlusData->aObjTitle != rStr)) + return; + + // Undo/Redo for setting object's title (#i73249#) + bool bUndo( false ); + if ( getSdrModelFromSdrObject().IsUndoEnabled() ) + { + bUndo = true; + std::unique_ptr pUndoAction = + SdrUndoFactory::CreateUndoObjectStrAttr( + *this, + SdrUndoObjStrAttr::ObjStrAttrType::Title, + GetTitle(), + rStr ); + getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() ); + getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) ); + } + m_pPlusData->aObjTitle = rStr; + // Undo/Redo for setting object's title (#i73249#) + if ( bUndo ) + { + getSdrModelFromSdrObject().EndUndo(); + } + SetChanged(); + BroadcastObjectChange(); +} + +OUString SdrObject::GetTitle() const +{ + if(m_pPlusData) + { + return m_pPlusData->aObjTitle; + } + + return OUString(); +} + +void SdrObject::SetDescription(const OUString& rStr) +{ + if (!rStr.isEmpty() && !m_pPlusData) + { + ImpForcePlusData(); + } + + if(!(m_pPlusData && m_pPlusData->aObjDescription != rStr)) + return; + + // Undo/Redo for setting object's description (#i73249#) + bool bUndo( false ); + if ( getSdrModelFromSdrObject().IsUndoEnabled() ) + { + bUndo = true; + std::unique_ptr pUndoAction = + SdrUndoFactory::CreateUndoObjectStrAttr( + *this, + SdrUndoObjStrAttr::ObjStrAttrType::Description, + GetDescription(), + rStr ); + getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() ); + getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) ); + } + m_pPlusData->aObjDescription = rStr; + // Undo/Redo for setting object's description (#i73249#) + if ( bUndo ) + { + getSdrModelFromSdrObject().EndUndo(); + } + SetChanged(); + BroadcastObjectChange(); +} + +OUString SdrObject::GetDescription() const +{ + if(m_pPlusData) + { + return m_pPlusData->aObjDescription; + } + + return OUString(); +} + +void SdrObject::SetDecorative(bool const isDecorative) +{ + ImpForcePlusData(); + + if (m_pPlusData->isDecorative == isDecorative) + { + return; + } + + if (getSdrModelFromSdrObject().IsUndoEnabled()) + { + std::unique_ptr pUndoAction( + SdrUndoFactory::CreateUndoObjectDecorative( + *this, m_pPlusData->isDecorative)); + getSdrModelFromSdrObject().BegUndo(pUndoAction->GetComment()); + getSdrModelFromSdrObject().AddUndo(std::move(pUndoAction)); + } + + m_pPlusData->isDecorative = isDecorative; + + if (getSdrModelFromSdrObject().IsUndoEnabled()) + { + getSdrModelFromSdrObject().EndUndo(); + } + + SetChanged(); + BroadcastObjectChange(); +} + +bool SdrObject::IsDecorative() const +{ + return m_pPlusData == nullptr ? false : m_pPlusData->isDecorative; +} + +sal_uInt32 SdrObject::GetOrdNum() const +{ + if (SdrObjList* pParentList = getParentSdrObjListFromSdrObject()) + { + if (pParentList->IsObjOrdNumsDirty()) + { + pParentList->RecalcObjOrdNums(); + } + } else const_cast(this)->m_nOrdNum=0; + return m_nOrdNum; +} + +void SdrObject::SetOrdNum(sal_uInt32 nNum) +{ + m_nOrdNum = nNum; +} + +void SdrObject::GetGrabBagItem(css::uno::Any& rVal) const +{ + if (m_pGrabBagItem != nullptr) + m_pGrabBagItem->QueryValue(rVal); + else + rVal <<= uno::Sequence(); +} + +void SdrObject::SetGrabBagItem(const css::uno::Any& rVal) +{ + if (m_pGrabBagItem == nullptr) + m_pGrabBagItem.reset(new SfxGrabBagItem); + + m_pGrabBagItem->PutValue(rVal, 0); + + SetChanged(); + BroadcastObjectChange(); +} + +sal_uInt32 SdrObject::GetNavigationPosition() const +{ + if (nullptr != getParentSdrObjListFromSdrObject() && getParentSdrObjListFromSdrObject()->RecalcNavigationPositions()) + { + return mnNavigationPosition; + } + else + return GetOrdNum(); +} + + +void SdrObject::SetNavigationPosition (const sal_uInt32 nNewPosition) +{ + mnNavigationPosition = nNewPosition; +} + + +// To make clearer that this method may trigger RecalcBoundRect and thus may be +// expensive and sometimes problematic (inside a bigger object change you will get +// non-useful BoundRects sometimes) I rename that method from GetBoundRect() to +// GetCurrentBoundRect(). +const tools::Rectangle& SdrObject::GetCurrentBoundRect() const +{ + auto const& rRectangle = getOutRectangle(); + if (rRectangle.IsEmpty()) + { + const_cast< SdrObject* >(this)->RecalcBoundRect(); + } + + return rRectangle; +} + +// To have a possibility to get the last calculated BoundRect e.g for producing +// the first rectangle for repaints (old and new need to be used) without forcing +// a RecalcBoundRect (which may be problematical and expensive sometimes) I add here +// a new method for accessing the last BoundRect. +const tools::Rectangle& SdrObject::GetLastBoundRect() const +{ + return getOutRectangle(); +} + +void SdrObject::RecalcBoundRect() +{ + // #i101680# suppress BoundRect calculations on import(s) + if ((getSdrModelFromSdrObject().isLocked()) || utl::ConfigManager::IsFuzzing()) + return; + + auto const& rRectangle = getOutRectangle(); + + // central new method which will calculate the BoundRect using primitive geometry + if (!rRectangle.IsEmpty()) + return; + + // Use view-independent data - we do not want any connections + // to e.g. GridOffset in SdrObject-level + drawinglayer::primitive2d::Primitive2DContainer xPrimitives; + GetViewContact().getViewIndependentPrimitive2DContainer(xPrimitives); + + if (xPrimitives.empty()) + return; + + // use neutral ViewInformation and get the range of the primitives + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + const basegfx::B2DRange aRange(xPrimitives.getB2DRange(aViewInformation2D)); + + if (!aRange.isEmpty()) + { + tools::Rectangle aNewRectangle( + tools::Long(floor(aRange.getMinX())), + tools::Long(floor(aRange.getMinY())), + tools::Long(ceil(aRange.getMaxX())), + tools::Long(ceil(aRange.getMaxY()))); + setOutRectangle(aNewRectangle); + return; + } +} + +void SdrObject::BroadcastObjectChange() const +{ + if ((getSdrModelFromSdrObject().isLocked()) || utl::ConfigManager::IsFuzzing()) + return; + + bool bPlusDataBroadcast(m_pPlusData && m_pPlusData->pBroadcast); + bool bObjectChange(IsInserted()); + + if(!(bPlusDataBroadcast || bObjectChange)) + return; + + SdrHint aHint(SdrHintKind::ObjectChange, *this); + + if(bPlusDataBroadcast) + { + m_pPlusData->pBroadcast->Broadcast(aHint); + } + + if(bObjectChange) + { + getSdrModelFromSdrObject().Broadcast(aHint); + } +} + +void SdrObject::SetChanged() +{ + // For testing purposes, use the new ViewContact for change + // notification now. + ActionChanged(); + + // TTTT Need to check meaning/usage of IsInserted in one + // of the next changes. It should not mean to have a SdrModel + // set (this is guaranteed now), but should be connected to + // being added to a SdrPage (?) + // TTTT tdf#120066 Indeed - This triggers e.g. by CustomShape + // geometry-presenting SdrObjects that are in a SdrObjGroup, + // but the SdrObjGroup is *by purpose* not inserted. + // Need to check deeper and maybe identify all ::IsInserted() + // calls by rename and let the compiler work... + if(nullptr != getSdrPageFromSdrObject()) + { + getSdrModelFromSdrObject().SetChanged(); + } +} + +// tooling for painting a single object to an OutputDevice. +void SdrObject::SingleObjectPainter(OutputDevice& rOut) const +{ + sdr::contact::SdrObjectVector aObjectVector; + aObjectVector.push_back(const_cast< SdrObject* >(this)); + + sdr::contact::ObjectContactOfObjListPainter aPainter(rOut, std::move(aObjectVector), getSdrPageFromSdrObject()); + sdr::contact::DisplayInfo aDisplayInfo; + + aPainter.ProcessDisplay(aDisplayInfo); +} + +bool SdrObject::LineGeometryUsageIsNecessary() const +{ + drawing::LineStyle eXLS = GetMergedItem(XATTR_LINESTYLE).GetValue(); + return (eXLS != drawing::LineStyle_NONE); +} + +bool SdrObject::HasLimitedRotation() const +{ + // RotGrfFlyFrame: Default is false, support full rotation + return false; +} + +OUString SdrObject::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulNONE)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + return sName; +} + +OUString SdrObject::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralNONE); +} + +OUString SdrObject::ImpGetDescriptionStr(TranslateId pStrCacheID) const +{ + OUString aStr = SvxResId(pStrCacheID); + sal_Int32 nPos = aStr.indexOf("%1"); + if (nPos >= 0) + { + // Replace '%1' with the object name. + OUString aObjName(TakeObjNameSingul()); + aStr = aStr.replaceAt(nPos, 2, aObjName); + } + + nPos = aStr.indexOf("%2"); + if (nPos >= 0) + // Replace '%2' with the passed value. + aStr = aStr.replaceAt(nPos, 2, u"0"); + return aStr; +} + +void SdrObject::ImpForcePlusData() +{ + if (!m_pPlusData) + m_pPlusData.reset( new SdrObjPlusData ); +} + +OUString SdrObject::GetMetrStr(tools::Long nVal) const +{ + return getSdrModelFromSdrObject().GetMetricString(nVal); +} + +basegfx::B2DPolyPolygon SdrObject::TakeXorPoly() const +{ + basegfx::B2DPolyPolygon aRetval; + const tools::Rectangle aR(GetCurrentBoundRect()); + aRetval.append(basegfx::utils::createPolygonFromRect(vcl::unotools::b2DRectangleFromRectangle(aR))); + + return aRetval; +} + +basegfx::B2DPolyPolygon SdrObject::TakeContour() const +{ + basegfx::B2DPolyPolygon aRetval; + + // create cloned object without text, but with drawing::LineStyle_SOLID, + // COL_BLACK as line color and drawing::FillStyle_NONE + rtl::Reference pClone(CloneSdrObject(getSdrModelFromSdrObject())); + + if(pClone) + { + const SdrTextObj* pTextObj = DynCastSdrTextObj(this); + + if(pTextObj) + { + // no text and no text animation + pClone->SetMergedItem(SdrTextAniKindItem(SdrTextAniKind::NONE)); + pClone->SetOutlinerParaObject(std::nullopt); + } + + const SdrEdgeObj* pEdgeObj = dynamic_cast< const SdrEdgeObj* >(this); + + if(pEdgeObj) + { + // create connections if connector, will be cleaned up when + // deleting the connector again + SdrObject* pLeft = pEdgeObj->GetConnectedNode(true); + SdrObject* pRight = pEdgeObj->GetConnectedNode(false); + + if(pLeft) + { + pClone->ConnectToNode(true, pLeft); + } + + if(pRight) + { + pClone->ConnectToNode(false, pRight); + } + } + + SfxItemSet aNewSet(GetObjectItemPool()); + + // #i101980# ignore LineWidth; that's what the old implementation + // did. With line width, the result may be huge due to fat/thick + // line decompositions + aNewSet.Put(XLineWidthItem(0)); + + // solid black lines and no fill + aNewSet.Put(XLineStyleItem(drawing::LineStyle_SOLID)); + aNewSet.Put(XLineColorItem(OUString(), COL_BLACK)); + aNewSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + pClone->SetMergedItemSet(aNewSet); + + // get sequence from clone + const sdr::contact::ViewContact& rVC(pClone->GetViewContact()); + drawinglayer::primitive2d::Primitive2DContainer xSequence; + rVC.getViewIndependentPrimitive2DContainer(xSequence); + + if(!xSequence.empty()) + { + // use neutral ViewInformation + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + + // create extractor, process and get result (with hairlines as opened polygons) + drawinglayer::processor2d::ContourExtractor2D aExtractor(aViewInformation2D, false); + aExtractor.process(xSequence); + const basegfx::B2DPolyPolygonVector& rResult(aExtractor.getExtractedContour()); + const sal_uInt32 nSize(rResult.size()); + + // when count is one, it is implied that the object has only its normal + // contour anyways and TakeContour() is to return an empty PolyPolygon + // (see old implementation for historical reasons) + if(nSize > 1) + { + // the topology for contour is correctly a vector of PolyPolygons; for + // historical reasons cut it back to a single tools::PolyPolygon here + for(sal_uInt32 a(0); a < nSize; a++) + { + aRetval.append(rResult[a]); + } + } + } + } + + return aRetval; +} + +sal_uInt32 SdrObject::GetHdlCount() const +{ + return 8; +} + +void SdrObject::AddToHdlList(SdrHdlList& rHdlList) const +{ + const tools::Rectangle& rR=GetSnapRect(); + for (sal_uInt32 nHdlNum=0; nHdlNum<8; ++nHdlNum) + { + std::unique_ptr pH; + switch (nHdlNum) { + case 0: pH.reset(new SdrHdl(rR.TopLeft(), SdrHdlKind::UpperLeft)); break; + case 1: pH.reset(new SdrHdl(rR.TopCenter(), SdrHdlKind::Upper)); break; + case 2: pH.reset(new SdrHdl(rR.TopRight(), SdrHdlKind::UpperRight)); break; + case 3: pH.reset(new SdrHdl(rR.LeftCenter(), SdrHdlKind::Left )); break; + case 4: pH.reset(new SdrHdl(rR.RightCenter(), SdrHdlKind::Right)); break; + case 5: pH.reset(new SdrHdl(rR.BottomLeft(), SdrHdlKind::LowerLeft)); break; + case 6: pH.reset(new SdrHdl(rR.BottomCenter(),SdrHdlKind::Lower)); break; + case 7: pH.reset(new SdrHdl(rR.BottomRight(), SdrHdlKind::LowerRight)); break; + } + rHdlList.AddHdl(std::move(pH)); + } +} + +void SdrObject::AddToPlusHdlList(SdrHdlList&, SdrHdl&) const +{ +} + +void SdrObject::addCropHandles(SdrHdlList& /*rTarget*/) const +{ + // Default implementation, does nothing. Overloaded in + // SdrGrafObj and SwVirtFlyDrawObj +} + +tools::Rectangle SdrObject::ImpDragCalcRect(const SdrDragStat& rDrag) const +{ + tools::Rectangle aTmpRect(GetSnapRect()); + tools::Rectangle aRect(aTmpRect); + const SdrHdl* pHdl=rDrag.GetHdl(); + SdrHdlKind eHdl=pHdl==nullptr ? SdrHdlKind::Move : pHdl->GetKind(); + bool bEcke=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::LowerLeft || eHdl==SdrHdlKind::LowerRight); + bool bOrtho=rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho(); + bool bBigOrtho=bEcke && bOrtho && rDrag.GetView()->IsBigOrtho(); + Point aPos(rDrag.GetNow()); + bool bLft=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::Left || eHdl==SdrHdlKind::LowerLeft); + bool bRgt=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Right || eHdl==SdrHdlKind::LowerRight); + bool bTop=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Upper || eHdl==SdrHdlKind::UpperLeft); + bool bBtm=(eHdl==SdrHdlKind::LowerRight || eHdl==SdrHdlKind::Lower || eHdl==SdrHdlKind::LowerLeft); + if (bLft) aTmpRect.SetLeft(aPos.X() ); + if (bRgt) aTmpRect.SetRight(aPos.X() ); + if (bTop) aTmpRect.SetTop(aPos.Y() ); + if (bBtm) aTmpRect.SetBottom(aPos.Y() ); + if (bOrtho) { // Ortho + tools::Long nWdt0=aRect.Right() -aRect.Left(); + tools::Long nHgt0=aRect.Bottom()-aRect.Top(); + tools::Long nXMul=aTmpRect.Right() -aTmpRect.Left(); + tools::Long nYMul=aTmpRect.Bottom()-aTmpRect.Top(); + tools::Long nXDiv=nWdt0; + tools::Long nYDiv=nHgt0; + bool bXNeg=(nXMul<0)!=(nXDiv<0); + bool bYNeg=(nYMul<0)!=(nYDiv<0); + nXMul=std::abs(nXMul); + nYMul=std::abs(nYMul); + nXDiv=std::abs(nXDiv); + nYDiv=std::abs(nYDiv); + Fraction aXFact(nXMul,nXDiv); // fractions for canceling + Fraction aYFact(nYMul,nYDiv); // and for comparing + nXMul=aXFact.GetNumerator(); + nYMul=aYFact.GetNumerator(); + nXDiv=aXFact.GetDenominator(); + nYDiv=aYFact.GetDenominator(); + if (bEcke) { // corner point handles + bool bUseX=(aXFact SdrObject::getFullDragClone() const +{ + // default uses simple clone + return CloneSdrObject(getSdrModelFromSdrObject()); +} + +bool SdrObject::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + + SdrHdlKind eHdl = (pHdl == nullptr) ? SdrHdlKind::Move : pHdl->GetKind(); + + return eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::Upper || eHdl==SdrHdlKind::UpperRight || + eHdl==SdrHdlKind::Left || eHdl==SdrHdlKind::Right || eHdl==SdrHdlKind::LowerLeft || + eHdl==SdrHdlKind::Lower || eHdl==SdrHdlKind::LowerRight; +} + +bool SdrObject::applySpecialDrag(SdrDragStat& rDrag) +{ + tools::Rectangle aNewRect(ImpDragCalcRect(rDrag)); + + if(aNewRect != GetSnapRect()) + { + NbcSetSnapRect(aNewRect); + } + + return true; +} + +OUString SdrObject::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const +{ + return OUString(); +} + +basegfx::B2DPolyPolygon SdrObject::getSpecialDragPoly(const SdrDragStat& /*rDrag*/) const +{ + // default has nothing to add + return basegfx::B2DPolyPolygon(); +} + + +// Create +bool SdrObject::BegCreate(SdrDragStat& rStat) +{ + rStat.SetOrtho4Possible(); + tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow()); + aRect1.Normalize(); + rStat.SetActionRect(aRect1); + setOutRectangle(aRect1); + return true; +} + +bool SdrObject::MovCreate(SdrDragStat& rStat) +{ + tools::Rectangle aRectangle; + rStat.TakeCreateRect(aRectangle); + rStat.SetActionRect(aRectangle); + aRectangle.Normalize(); + setOutRectangle(aRectangle); + return true; +} + +bool SdrObject::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + tools::Rectangle aRectangle; + rStat.TakeCreateRect(aRectangle); + aRectangle.Normalize(); + setOutRectangle(aRectangle); + + return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2); +} + +void SdrObject::BrkCreate(SdrDragStat& /*rStat*/) +{ +} + +bool SdrObject::BckCreate(SdrDragStat& /*rStat*/) +{ + return false; +} + +basegfx::B2DPolyPolygon SdrObject::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + tools::Rectangle aRect1; + rDrag.TakeCreateRect(aRect1); + aRect1.Normalize(); + + basegfx::B2DPolyPolygon aRetval; + aRetval.append(basegfx::utils::createPolygonFromRect(vcl::unotools::b2DRectangleFromRectangle(aRect1))); + return aRetval; +} + +PointerStyle SdrObject::GetCreatePointer() const +{ + return PointerStyle::Cross; +} + +// transformations +void SdrObject::NbcMove(const Size& rSize) +{ + moveOutRectangle(rSize.Width(), rSize.Height()); + SetBoundAndSnapRectsDirty(); +} + +void SdrObject::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0); + bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0); + if (bXMirr || bYMirr) { + Point aRef1(GetSnapRect().Center()); + if (bXMirr) { + Point aRef2(aRef1); + aRef2.AdjustY( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + if (bYMirr) { + Point aRef2(aRef1); + aRef2.AdjustX( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + } + auto aRectangle = getOutRectangle(); + ResizeRect(aRectangle, rRef, xFact, yFact); + setOutRectangle(aRectangle); + + SetBoundAndSnapRectsDirty(); +} + +void SdrObject::NbcRotate(const Point& rRef, Degree100 nAngle) +{ + if (nAngle) + { + double a = toRadians(nAngle); + NbcRotate( rRef, nAngle, sin( a ), cos( a ) ); + } +} + +namespace +{ +tools::Rectangle lclMirrorRectangle(tools::Rectangle const& rRectangle, Point const& rRef1, Point const& rRef2) +{ + tools::Rectangle aRectangle(rRectangle); + aRectangle.Move(-rRef1.X(),-rRef1.Y()); + tools::Rectangle R(aRectangle); + tools::Long dx=rRef2.X()-rRef1.X(); + tools::Long dy=rRef2.Y()-rRef1.Y(); + if (dx==0) { // vertical axis + aRectangle.SetLeft(-R.Right() ); + aRectangle.SetRight(-R.Left() ); + } else if (dy==0) { // horizontal axis + aRectangle.SetTop(-R.Bottom() ); + aRectangle.SetBottom(-R.Top() ); + } else if (dx==dy) { // 45deg axis + aRectangle.SetLeft(R.Top() ); + aRectangle.SetRight(R.Bottom() ); + aRectangle.SetTop(R.Left() ); + aRectangle.SetBottom(R.Right() ); + } else if (dx==-dy) { // 45deg axis + aRectangle.SetLeft(-R.Bottom() ); + aRectangle.SetRight(-R.Top() ); + aRectangle.SetTop(-R.Right() ); + aRectangle.SetBottom(-R.Left() ); + } + aRectangle.Move(rRef1.X(),rRef1.Y()); + aRectangle.Normalize(); // just in case + return aRectangle; +} + +} // end anonymous namespace + +void SdrObject::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + SetGlueReallyAbsolute(true); + + tools::Rectangle aRectangle = getOutRectangle(); + aRectangle = lclMirrorRectangle(aRectangle, rRef1, rRef2); + setOutRectangle(aRectangle); + + SetBoundAndSnapRectsDirty(); + NbcMirrorGluePoints(rRef1,rRef2); + SetGlueReallyAbsolute(false); +} + +void SdrObject::NbcShear(const Point& rRef, Degree100 /*nAngle*/, double tn, bool bVShear) +{ + SetGlueReallyAbsolute(true); + NbcShearGluePoints(rRef,tn,bVShear); + SetGlueReallyAbsolute(false); +} + +void SdrObject::Move(const Size& rSiz) +{ + if (rSiz.Width()!=0 || rSiz.Height()!=0) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcMove(rSiz); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} + +void SdrObject::NbcCrop(const basegfx::B2DPoint& /*aRef*/, double /*fxFact*/, double /*fyFact*/) +{ + // Default: does nothing. Real behaviour in SwVirtFlyDrawObj and SdrDragCrop::EndSdrDrag. + // Where SwVirtFlyDrawObj is the only real user of it to do something local +} + +void SdrObject::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative) +{ + if (xFact.GetNumerator() == xFact.GetDenominator() && yFact.GetNumerator() == yFact.GetDenominator()) + return; + + if (bUnsetRelative) + { + mpImpl->mnRelativeWidth.reset(); + mpImpl->meRelativeWidthRelation = text::RelOrientation::PAGE_FRAME; + mpImpl->meRelativeHeightRelation = text::RelOrientation::PAGE_FRAME; + mpImpl->mnRelativeHeight.reset(); + } + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcResize(rRef,xFact,yFact); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::Crop(const basegfx::B2DPoint& rRef, double fxFact, double fyFact) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcCrop(rRef, fxFact, fyFact); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + if (nAngle) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcRotate(rRef,nAngle,sn,cs); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrObject::Mirror(const Point& rRef1, const Point& rRef2) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcMirror(rRef1,rRef2); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::Shear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + if (nAngle) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcShear(rRef,nAngle,tn,bVShear); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrObject::NbcSetRelativePos(const Point& rPnt) +{ + Point aRelPos0(GetSnapRect().TopLeft()-m_aAnchor); + Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y()); + NbcMove(aSiz); // This also calls SetRectsDirty() +} + +void SdrObject::SetRelativePos(const Point& rPnt) +{ + if (rPnt!=GetRelativePos()) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetRelativePos(rPnt); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} + +Point SdrObject::GetRelativePos() const +{ + return GetSnapRect().TopLeft()-m_aAnchor; +} + +void SdrObject::ImpSetAnchorPos(const Point& rPnt) +{ + m_aAnchor = rPnt; +} + +void SdrObject::NbcSetAnchorPos(const Point& rPnt) +{ + Size aSiz(rPnt.X()-m_aAnchor.X(),rPnt.Y()-m_aAnchor.Y()); + m_aAnchor=rPnt; + NbcMove(aSiz); // This also calls SetRectsDirty() +} + +void SdrObject::SetAnchorPos(const Point& rPnt) +{ + if (rPnt!=m_aAnchor) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetAnchorPos(rPnt); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} + +const Point& SdrObject::GetAnchorPos() const +{ + return m_aAnchor; +} + +void SdrObject::RecalcSnapRect() +{ +} + +const tools::Rectangle& SdrObject::GetSnapRect() const +{ + return getOutRectangle(); +} + +void SdrObject::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + setOutRectangle(rRect); +} + +const tools::Rectangle& SdrObject::GetLogicRect() const +{ + return GetSnapRect(); +} + +void SdrObject::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + NbcSetSnapRect(rRect); +} + +void SdrObject::AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool /* bShrinkOnly = false */ ) +{ + SetLogicRect( rMaxRect ); +} + +void SdrObject::SetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetSnapRect(rRect); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::SetLogicRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetLogicRect(rRect); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +Degree100 SdrObject::GetRotateAngle() const +{ + return 0_deg100; +} + +Degree100 SdrObject::GetShearAngle(bool /*bVertical*/) const +{ + return 0_deg100; +} + +sal_uInt32 SdrObject::GetSnapPointCount() const +{ + return GetPointCount(); +} + +Point SdrObject::GetSnapPoint(sal_uInt32 i) const +{ + return GetPoint(i); +} + +bool SdrObject::IsPolyObj() const +{ + return false; +} + +sal_uInt32 SdrObject::GetPointCount() const +{ + return 0; +} + +Point SdrObject::GetPoint(sal_uInt32 /*i*/) const +{ + return Point(); +} + +void SdrObject::SetPoint(const Point& rPnt, sal_uInt32 i) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetPoint(rPnt, i); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::NbcSetPoint(const Point& /*rPnt*/, sal_uInt32 /*i*/) +{ +} + +bool SdrObject::HasTextEdit() const +{ + return false; +} + +bool SdrObject::Equals(const SdrObject& rOtherObj) const +{ + return (m_aAnchor.X() == rOtherObj.m_aAnchor.X() && m_aAnchor.Y() == rOtherObj.m_aAnchor.Y() && + m_nOrdNum == rOtherObj.m_nOrdNum && mnNavigationPosition == rOtherObj.mnNavigationPosition && + mbSupportTextIndentingOnLineWidthChange == rOtherObj.mbSupportTextIndentingOnLineWidthChange && + mbLineIsOutsideGeometry == rOtherObj.mbLineIsOutsideGeometry && m_bMarkProt == rOtherObj.m_bMarkProt && + m_bIs3DObj == rOtherObj.m_bIs3DObj && m_bIsEdge == rOtherObj.m_bIsEdge && m_bClosedObj == rOtherObj.m_bClosedObj && + m_bNotVisibleAsMaster == rOtherObj.m_bNotVisibleAsMaster && m_bEmptyPresObj == rOtherObj.m_bEmptyPresObj && + mbVisible == rOtherObj.mbVisible && m_bNoPrint == rOtherObj.m_bNoPrint && m_bSizProt == rOtherObj.m_bSizProt && + m_bMovProt == rOtherObj.m_bMovProt && m_bVirtObj == rOtherObj.m_bVirtObj && + mnLayerID == rOtherObj.mnLayerID && GetMergedItemSet().Equals(rOtherObj.GetMergedItemSet(), false) ); +} + +void SdrObject::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObject")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name())); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("name"), "%s", BAD_CAST(GetName().toUtf8().getStr())); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("title"), "%s", BAD_CAST(GetTitle().toUtf8().getStr())); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("description"), "%s", BAD_CAST(GetDescription().toUtf8().getStr())); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("nOrdNum"), "%" SAL_PRIuUINT32, GetOrdNumDirect()); + (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aOutRect"), BAD_CAST(getOutRectangle().toString().getStr())); + + if (m_pGrabBagItem) + { + m_pGrabBagItem->dumpAsXml(pWriter); + } + + if (mpProperties) + { + mpProperties->dumpAsXml(pWriter); + } + + if (const OutlinerParaObject* pOutliner = GetOutlinerParaObject()) + pOutliner->dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +void SdrObject::SetOutlinerParaObject(std::optional pTextObject) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetOutlinerParaObject(std::move(pTextObject)); + SetChanged(); + BroadcastObjectChange(); + if (GetCurrentBoundRect()!=aBoundRect0) { + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } + + if (!getSdrModelFromSdrObject().IsUndoEnabled()) + return; + + // Don't do this during import. + SdrObject* pTopGroupObj = nullptr; + if (getParentSdrObjectFromSdrObject()) + { + pTopGroupObj = getParentSdrObjectFromSdrObject(); + while (pTopGroupObj->getParentSdrObjectFromSdrObject()) + { + pTopGroupObj = pTopGroupObj->getParentSdrObjectFromSdrObject(); + } + } + if (pTopGroupObj) + { + // A shape was modified, which is in a group shape. Empty the group shape's grab-bag, + // which potentially contains the old text of the shapes in case of diagrams. + pTopGroupObj->SetGrabBagItem(uno::Any(uno::Sequence())); + } +} + +void SdrObject::NbcSetOutlinerParaObject(std::optional /*pTextObject*/) +{ +} + +OutlinerParaObject* SdrObject::GetOutlinerParaObject() const +{ + return nullptr; +} + +void SdrObject::NbcReformatText() +{ +} + +void SdrObject::BurnInStyleSheetAttributes() +{ + GetProperties().ForceStyleToHardAttributes(); +} + +bool SdrObject::HasMacro() const +{ + return false; +} + +SdrObject* SdrObject::CheckMacroHit(const SdrObjMacroHitRec& rRec) const +{ + if(rRec.pPageView) + { + return SdrObjectPrimitiveHit(*this, rRec.aPos, {static_cast(rRec.nTol), static_cast(rRec.nTol)}, *rRec.pPageView, rRec.pVisiLayer, false); + } + + return nullptr; +} + +PointerStyle SdrObject::GetMacroPointer(const SdrObjMacroHitRec&) const +{ + return PointerStyle::RefHand; +} + +void SdrObject::PaintMacro(OutputDevice& rOut, const tools::Rectangle& , const SdrObjMacroHitRec& ) const +{ + const RasterOp eRop(rOut.GetRasterOp()); + const basegfx::B2DPolyPolygon aPolyPolygon(TakeXorPoly()); + + rOut.SetLineColor(COL_BLACK); + rOut.SetFillColor(); + rOut.SetRasterOp(RasterOp::Invert); + + for(auto const& rPolygon : aPolyPolygon) + { + rOut.DrawPolyLine(rPolygon); + } + + rOut.SetRasterOp(eRop); +} + +bool SdrObject::DoMacro(const SdrObjMacroHitRec&) +{ + return false; +} + +bool SdrObject::IsMacroHit(const SdrObjMacroHitRec& rRec) const +{ + return CheckMacroHit(rRec) != nullptr; +} + + +std::unique_ptr SdrObject::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrObject::SaveGeoData(SdrObjGeoData& rGeo) const +{ + rGeo.aBoundRect =GetCurrentBoundRect(); + rGeo.aAnchor =m_aAnchor ; + rGeo.bMovProt =m_bMovProt ; + rGeo.bSizProt =m_bSizProt ; + rGeo.bNoPrint =m_bNoPrint ; + rGeo.mbVisible =mbVisible ; + rGeo.bClosedObj =m_bClosedObj ; + rGeo.mnLayerID = mnLayerID; + + // user-defined gluepoints + if (m_pPlusData!=nullptr && m_pPlusData->pGluePoints!=nullptr) { + if (rGeo.pGPL!=nullptr) { + *rGeo.pGPL=*m_pPlusData->pGluePoints; + } else { + rGeo.pGPL.reset( new SdrGluePointList(*m_pPlusData->pGluePoints) ); + } + } else { + rGeo.pGPL.reset(); + } +} + +void SdrObject::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SetBoundAndSnapRectsDirty(); + setOutRectangle(rGeo.aBoundRect); + m_aAnchor =rGeo.aAnchor ; + m_bMovProt =rGeo.bMovProt ; + m_bSizProt =rGeo.bSizProt ; + m_bNoPrint =rGeo.bNoPrint ; + mbVisible =rGeo.mbVisible ; + m_bClosedObj =rGeo.bClosedObj ; + mnLayerID = rGeo.mnLayerID; + + // user-defined gluepoints + if (rGeo.pGPL!=nullptr) { + ImpForcePlusData(); + if (m_pPlusData->pGluePoints!=nullptr) { + *m_pPlusData->pGluePoints=*rGeo.pGPL; + } else { + m_pPlusData->pGluePoints.reset(new SdrGluePointList(*rGeo.pGPL)); + } + } else { + if (m_pPlusData!=nullptr && m_pPlusData->pGluePoints!=nullptr) { + m_pPlusData->pGluePoints.reset(); + } + } +} + +std::unique_ptr SdrObject::GetGeoData() const +{ + std::unique_ptr pGeo = NewGeoData(); + SaveGeoData(*pGeo); + return pGeo; +} + +void SdrObject::SetGeoData(const SdrObjGeoData& rGeo) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + RestoreGeoData(rGeo); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +// ItemSet access + +const SfxItemSet& SdrObject::GetObjectItemSet() const +{ + return GetProperties().GetObjectItemSet(); +} + +const SfxItemSet& SdrObject::GetMergedItemSet() const +{ + return GetProperties().GetMergedItemSet(); +} + +void SdrObject::SetObjectItem(const SfxPoolItem& rItem) +{ + GetProperties().SetObjectItem(rItem); +} + +void SdrObject::SetMergedItem(const SfxPoolItem& rItem) +{ + GetProperties().SetMergedItem(rItem); +} + +void SdrObject::ClearMergedItem(const sal_uInt16 nWhich) +{ + GetProperties().ClearMergedItem(nWhich); +} + +void SdrObject::SetObjectItemSet(const SfxItemSet& rSet) +{ + GetProperties().SetObjectItemSet(rSet); +} + +void SdrObject::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems) +{ + GetProperties().SetMergedItemSet(rSet, bClearAllItems); +} + +const SfxPoolItem& SdrObject::GetObjectItem(const sal_uInt16 nWhich) const +{ + return GetObjectItemSet().Get(nWhich); +} + +const SfxPoolItem& SdrObject::GetMergedItem(const sal_uInt16 nWhich) const +{ + return GetMergedItemSet().Get(nWhich); +} + +void SdrObject::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, bool bClearAllItems) +{ + GetProperties().SetMergedItemSetAndBroadcast(rSet, bClearAllItems); +} + +void SdrObject::ApplyNotPersistAttr(const SfxItemSet& rAttr) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcApplyNotPersistAttr(rAttr); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrObject::NbcApplyNotPersistAttr(const SfxItemSet& rAttr) +{ + const tools::Rectangle& rSnap=GetSnapRect(); + const tools::Rectangle& rLogic=GetLogicRect(); + Point aRef1(rSnap.Center()); + + if (const SdrTransformRef1XItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF1X)) + { + aRef1.setX(pPoolItem->GetValue() ); + } + if (const SdrTransformRef1YItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_TRANSFORMREF1Y)) + { + aRef1.setY(pPoolItem->GetValue() ); + } + + tools::Rectangle aNewSnap(rSnap); + if (const SdrMoveXItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_MOVEX)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.Move(n,0); + } + if (const SdrMoveYItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_MOVEY)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.Move(0,n); + } + if (const SdrOnePositionXItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ONEPOSITIONX)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.Move(n-aNewSnap.Left(),0); + } + if (const SdrOnePositionYItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ONEPOSITIONY)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.Move(0,n-aNewSnap.Top()); + } + if (const SdrOneSizeWidthItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ONESIZEWIDTH)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.SetRight(aNewSnap.Left()+n ); + } + if (const SdrOneSizeHeightItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ONESIZEHEIGHT)) + { + tools::Long n = pPoolItem->GetValue(); + aNewSnap.SetBottom(aNewSnap.Top()+n ); + } + if (aNewSnap!=rSnap) { + if (aNewSnap.GetSize()==rSnap.GetSize()) { + NbcMove(Size(aNewSnap.Left()-rSnap.Left(),aNewSnap.Top()-rSnap.Top())); + } else { + NbcSetSnapRect(aNewSnap); + } + } + + if (const SdrShearAngleItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_SHEARANGLE)) + { + Degree100 n = pPoolItem->GetValue(); + n-=GetShearAngle(); + if (n) { + double nTan = tan(toRadians(n)); + NbcShear(aRef1,n,nTan,false); + } + } + if (const SdrAngleItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ROTATEANGLE)) + { + Degree100 n = pPoolItem->GetValue(); + n-=GetRotateAngle(); + if (n) { + NbcRotate(aRef1,n); + } + } + if (const SdrRotateOneItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_ROTATEONE)) + { + Degree100 n = pPoolItem->GetValue(); + NbcRotate(aRef1,n); + } + if (const SdrHorzShearOneItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_HORZSHEARONE)) + { + Degree100 n = pPoolItem->GetValue(); + double nTan = tan(toRadians(n)); + NbcShear(aRef1,n,nTan,false); + } + if (const SdrVertShearOneItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_VERTSHEARONE)) + { + Degree100 n = pPoolItem->GetValue(); + double nTan = tan(toRadians(n)); + NbcShear(aRef1,n,nTan,true); + } + + if (const SdrYesNoItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_OBJMOVEPROTECT)) + { + bool b = pPoolItem->GetValue(); + SetMoveProtect(b); + } + if (const SdrYesNoItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_OBJSIZEPROTECT)) + { + bool b = pPoolItem->GetValue(); + SetResizeProtect(b); + } + + /* move protect always sets size protect */ + if( IsMoveProtect() ) + SetResizeProtect( true ); + + if (const SdrObjPrintableItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_OBJPRINTABLE)) + { + bool b = pPoolItem->GetValue(); + SetPrintable(b); + } + + if (const SdrObjVisibleItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_OBJVISIBLE)) + { + bool b = pPoolItem->GetValue(); + SetVisible(b); + } + + SdrLayerID nLayer=SDRLAYER_NOTFOUND; + if (const SdrLayerIdItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERID)) + { + nLayer = pPoolItem->GetValue(); + } + if (const SdrLayerNameItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERNAME)) + { + OUString aLayerName = pPoolItem->GetValue(); + const SdrLayerAdmin& rLayAd(nullptr != getSdrPageFromSdrObject() + ? getSdrPageFromSdrObject()->GetLayerAdmin() + : getSdrModelFromSdrObject().GetLayerAdmin()); + const SdrLayer* pLayer = rLayAd.GetLayer(aLayerName); + + if(nullptr != pLayer) + { + nLayer=pLayer->GetID(); + } + } + if (nLayer!=SDRLAYER_NOTFOUND) { + NbcSetLayer(nLayer); + } + + if (const SfxStringItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_OBJECTNAME)) + { + OUString aName = pPoolItem->GetValue(); + SetName(aName); + } + tools::Rectangle aNewLogic(rLogic); + if (const SdrLogicSizeWidthItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LOGICSIZEWIDTH)) + { + tools::Long n = pPoolItem->GetValue(); + aNewLogic.SetRight(aNewLogic.Left()+n ); + } + if (const SdrLogicSizeHeightItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LOGICSIZEHEIGHT)) + { + tools::Long n = pPoolItem->GetValue(); + aNewLogic.SetBottom(aNewLogic.Top()+n ); + } + if (aNewLogic!=rLogic) { + NbcSetLogicRect(aNewLogic); + } + Fraction aResizeX(1,1); + Fraction aResizeY(1,1); + if (const SdrResizeXOneItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_RESIZEXONE)) + { + aResizeX *= pPoolItem->GetValue(); + } + if (const SdrResizeYOneItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_RESIZEYONE)) + { + aResizeY *= pPoolItem->GetValue(); + } + if (aResizeX!=Fraction(1,1) || aResizeY!=Fraction(1,1)) { + NbcResize(aRef1,aResizeX,aResizeY); + } +} + +void SdrObject::TakeNotPersistAttr(SfxItemSet& rAttr) const +{ + const tools::Rectangle& rSnap=GetSnapRect(); + const tools::Rectangle& rLogic=GetLogicRect(); + rAttr.Put(SdrYesNoItem(SDRATTR_OBJMOVEPROTECT, IsMoveProtect())); + rAttr.Put(SdrYesNoItem(SDRATTR_OBJSIZEPROTECT, IsResizeProtect())); + rAttr.Put(SdrObjPrintableItem(IsPrintable())); + rAttr.Put(SdrObjVisibleItem(IsVisible())); + rAttr.Put(SdrAngleItem(SDRATTR_ROTATEANGLE, GetRotateAngle())); + rAttr.Put(SdrShearAngleItem(GetShearAngle())); + rAttr.Put(SdrOneSizeWidthItem(rSnap.GetWidth()-1)); + rAttr.Put(SdrOneSizeHeightItem(rSnap.GetHeight()-1)); + rAttr.Put(SdrOnePositionXItem(rSnap.Left())); + rAttr.Put(SdrOnePositionYItem(rSnap.Top())); + if (rLogic.GetWidth()!=rSnap.GetWidth()) { + rAttr.Put(SdrLogicSizeWidthItem(rLogic.GetWidth()-1)); + } + if (rLogic.GetHeight()!=rSnap.GetHeight()) { + rAttr.Put(SdrLogicSizeHeightItem(rLogic.GetHeight()-1)); + } + OUString aName(GetName()); + + if (!aName.isEmpty()) + { + rAttr.Put(SfxStringItem(SDRATTR_OBJECTNAME, aName)); + } + + rAttr.Put(SdrLayerIdItem(GetLayer())); + const SdrLayerAdmin& rLayAd(nullptr != getSdrPageFromSdrObject() + ? getSdrPageFromSdrObject()->GetLayerAdmin() + : getSdrModelFromSdrObject().GetLayerAdmin()); + const SdrLayer* pLayer = rLayAd.GetLayerPerID(GetLayer()); + if(nullptr != pLayer) + { + rAttr.Put(SdrLayerNameItem(pLayer->GetName())); + } + Point aRef1(rSnap.Center()); + Point aRef2(aRef1); aRef2.AdjustY( 1 ); + rAttr.Put(SdrTransformRef1XItem(aRef1.X())); + rAttr.Put(SdrTransformRef1YItem(aRef1.Y())); + rAttr.Put(SdrTransformRef2XItem(aRef2.X())); + rAttr.Put(SdrTransformRef2YItem(aRef2.Y())); +} + +SfxStyleSheet* SdrObject::GetStyleSheet() const +{ + return GetProperties().GetStyleSheet(); +} + +void SdrObject::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) +{ + tools::Rectangle aBoundRect0; + + if(m_pUserCall) + aBoundRect0 = GetLastBoundRect(); + + InternalSetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr, true); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::ChangeAttr, aBoundRect0); +} + +void SdrObject::NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) +{ + InternalSetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr, false); +} + +void SdrObject::InternalSetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr, bool bBroadcast) +{ + GetProperties().SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr, bBroadcast); +} + +// Broadcasting while setting attributes is managed by the AttrObj. + + +SdrGluePoint SdrObject::GetVertexGluePoint(sal_uInt16 nPosNum) const +{ + // #i41936# Use SnapRect for default GluePoints + const tools::Rectangle aR(GetSnapRect()); + Point aPt; + + switch(nPosNum) + { + case 0 : aPt = aR.TopCenter(); break; + case 1 : aPt = aR.RightCenter(); break; + case 2 : aPt = aR.BottomCenter(); break; + case 3 : aPt = aR.LeftCenter(); break; + } + + aPt -= aR.Center(); + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + + return aGP; +} + +SdrGluePoint SdrObject::GetCornerGluePoint(sal_uInt16 nPosNum) const +{ + tools::Rectangle aR(GetCurrentBoundRect()); + Point aPt; + switch (nPosNum) { + case 0 : aPt=aR.TopLeft(); break; + case 1 : aPt=aR.TopRight(); break; + case 2 : aPt=aR.BottomRight(); break; + case 3 : aPt=aR.BottomLeft(); break; + } + aPt-=GetSnapRect().Center(); + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + return aGP; +} + +const SdrGluePointList* SdrObject::GetGluePointList() const +{ + if (m_pPlusData!=nullptr) return m_pPlusData->pGluePoints.get(); + return nullptr; +} + + +SdrGluePointList* SdrObject::ForceGluePointList() +{ + ImpForcePlusData(); + if (m_pPlusData->pGluePoints==nullptr) { + m_pPlusData->pGluePoints.reset(new SdrGluePointList); + } + return m_pPlusData->pGluePoints.get(); +} + +void SdrObject::SetGlueReallyAbsolute(bool bOn) +{ + // First a const call to see whether there are any gluepoints. + // Force const call! + if (GetGluePointList()!=nullptr) { + SdrGluePointList* pGPL=ForceGluePointList(); + pGPL->SetReallyAbsolute(bOn,*this); + } +} + +void SdrObject::NbcRotateGluePoints(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + // First a const call to see whether there are any gluepoints. + // Force const call! + if (GetGluePointList()!=nullptr) { + SdrGluePointList* pGPL=ForceGluePointList(); + pGPL->Rotate(rRef,nAngle,sn,cs,this); + } +} + +void SdrObject::NbcMirrorGluePoints(const Point& rRef1, const Point& rRef2) +{ + // First a const call to see whether there are any gluepoints. + // Force const call! + if (GetGluePointList()!=nullptr) { + SdrGluePointList* pGPL=ForceGluePointList(); + pGPL->Mirror(rRef1,rRef2,this); + } +} + +void SdrObject::NbcShearGluePoints(const Point& rRef, double tn, bool bVShear) +{ + // First a const call to see whether there are any gluepoints. + // Force const call! + if (GetGluePointList()!=nullptr) { + SdrGluePointList* pGPL=ForceGluePointList(); + pGPL->Shear(rRef,tn,bVShear,this); + } +} + +void SdrObject::ConnectToNode(bool /*bTail1*/, SdrObject* /*pObj*/) +{ +} + +void SdrObject::DisconnectFromNode(bool /*bTail1*/) +{ +} + +SdrObject* SdrObject::GetConnectedNode(bool /*bTail1*/) const +{ + return nullptr; +} + + +static void extractLineContourFromPrimitive2DSequence( + const drawinglayer::primitive2d::Primitive2DContainer& rxSequence, + basegfx::B2DPolygonVector& rExtractedHairlines, + basegfx::B2DPolyPolygonVector& rExtractedLineFills) +{ + rExtractedHairlines.clear(); + rExtractedLineFills.clear(); + + if(rxSequence.empty()) + return; + + // use neutral ViewInformation + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + + // create extractor, process and get result + drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D); + aExtractor.process(rxSequence); + + // copy line results + rExtractedHairlines = aExtractor.getExtractedHairlines(); + + // copy fill rsults + rExtractedLineFills = aExtractor.getExtractedLineFills(); +} + + +rtl::Reference SdrObject::ImpConvertToContourObj(bool bForceLineDash) +{ + rtl::Reference pRetval; + + if(LineGeometryUsageIsNecessary()) + { + basegfx::B2DPolyPolygon aMergedLineFillPolyPolygon; + basegfx::B2DPolyPolygon aMergedHairlinePolyPolygon; + drawinglayer::primitive2d::Primitive2DContainer xSequence; + GetViewContact().getViewIndependentPrimitive2DContainer(xSequence); + + if(!xSequence.empty()) + { + basegfx::B2DPolygonVector aExtractedHairlines; + basegfx::B2DPolyPolygonVector aExtractedLineFills; + + extractLineContourFromPrimitive2DSequence(xSequence, aExtractedHairlines, aExtractedLineFills); + + // for SdrObject creation, just copy all to a single Hairline-PolyPolygon + for(const basegfx::B2DPolygon & rExtractedHairline : aExtractedHairlines) + { + aMergedHairlinePolyPolygon.append(rExtractedHairline); + } + + // check for fill rsults + if (!aExtractedLineFills.empty() && !utl::ConfigManager::IsFuzzing()) + { + // merge to a single tools::PolyPolygon (OR) + aMergedLineFillPolyPolygon = basegfx::utils::mergeToSinglePolyPolygon(std::move(aExtractedLineFills)); + } + } + + if(aMergedLineFillPolyPolygon.count() || (bForceLineDash && aMergedHairlinePolyPolygon.count())) + { + SfxItemSet aSet(GetMergedItemSet()); + drawing::FillStyle eOldFillStyle = aSet.Get(XATTR_FILLSTYLE).GetValue(); + rtl::Reference aLinePolygonPart; + rtl::Reference aLineHairlinePart; + bool bBuildGroup(false); + + if(aMergedLineFillPolyPolygon.count()) + { + // create SdrObject for filled line geometry + aLinePolygonPart = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathFill, + std::move(aMergedLineFillPolyPolygon)); + + // correct item properties + aSet.Put(XLineWidthItem(0)); + aSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + Color aColorLine = aSet.Get(XATTR_LINECOLOR).GetColorValue(); + sal_uInt16 nTransLine = aSet.Get(XATTR_LINETRANSPARENCE).GetValue(); + aSet.Put(XFillColorItem(OUString(), aColorLine)); + aSet.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + aSet.Put(XFillTransparenceItem(nTransLine)); + + aLinePolygonPart->SetMergedItemSet(aSet); + } + + if(aMergedHairlinePolyPolygon.count()) + { + // create SdrObject for hairline geometry + // OBJ_PATHLINE is necessary here, not OBJ_PATHFILL. This is intended + // to get a non-filled object. If the poly is closed, the PathObj takes care for + // the correct closed state. + aLineHairlinePart = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + std::move(aMergedHairlinePolyPolygon)); + + aSet.Put(XLineWidthItem(0)); + aSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + aSet.Put(XLineStyleItem(drawing::LineStyle_SOLID)); + + // it is also necessary to switch off line start and ends here + aSet.Put(XLineStartWidthItem(0)); + aSet.Put(XLineEndWidthItem(0)); + + aLineHairlinePart->SetMergedItemSet(aSet); + + if(aLinePolygonPart) + { + bBuildGroup = true; + } + } + + // check if original geometry should be added (e.g. filled and closed) + bool bAddOriginalGeometry(false); + SdrPathObj* pPath = dynamic_cast(this); + + if(pPath && pPath->IsClosed()) + { + if(eOldFillStyle != drawing::FillStyle_NONE) + { + bAddOriginalGeometry = true; + } + } + + // do we need a group? + if(bBuildGroup || bAddOriginalGeometry) + { + rtl::Reference pGroup = new SdrObjGroup(getSdrModelFromSdrObject()); + + if(bAddOriginalGeometry) + { + // Add a clone of the original geometry. + aSet.ClearItem(); + aSet.Put(GetMergedItemSet()); + aSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + aSet.Put(XLineWidthItem(0)); + + rtl::Reference pClone(CloneSdrObject(getSdrModelFromSdrObject())); + pClone->SetMergedItemSet(aSet); + + pGroup->GetSubList()->NbcInsertObject(pClone.get()); + } + + if(aLinePolygonPart) + { + pGroup->GetSubList()->NbcInsertObject(aLinePolygonPart.get()); + } + + if(aLineHairlinePart) + { + pGroup->GetSubList()->NbcInsertObject(aLineHairlinePart.get()); + } + + pRetval = pGroup; + } + else + { + if(aLinePolygonPart) + { + pRetval = aLinePolygonPart; + } + else if(aLineHairlinePart) + { + pRetval = aLineHairlinePart; + } + } + } + } + + if(!pRetval) + { + // due to current method usage, create and return a clone when nothing has changed + pRetval = CloneSdrObject(getSdrModelFromSdrObject()); + } + + return pRetval; +} + + +void SdrObject::SetMarkProtect(bool bProt) +{ + m_bMarkProt = bProt; +} + + +void SdrObject::SetEmptyPresObj(bool bEpt) +{ + m_bEmptyPresObj = bEpt; +} + + +void SdrObject::SetNotVisibleAsMaster(bool bFlg) +{ + m_bNotVisibleAsMaster=bFlg; +} + + +// convert this path object to contour object, even when it is a group +rtl::Reference SdrObject::ConvertToContourObj(SdrObject* pRet1, bool bForceLineDash) const +{ + rtl::Reference pRet = pRet1; + if(dynamic_cast( pRet.get()) != nullptr) + { + SdrObjList* pObjList2 = pRet->GetSubList(); + rtl::Reference pGroup = new SdrObjGroup(getSdrModelFromSdrObject()); + + for (const rtl::Reference& pIterObj : *pObjList2) + pGroup->GetSubList()->NbcInsertObject(ConvertToContourObj(pIterObj.get(), bForceLineDash).get()); + + pRet = pGroup; + } + else + { + if (SdrPathObj *pPathObj = dynamic_cast(pRet.get())) + { + // bezier geometry got created, even for straight edges since the given + // object is a result of DoConvertToPolyObj. For conversion to contour + // this is not really needed and can be reduced again AFAP + pPathObj->SetPathPoly(basegfx::utils::simplifyCurveSegments(pPathObj->GetPathPoly())); + } + + pRet = pRet->ImpConvertToContourObj(bForceLineDash); + } + + // #i73441# preserve LayerID + if(pRet && pRet->GetLayer() != GetLayer()) + { + pRet->SetLayer(GetLayer()); + } + + return pRet; +} + + +rtl::Reference SdrObject::ConvertToPolyObj(bool bBezier, bool bLineToArea) const +{ + rtl::Reference pRet = DoConvertToPolyObj(bBezier, true); + + if(pRet && bLineToArea) + { + pRet = ConvertToContourObj(pRet.get()); + } + + // #i73441# preserve LayerID + if(pRet && pRet->GetLayer() != GetLayer()) + { + pRet->SetLayer(GetLayer()); + } + + return pRet; +} + + +rtl::Reference SdrObject::DoConvertToPolyObj(bool /*bBezier*/, bool /*bAddText*/) const +{ + return nullptr; +} + + +void SdrObject::InsertedStateChange() +{ + const bool bIsInserted(nullptr != getParentSdrObjListFromSdrObject()); + const tools::Rectangle aBoundRect0(GetLastBoundRect()); + + if(bIsInserted) + { + SendUserCall(SdrUserCallType::Inserted, aBoundRect0); + } + else + { + SendUserCall(SdrUserCallType::Removed, aBoundRect0); + } + + if(nullptr != m_pPlusData && nullptr != m_pPlusData->pBroadcast) + { + SdrHint aHint(bIsInserted ? SdrHintKind::ObjectInserted : SdrHintKind::ObjectRemoved, *this); + m_pPlusData->pBroadcast->Broadcast(aHint); + } +} + +void SdrObject::SetMoveProtect(bool bProt) +{ + if(IsMoveProtect() != bProt) + { + // #i77187# secured and simplified + m_bMovProt = bProt; + SetChanged(); + BroadcastObjectChange(); + } +} + +void SdrObject::SetResizeProtect(bool bProt) +{ + if(IsResizeProtect() != bProt) + { + // #i77187# secured and simplified + m_bSizProt = bProt; + SetChanged(); + BroadcastObjectChange(); + } +} + +void SdrObject::SetPrintable(bool bPrn) +{ + if( bPrn == m_bNoPrint ) + { + m_bNoPrint=!bPrn; + SetChanged(); + if (IsInserted()) + { + SdrHint aHint(SdrHintKind::ObjectChange, *this); + getSdrModelFromSdrObject().Broadcast(aHint); + } + } +} + +void SdrObject::SetVisible(bool bVisible) +{ + if( bVisible != mbVisible ) + { + mbVisible = bVisible; + SetChanged(); + if (IsInserted()) + { + SdrHint aHint(SdrHintKind::ObjectChange, *this); + getSdrModelFromSdrObject().Broadcast(aHint); + } + } +} + + +sal_uInt16 SdrObject::GetUserDataCount() const +{ + if (m_pPlusData==nullptr || m_pPlusData->pUserDataList==nullptr) return 0; + return m_pPlusData->pUserDataList->GetUserDataCount(); +} + +SdrObjUserData* SdrObject::GetUserData(sal_uInt16 nNum) const +{ + if (m_pPlusData==nullptr || m_pPlusData->pUserDataList==nullptr) return nullptr; + return &m_pPlusData->pUserDataList->GetUserData(nNum); +} + +void SdrObject::AppendUserData(std::unique_ptr pData) +{ + if (!pData) + { + OSL_FAIL("SdrObject::AppendUserData(): pData is NULL pointer."); + return; + } + + ImpForcePlusData(); + if (!m_pPlusData->pUserDataList) + m_pPlusData->pUserDataList.reset( new SdrObjUserDataList ); + + m_pPlusData->pUserDataList->AppendUserData(std::move(pData)); +} + +void SdrObject::DeleteUserData(sal_uInt16 nNum) +{ + sal_uInt16 nCount=GetUserDataCount(); + if (nNumpUserDataList->DeleteUserData(nNum); + if (nCount==1) { + m_pPlusData->pUserDataList.reset(); + } + } else { + OSL_FAIL("SdrObject::DeleteUserData(): Invalid Index."); + } +} + +void SdrObject::SetUserCall(SdrObjUserCall* pUser) +{ + m_pUserCall = pUser; +} + + +void SdrObject::SendUserCall(SdrUserCallType eUserCall, const tools::Rectangle& rBoundRect) const +{ + SdrObject* pGroup(getParentSdrObjectFromSdrObject()); + + if ( m_pUserCall ) + { + m_pUserCall->Changed( *this, eUserCall, rBoundRect ); + } + + if(nullptr != pGroup && pGroup->GetUserCall()) + { + // broadcast to group + SdrUserCallType eChildUserType = SdrUserCallType::ChildChangeAttr; + + switch( eUserCall ) + { + case SdrUserCallType::MoveOnly: + eChildUserType = SdrUserCallType::ChildMoveOnly; + break; + + case SdrUserCallType::Resize: + eChildUserType = SdrUserCallType::ChildResize; + break; + + case SdrUserCallType::ChangeAttr: + eChildUserType = SdrUserCallType::ChildChangeAttr; + break; + + case SdrUserCallType::Delete: + eChildUserType = SdrUserCallType::ChildDelete; + break; + + case SdrUserCallType::Inserted: + eChildUserType = SdrUserCallType::ChildInserted; + break; + + case SdrUserCallType::Removed: + eChildUserType = SdrUserCallType::ChildRemoved; + break; + + default: break; + } + + pGroup->GetUserCall()->Changed( *this, eChildUserType, rBoundRect ); + } + + // notify our UNO shape listeners + switch ( eUserCall ) + { + case SdrUserCallType::Resize: + notifyShapePropertyChange( "Size" ); + [[fallthrough]]; // RESIZE might also imply a change of the position + case SdrUserCallType::MoveOnly: + notifyShapePropertyChange( "Position" ); + break; + default: + // not interested in + break; + } +} + +void SdrObject::setUnoShape( const uno::Reference< drawing::XShape >& _rxUnoShape ) +{ + const uno::Reference< uno::XInterface>& xOldUnoShape( maWeakUnoShape ); + // the UNO shape would be gutted by the following code; return early + if ( _rxUnoShape == xOldUnoShape ) + { + if ( !xOldUnoShape.is() ) + { + // make sure there is no stale impl. pointer if the UNO + // shape was destroyed meanwhile (remember we only hold weak + // reference to it!) + mpSvxShape = nullptr; + } + return; + } + + if ( xOldUnoShape.is() ) + { + // Remove yourself from the current UNO shape. Its destructor + // will reset our UNO shape otherwise. + mpSvxShape->InvalidateSdrObject(); + } + + maWeakUnoShape = _rxUnoShape; + mpSvxShape = comphelper::getFromUnoTunnel( _rxUnoShape ); +} + +/** only for internal use! */ +SvxShape* SdrObject::getSvxShape() +{ + DBG_TESTSOLARMUTEX(); + // retrieving the impl pointer and subsequently using it is not thread-safe, of course, so it needs to be + // guarded by the SolarMutex + + uno::Reference< uno::XInterface > xShape( maWeakUnoShape ); + //#113608#, make sure mpSvxShape is always synchronized with maWeakUnoShape + if ( mpSvxShape && !xShape ) + mpSvxShape = nullptr; + + return mpSvxShape; +} + +css::uno::Reference< css::drawing::XShape > SdrObject::getUnoShape() +{ + // try weak reference first + uno::Reference< css::drawing::XShape > xShape = maWeakUnoShape; + if (xShape) + return xShape; + + // try to access SdrPage from this SdrObject. This will only exist if the SdrObject is + // inserted in a SdrObjList (page/group/3dScene) + SdrPage* pPageCandidate(getSdrPageFromSdrObject()); + + // tdf#12152, tdf#120728 + // + // With the paradigm change to only get a SdrPage for a SdrObject when the SdrObject + // is *inserted*, the functionality for creating 1:1 associated UNO API implementation + // SvxShapes was partially broken: The used ::CreateShape relies on the SvxPage being + // derived and the CreateShape method overloaded, implementing additional SdrInventor + // types as needed. + // + // The fallback to use SvxDrawPage::CreateShapeByTypeAndInventor is a trap: It's only + // a static fallback that handles the SdrInventor types SdrInventor::E3d and + // SdrInventor::Default. Due to that, e.g. the ReportDesigner broke in various conditions. + // + // That again has to do with the ReportDesigner being implemented using the UNO API + // aspects of SdrObjects early during their construction, not just after these are + // inserted to a SdrPage - but that is not illegal or wrong, the SdrObject exists already. + // + // As a current solution, use the (now always available) SdrModel and any of the + // existing SdrPages. The only important thing is to get a SdrPage where ::CreateShape is + // overloaded and implemented as needed. + // + // Note for the future: + // In a more ideal world there would be only one factory method for creating SdrObjects (not + // ::CreateShape and ::CreateShapeByTypeAndInventor). This also would not be placed at + // SdrPage/SvxPage at all, but at the Model where it belongs - where else would you expect + // objects for the current Model to be constructed? To have this at the Page only would make + // sense if different shapes would need to be constructed for different Pages in the same Model + // - this is never the case. + // At that Model extended functionality for that factory (or overloads and implementations) + // should be placed. But to be realistic, migrating the factories to Model now is too much + // work - maybe over time when melting SdrObject/SvxObject one day... + // + // More Note (added by noel grandin) + // Except that sd/ is being naughty and doing all kinds of magic during CreateShape that + // requires knowing which page the object is being created for. Fixing that would require + // moving a bunch of nasty logic from object creation time, to the point in time when + // it is actually added to a page. + if(nullptr == pPageCandidate) + { + // If not inserted, alternatively access a SdrPage using the SdrModel. There is + // no reason not to create and return a UNO API XShape when the SdrObject is not + // inserted - it may be in construction. Main paradigm is that it exists. + if(0 != getSdrModelFromSdrObject().GetPageCount()) + { + // Take 1st SdrPage. That may be e.g. a special page (in SD), but the + // to-be-used method ::CreateShape will be correctly overloaded in + // all cases + pPageCandidate = getSdrModelFromSdrObject().GetPage(0); + } + } + + if(nullptr != pPageCandidate) + { + uno::Reference< uno::XInterface > xPage(pPageCandidate->getUnoPage()); + if( xPage.is() ) + { + SvxDrawPage* pDrawPage = comphelper::getFromUnoTunnel(xPage); + if( pDrawPage ) + { + // create one + xShape = pDrawPage->CreateShape( this ); + assert(xShape); + setUnoShape( xShape ); + } + } + } + else + { + // Fallback to static base functionality. CAUTION: This will only support + // the most basic stuff like SdrInventor::E3d and SdrInventor::Default. All + // the other SdrInventor enum entries are from overloads and are *not accessible* + // using this fallback (!) - what a bad trap + rtl::Reference xNewShape = SvxDrawPage::CreateShapeByTypeAndInventor( GetObjIdentifier(), GetObjInventor(), this ); + mpSvxShape = xNewShape.get(); + maWeakUnoShape = xShape = mpSvxShape; + } + + return xShape; +} + +void SdrObject::notifyShapePropertyChange( const OUString& rPropName ) const +{ + DBG_TESTSOLARMUTEX(); + + SvxShape* pSvxShape = const_cast< SdrObject* >( this )->getSvxShape(); + if ( pSvxShape ) + return pSvxShape->notifyPropertyChange( rPropName ); +} + +// transformation interface for StarOfficeAPI. This implements support for +// homogeneous 3x3 matrices containing the transformation of the SdrObject. At the +// moment it contains a shearX, rotation and translation, but for setting all linear +// transforms like Scale, ShearX, ShearY, Rotate and Translate are supported. + + +// gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon +// with the base geometry and returns TRUE. Otherwise it returns FALSE. +bool SdrObject::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const +{ + // any kind of SdrObject, just use SnapRect + tools::Rectangle aRectangle(GetSnapRect()); + + // convert to transformation values + basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight()); + basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top()); + + // position maybe relative to anchorpos, convert + if(getSdrModelFromSdrObject().IsWriter()) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build matrix + rMatrix = basegfx::utils::createScaleTranslateB2DHomMatrix(aScale, aTranslate); + + return false; +} + +// sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix. +// If it's an SdrPathObj it will use the provided geometry information. The Polygon has +// to use (0,0) as upper left and will be scaled to the given size in the matrix. +void SdrObject::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/) +{ + // break up matrix + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + rMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings + // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly + if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0)) + { + aScale.setX(fabs(aScale.getX())); + aScale.setY(fabs(aScale.getY())); + } + + // if anchor is used, make position relative to it + if(getSdrModelFromSdrObject().IsWriter()) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build BaseRect + Point aPoint(FRound(aTranslate.getX()), FRound(aTranslate.getY())); + tools::Rectangle aBaseRect(aPoint, Size(FRound(aScale.getX()), FRound(aScale.getY()))); + + // set BaseRect + SetSnapRect(aBaseRect); +} + +// Give info if object is in destruction +bool SdrObject::IsInDestruction() const +{ + return getSdrModelFromSdrObject().IsInDestruction(); +} + +// return if fill is != drawing::FillStyle_NONE +bool SdrObject::HasFillStyle() const +{ + return GetObjectItem(XATTR_FILLSTYLE).GetValue() != drawing::FillStyle_NONE; +} + +bool SdrObject::HasLineStyle() const +{ + return GetObjectItem(XATTR_LINESTYLE).GetValue() != drawing::LineStyle_NONE; +} + + +// #i52224# +// on import of OLE object from MS documents the BLIP size might be retrieved, +// the following four methods are used to control it; +// usually this data makes no sense after the import is finished, since the object +// might be resized + + +void SdrObject::SetBLIPSizeRectangle( const tools::Rectangle& aRect ) +{ + maBLIPSizeRectangle = aRect; +} + +void SdrObject::SetContextWritingMode( const sal_Int16 /*_nContextWritingMode*/ ) +{ + // this base class does not support different writing modes, so ignore the call +} + +void SdrObject::SetDoNotInsertIntoPageAutomatically(const bool bSet) +{ + mbDoNotInsertIntoPageAutomatically = bSet; +} + + +// #i121917# +bool SdrObject::HasText() const +{ + return false; +} + +bool SdrObject::IsTextBox() const +{ + return false; +} + +void SdrObject::MakeNameUnique() +{ + if (GetName().isEmpty()) + { + OUString aName; + if (const E3dScene* pE3dObj = DynCastE3dScene(this)) + { + SdrObjList* pObjList = pE3dObj->GetSubList(); + if (pObjList) + { + SdrObject* pObj0 = pObjList->GetObj(0); + if (pObj0) + aName = pObj0->TakeObjNameSingul(); + } + } + else + aName = TakeObjNameSingul(); + SetName(aName + " 1"); + } + + std::unordered_set aNameSet; + MakeNameUnique(aNameSet); +} + +void SdrObject::MakeNameUnique(std::unordered_set& rNameSet) +{ + if (GetName().isEmpty()) + return; + + if (rNameSet.empty()) + { + SdrPage* pPage; + SdrObject* pObj; + for (sal_uInt16 nPage(0); nPage < mrSdrModelFromSdrObject.GetPageCount(); ++nPage) + { + pPage = mrSdrModelFromSdrObject.GetPage(nPage); + SdrObjListIter aIter(pPage, SdrIterMode::DeepWithGroups); + while (aIter.IsMore()) + { + pObj = aIter.Next(); + if (pObj != this) + rNameSet.insert(pObj->GetName()); + } + } + } + + OUString sName(GetName().trim()); + OUString sRootName(sName); + + if (!sName.isEmpty() && rtl::isAsciiDigit(sName[sName.getLength() - 1])) + { + sal_Int32 nPos(sName.getLength() - 1); + while (nPos > 0 && rtl::isAsciiDigit(sName[--nPos])); + sRootName = o3tl::trim(sName.subView(0, nPos + 1)); + } + + for (sal_uInt32 n = 1; rNameSet.find(sName) != rNameSet.end(); n++) + sName = sRootName + " " + OUString::number(n); + rNameSet.insert(sName); + + SetName(sName); +} + +void SdrObject::ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon& rPolyPolygon) const noexcept +{ + MapUnit eMapUnit(getSdrModelFromSdrObject().GetItemPool().GetMetric(0)); + if(eMapUnit == MapUnit::Map100thMM) + return; + + if (const auto eTo = MapToO3tlLength(eMapUnit); eTo != o3tl::Length::invalid) + { + const double fConvert(o3tl::convert(1.0, o3tl::Length::mm100, eTo)); + rPolyPolygon.transform(basegfx::utils::createScaleB2DHomMatrix(fConvert, fConvert)); + } + else + { + OSL_FAIL("Missing unit translation to PoolMetric!"); + } +} + +const tools::Rectangle& SdrObject::getOutRectangle() const +{ + return m_aOutRect; +} + +void SdrObject::setOutRectangleConst(tools::Rectangle const& rRectangle) const +{ + m_aOutRect = rRectangle; +} + +void SdrObject::setOutRectangle(tools::Rectangle const& rRectangle) +{ + m_aOutRect = rRectangle; +} + +void SdrObject::resetOutRectangle() +{ + m_aOutRect = tools::Rectangle(); +} + +void SdrObject::moveOutRectangle(sal_Int32 nXDelta, sal_Int32 nYDelta) +{ + m_aOutRect.Move(nXDelta, nYDelta); +} + +E3dScene* DynCastE3dScene(SdrObject* pObj) +{ + if( pObj && pObj->GetObjInventor() == SdrInventor::E3d && pObj->GetObjIdentifier() == SdrObjKind::E3D_Scene ) + return static_cast(pObj); + return nullptr; +} + +E3dObject* DynCastE3dObject(SdrObject* pObj) +{ + if( pObj && pObj->GetObjInventor() == SdrInventor::E3d ) + return static_cast(pObj); + return nullptr; +} + +SdrTextObj* DynCastSdrTextObj(SdrObject* pObj) +{ + // SdrTextObj has a lot of subclasses, with lots of SdrObjKind identifiers, so use a virtual method + // to be safer. + if( pObj && pObj->IsSdrTextObj() ) + return static_cast(pObj); + return nullptr; +} + +rtl::Reference SdrObjFactory::CreateObjectFromFactory(SdrModel& rSdrModel, SdrInventor nInventor, SdrObjKind nObjIdentifier) +{ + SdrObjCreatorParams aParams { nInventor, nObjIdentifier, rSdrModel }; + for (const auto & i : ImpGetUserMakeObjHdl()) { + rtl::Reference pObj = i.Call(aParams); + if (pObj) { + return pObj; + } + } + return nullptr; +} + +namespace +{ + +// SdrObject subclass, which represents an empty object of a +// certain type (kind). +template +class EmptyObject final : public SdrObject +{ +private: + virtual ~EmptyObject() override + {} + +public: + EmptyObject(SdrModel& rSdrModel) + : SdrObject(rSdrModel) + { + } + + EmptyObject(SdrModel& rSdrModel, EmptyObject const& rSource) + : SdrObject(rSdrModel, rSource) + { + } + + rtl::Reference CloneSdrObject(SdrModel& rTargetModel) const override + { + return new EmptyObject(rTargetModel, *this); + } + + virtual std::unique_ptr CreateObjectSpecificProperties() override + { + return std::make_unique(*this); + } + + SdrInventor GetObjInventor() const override + { + return OBJECT_INVENTOR; + } + + SdrObjKind GetObjIdentifier() const override + { + return OBJECT_KIND; + } + + void NbcRotate(const Point& /*rRef*/, Degree100 /*nAngle*/, double /*sinAngle*/, double /*cosAngle*/) override + { + assert(false); // should not be called for this kind of objects + } +}; + +} // end anonymous namespace + +rtl::Reference SdrObjFactory::MakeNewObject( + SdrModel& rSdrModel, + SdrInventor nInventor, + SdrObjKind nIdentifier, + const tools::Rectangle* pSnapRect) +{ + rtl::Reference pObj; + bool bSetSnapRect(nullptr != pSnapRect); + + if (nInventor == SdrInventor::Default) + { + switch (nIdentifier) + { + case SdrObjKind::Measure: + { + if(nullptr != pSnapRect) + { + pObj = new SdrMeasureObj( + rSdrModel, + pSnapRect->TopLeft(), + pSnapRect->BottomRight()); + } + else + { + pObj = new SdrMeasureObj(rSdrModel); + } + } + break; + case SdrObjKind::Line: + { + if(nullptr != pSnapRect) + { + basegfx::B2DPolygon aPoly; + + aPoly.append( + basegfx::B2DPoint( + pSnapRect->Left(), + pSnapRect->Top())); + aPoly.append( + basegfx::B2DPoint( + pSnapRect->Right(), + pSnapRect->Bottom())); + pObj = new SdrPathObj( + rSdrModel, + SdrObjKind::Line, + basegfx::B2DPolyPolygon(aPoly)); + } + else + { + pObj = new SdrPathObj( + rSdrModel, + SdrObjKind::Line); + } + } + break; + case SdrObjKind::Text: + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + { + if(nullptr != pSnapRect) + { + pObj = new SdrRectObj( + rSdrModel, + nIdentifier, + *pSnapRect); + bSetSnapRect = false; + } + else + { + pObj = new SdrRectObj( + rSdrModel, + nIdentifier); + } + } + break; + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::CircleSection: + case SdrObjKind::CircleArc: + case SdrObjKind::CircleCut: + { + SdrCircKind eCircKind = ToSdrCircKind(nIdentifier); + if(nullptr != pSnapRect) + { + pObj = new SdrCircObj(rSdrModel, eCircKind, *pSnapRect); + bSetSnapRect = false; + } + else + { + pObj = new SdrCircObj(rSdrModel, eCircKind); + } + } + break; + case SdrObjKind::NONE: pObj = nullptr; break; + case SdrObjKind::Group : pObj=new SdrObjGroup(rSdrModel); break; + case SdrObjKind::Polygon : pObj=new SdrPathObj(rSdrModel, SdrObjKind::Polygon ); break; + case SdrObjKind::PolyLine : pObj=new SdrPathObj(rSdrModel, SdrObjKind::PolyLine ); break; + case SdrObjKind::PathLine : pObj=new SdrPathObj(rSdrModel, SdrObjKind::PathLine ); break; + case SdrObjKind::PathFill : pObj=new SdrPathObj(rSdrModel, SdrObjKind::PathFill ); break; + case SdrObjKind::FreehandLine : pObj=new SdrPathObj(rSdrModel, SdrObjKind::FreehandLine ); break; + case SdrObjKind::FreehandFill : pObj=new SdrPathObj(rSdrModel, SdrObjKind::FreehandFill ); break; + case SdrObjKind::PathPoly : pObj=new SdrPathObj(rSdrModel, SdrObjKind::Polygon ); break; + case SdrObjKind::PathPolyLine : pObj=new SdrPathObj(rSdrModel, SdrObjKind::PolyLine ); break; + case SdrObjKind::Edge : pObj=new SdrEdgeObj(rSdrModel); break; + case SdrObjKind::Rectangle : pObj=new SdrRectObj(rSdrModel); break; + case SdrObjKind::Graphic : pObj=new SdrGrafObj(rSdrModel); break; + case SdrObjKind::OLE2 : pObj=new SdrOle2Obj(rSdrModel); break; + case SdrObjKind::OLEPluginFrame : pObj=new SdrOle2Obj(rSdrModel, true); break; + case SdrObjKind::Caption : pObj=new SdrCaptionObj(rSdrModel); break; + case SdrObjKind::Page : pObj=new SdrPageObj(rSdrModel); break; + case SdrObjKind::UNO : pObj=new SdrUnoObj(rSdrModel, OUString()); break; + case SdrObjKind::CustomShape: pObj=new SdrObjCustomShape(rSdrModel); break; +#if HAVE_FEATURE_AVMEDIA + case SdrObjKind::Media : pObj=new SdrMediaObj(rSdrModel); break; +#endif + case SdrObjKind::Table : pObj=new sdr::table::SdrTableObj(rSdrModel); break; + case SdrObjKind::NewFrame: // used for frame creation in writer + pObj = new EmptyObject(rSdrModel); + break; + default: + break; + } + } + + if (!pObj) + { + pObj = CreateObjectFromFactory(rSdrModel, nInventor, nIdentifier); + } + + if (!pObj) + { + // Well, if no one wants it... + return nullptr; + } + + if(bSetSnapRect && nullptr != pSnapRect) + { + pObj->NbcSetSnapRect(*pSnapRect); + } + + return pObj; +} + +void SdrObjFactory::InsertMakeObjectHdl(Link> const & rLink) +{ + std::vector>>& rLL=ImpGetUserMakeObjHdl(); + auto it = std::find(rLL.begin(), rLL.end(), rLink); + if (it != rLL.end()) { + OSL_FAIL("SdrObjFactory::InsertMakeObjectHdl(): Link already in place."); + } else { + rLL.push_back(rLink); + } +} + +void SdrObjFactory::RemoveMakeObjectHdl(Link> const & rLink) +{ + std::vector>>& rLL=ImpGetUserMakeObjHdl(); + auto it = std::find(rLL.begin(), rLL.end(), rLink); + if (it != rLL.end()) + rLL.erase(it); +} + +namespace svx +{ + ISdrObjectFilter::~ISdrObjectFilter() + { + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdobjplusdata.cxx b/svx/source/svdraw/svdobjplusdata.cxx new file mode 100644 index 0000000000..8318b3df96 --- /dev/null +++ b/svx/source/svdraw/svdobjplusdata.cxx @@ -0,0 +1,63 @@ +/* -*- 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/. +*/ + +#include +#include +#include +#include +#include +#include + +SdrObjPlusData::SdrObjPlusData() +{ +} + +SdrObjPlusData::~SdrObjPlusData() +{ + o3tl::reset_preserve_ptr_during(pBroadcast); + pUserDataList.reset(); + pGluePoints.reset(); +} + +SdrObjPlusData* SdrObjPlusData::Clone(SdrObject* pObj1) const +{ + SdrObjPlusData* pNewPlusData=new SdrObjPlusData; + if (pUserDataList!=nullptr) { + sal_uInt16 nCount=pUserDataList->GetUserDataCount(); + if (nCount!=0) { + pNewPlusData->pUserDataList.reset(new SdrObjUserDataList); + for (sal_uInt16 i=0; i pNewUserData=pUserDataList->GetUserData(i).Clone(pObj1); + if (pNewUserData!=nullptr) { + pNewPlusData->pUserDataList->AppendUserData(std::move(pNewUserData)); + } else { + OSL_FAIL("SdrObjPlusData::Clone(): UserData.Clone() returns NULL."); + } + } + } + } + if (pGluePoints!=nullptr) pNewPlusData->pGluePoints.reset(new SdrGluePointList(*pGluePoints)); + // MtfAnimator isn't copied either + + // #i68101# + // copy object name, title and description + pNewPlusData->aObjName = aObjName; + pNewPlusData->aObjTitle = aObjTitle; + pNewPlusData->aObjDescription = aObjDescription; + pNewPlusData->isDecorative = isDecorative; + + return pNewPlusData; +} + +void SdrObjPlusData::SetGluePoints(const SdrGluePointList& rPts) +{ + *pGluePoints = rPts; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdobjuserdatalist.cxx b/svx/source/svdraw/svdobjuserdatalist.cxx new file mode 100644 index 0000000000..cae5e8db68 --- /dev/null +++ b/svx/source/svdraw/svdobjuserdatalist.cxx @@ -0,0 +1,36 @@ +/* -*- 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/. +*/ + +#include +#include + +SdrObjUserDataList::SdrObjUserDataList() {} +SdrObjUserDataList::~SdrObjUserDataList() {} + +size_t SdrObjUserDataList::GetUserDataCount() const +{ + return maList.size(); +} + +SdrObjUserData& SdrObjUserDataList::GetUserData(size_t nNum) +{ + return *maList.at(nNum); +} + +void SdrObjUserDataList::AppendUserData(std::unique_ptr pData) +{ + maList.push_back(std::move(pData)); +} + +void SdrObjUserDataList::DeleteUserData(size_t nNum) +{ + maList.erase(maList.begin()+nNum); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdocapt.cxx b/svx/source/svdraw/svdocapt.cxx new file mode 100644 index 0000000000..98c86664c2 --- /dev/null +++ b/svx/source/svdraw/svdocapt.cxx @@ -0,0 +1,757 @@ +/* -*- 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 + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +enum EscDir {LKS,RTS,OBN,UNT}; + +} + +class ImpCaptParams +{ +public: + SdrCaptionType eType; + tools::Long nGap; + tools::Long nEscRel; + tools::Long nEscAbs; + tools::Long nLineLen; + SdrCaptionEscDir eEscDir; + bool bFitLineLen; + bool bEscRel; + bool bFixedAngle; + +public: + ImpCaptParams() + : eType(SdrCaptionType::Type3), + nGap(0), nEscRel(5000), nEscAbs(0), + nLineLen(0), eEscDir(SdrCaptionEscDir::Horizontal), + bFitLineLen(true), bEscRel(true), bFixedAngle(false) + { + } + void CalcEscPos(const Point& rTail, const tools::Rectangle& rRect, Point& rPt, EscDir& rDir) const; +}; + +void ImpCaptParams::CalcEscPos(const Point& rTailPt, const tools::Rectangle& rRect, Point& rPt, EscDir& rDir) const +{ + Point aTl(rTailPt); // copy locally for performance reasons + tools::Long nX,nY; + if (bEscRel) { + nX=rRect.Right()-rRect.Left(); + nX=BigMulDiv(nX,nEscRel,10000); + nY=rRect.Bottom()-rRect.Top(); + nY=BigMulDiv(nY,nEscRel,10000); + } else { + nX=nEscAbs; + nY=nEscAbs; + } + nX+=rRect.Left(); + nY+=rRect.Top(); + Point aBestPt; + EscDir eBestDir=LKS; + bool bTryH=eEscDir==SdrCaptionEscDir::BestFit; + if (!bTryH) { + if (eType!=SdrCaptionType::Type1) { + bTryH=eEscDir==SdrCaptionEscDir::Horizontal; + } else { + bTryH=eEscDir==SdrCaptionEscDir::Vertical; + } + } + bool bTryV=eEscDir==SdrCaptionEscDir::BestFit; + if (!bTryV) { + if (eType!=SdrCaptionType::Type1) { + bTryV=eEscDir==SdrCaptionEscDir::Vertical; + } else { + bTryV=eEscDir==SdrCaptionEscDir::Horizontal; + } + } + + if (bTryH) { + Point aLft(rRect.Left()-nGap,nY); + Point aRgt(rRect.Right()+nGap,nY); + bool bLft=(aTl.X()-aLft.X()=aHorX+aHorY; + } + } + if (bTakeIt) { + aBestPt=aBest2; + eBestDir=eBest2; + } + } + rPt=aBestPt; + rDir=eBestDir; +} + + +// BaseProperties section + +std::unique_ptr SdrCaptionObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrCaptionObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +SdrCaptionObj::SdrCaptionObj(SdrModel& rSdrModel) +: SdrRectObj(rSdrModel, SdrObjKind::Text), + aTailPoly(3), // default size: 3 points = 2 lines + mbSpecialTextBoxShadow(false), + mbFixedTail(false), + mbSuppressGetBitmap(false) +{ +} + +SdrCaptionObj::SdrCaptionObj(SdrModel& rSdrModel, SdrCaptionObj const & rSource) +: SdrRectObj(rSdrModel, rSource), + mbSuppressGetBitmap(false) +{ + aTailPoly = rSource.aTailPoly; + mbSpecialTextBoxShadow = rSource.mbSpecialTextBoxShadow; + mbFixedTail = rSource.mbFixedTail; + maFixedTailPos = rSource.maFixedTailPos; +} + +SdrCaptionObj::SdrCaptionObj( + SdrModel& rSdrModel, + const tools::Rectangle& rRect, + const Point& rTail) +: SdrRectObj(rSdrModel, SdrObjKind::Text,rRect), + aTailPoly(3), // default size: 3 points = 2 lines + mbSpecialTextBoxShadow(false), + mbFixedTail(false), + mbSuppressGetBitmap(false) +{ + aTailPoly[0]=maFixedTailPos=rTail; +} + +SdrCaptionObj::~SdrCaptionObj() +{ +} + +void SdrCaptionObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bRotateFreeAllowed=false; + rInfo.bRotate90Allowed =false; + rInfo.bMirrorFreeAllowed=false; + rInfo.bMirror45Allowed =false; + rInfo.bMirror90Allowed =false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =false; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bCanConvToPath =true; + rInfo.bCanConvToPoly =true; + rInfo.bCanConvToPathLineToArea=false; + rInfo.bCanConvToPolyLineToArea=false; + rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrCaptionObj::GetObjIdentifier() const +{ + return SdrObjKind::Caption; +} + +rtl::Reference SdrCaptionObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrCaptionObj(rTargetModel, *this); +} + +OUString SdrCaptionObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulCAPTION)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrCaptionObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralCAPTION); +} + +basegfx::B2DPolyPolygon SdrCaptionObj::TakeXorPoly() const +{ + basegfx::B2DPolyPolygon aPolyPoly(SdrRectObj::TakeXorPoly()); + aPolyPoly.append(aTailPoly.getB2DPolygon()); + + return aPolyPoly; +} + +sal_uInt32 SdrCaptionObj::GetHdlCount() const +{ + sal_uInt32 nCount1(SdrRectObj::GetHdlCount()); + // Currently only dragging the tail's end is implemented. + return nCount1 + 1; +} + +void SdrCaptionObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + SdrRectObj::AddToHdlList(rHdlList); + // Currently only dragging the tail's end is implemented. + std::unique_ptr pHdl(new SdrHdl(aTailPoly.GetPoint(0), SdrHdlKind::Poly)); + pHdl->SetPolyNum(1); + pHdl->SetPointNum(0); + rHdlList.AddHdl(std::move(pHdl)); +} + +bool SdrCaptionObj::hasSpecialDrag() const +{ + return true; +} + +bool SdrCaptionObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + rDrag.SetEndDragChangesAttributes(true); + rDrag.SetEndDragChangesGeoAndAttributes(true); + + if(pHdl && 0 == pHdl->GetPolyNum()) + { + return SdrRectObj::beginSpecialDrag(rDrag); + } + else + { + rDrag.SetOrtho8Possible(); + + if(!pHdl) + { + if (m_bMovProt) + return false; + + rDrag.SetNoSnap(); + rDrag.SetActionRect(getRectangle()); + + Point aHit(rDrag.GetStart()); + + if(rDrag.GetPageView() && SdrObjectPrimitiveHit(*this, aHit, {0, 0}, *rDrag.GetPageView(), nullptr, false)) + { + return true; + } + } + else + { + if((1 == pHdl->GetPolyNum()) && (0 == pHdl->GetPointNum())) + return true; + } + } + + return false; +} + +bool SdrCaptionObj::applySpecialDrag(SdrDragStat& rDrag) +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + + if(pHdl && 0 == pHdl->GetPolyNum()) + { + const bool bRet(SdrRectObj::applySpecialDrag(rDrag)); + ImpRecalcTail(); + ActionChanged(); + + return bRet; + } + else + { + Point aDelta(rDrag.GetNow()-rDrag.GetStart()); + + if(!pHdl) + { + moveRectangle(aDelta.X(), aDelta.Y()); + } + else + { + aTailPoly[0] += aDelta; + } + + ImpRecalcTail(); + ActionChanged(); + + return true; + } +} + +OUString SdrCaptionObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment) + { + return OUString(); + } + else + { + const SdrHdl* pHdl = rDrag.GetHdl(); + + if(pHdl && 0 == pHdl->GetPolyNum()) + { + return SdrRectObj::getSpecialDragComment(rDrag); + } + else + { + if(!pHdl) + { + return ImpGetDescriptionStr(STR_DragCaptFram); + } + else + { + return ImpGetDescriptionStr(STR_DragCaptTail); + } + } + } +} + + +void SdrCaptionObj::ImpGetCaptParams(ImpCaptParams& rPara) const +{ + const SfxItemSet& rSet = GetObjectItemSet(); + rPara.eType =rSet.Get(SDRATTR_CAPTIONTYPE ).GetValue(); + rPara.bFixedAngle=rSet.Get(SDRATTR_CAPTIONFIXEDANGLE).GetValue(); + rPara.nGap =static_cast (rSet.Get(SDRATTR_CAPTIONGAP )).GetValue(); + rPara.eEscDir =rSet.Get(SDRATTR_CAPTIONESCDIR ).GetValue(); + rPara.bEscRel =rSet.Get(SDRATTR_CAPTIONESCISREL ).GetValue(); + rPara.nEscRel =rSet.Get(SDRATTR_CAPTIONESCREL ).GetValue(); + rPara.nEscAbs =rSet.Get(SDRATTR_CAPTIONESCABS ).GetValue(); + rPara.nLineLen =rSet.Get(SDRATTR_CAPTIONLINELEN ).GetValue(); + rPara.bFitLineLen=rSet.Get(SDRATTR_CAPTIONFITLINELEN).GetValue(); +} + +void SdrCaptionObj::ImpRecalcTail() +{ + ImpCaptParams aPara; + ImpGetCaptParams(aPara); + ImpCalcTail(aPara, aTailPoly, getRectangle()); + SetBoundAndSnapRectsDirty(); + SetXPolyDirty(); +} + +// #i35971# +// SdrCaptionObj::ImpCalcTail1 does move the object(!). What a hack. +// I really wonder why this had not triggered problems before. I am +// sure there are some places where SetTailPos() is called at least +// twice or SetSnapRect after it again just to work around this. +// Changed this method to not do that. +// Also found why this has been done: For interactive dragging of the +// tail end pos for SdrCaptionType::Type1. This sure was the simplest method +// to achieve this, at the cost of making a whole group of const methods +// of this object implicitly change the object's position. +void SdrCaptionObj::ImpCalcTail1(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect) +{ + tools::Polygon aPol(2); + Point aTl(rPoly[0]); + + aPol[0] = aTl; + aPol[1] = aTl; + + EscDir eEscDir; + Point aEscPos; + + rPara.CalcEscPos(aTl, rRect, aEscPos, eEscDir); + aPol[1] = aEscPos; + + if(eEscDir==LKS || eEscDir==RTS) + { + aPol[0].setX( aEscPos.X() ); + } + else + { + aPol[0].setY( aEscPos.Y() ); + } + + rPoly = aPol; +} + +void SdrCaptionObj::ImpCalcTail2(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect) +{ // Gap/EscDir/EscPos/Angle + tools::Polygon aPol(2); + Point aTl(rPoly[0]); + aPol[0]=aTl; + + EscDir eEscDir; + Point aEscPos; + rPara.CalcEscPos(aTl,rRect,aEscPos,eEscDir); + aPol[1]=aEscPos; + + if (!rPara.bFixedAngle) { + // TODO: Implementation missing. + } + rPoly=aPol; +} + +void SdrCaptionObj::ImpCalcTail3(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect) +{ // Gap/EscDir/EscPos/Angle/LineLen + tools::Polygon aPol(3); + Point aTl(rPoly[0]); + aPol[0]=aTl; + + EscDir eEscDir; + Point aEscPos; + rPara.CalcEscPos(aTl,rRect,aEscPos,eEscDir); + aPol[1]=aEscPos; + aPol[2]=aEscPos; + + if (eEscDir==LKS || eEscDir==RTS) { + if (rPara.bFitLineLen) { + aPol[1].setX((aTl.X()+aEscPos.X())/2 ); + } else { + if (eEscDir==LKS) aPol[1].AdjustX( -(rPara.nLineLen) ); + else aPol[1].AdjustX(rPara.nLineLen ); + } + } else { + if (rPara.bFitLineLen) { + aPol[1].setY((aTl.Y()+aEscPos.Y())/2 ); + } else { + if (eEscDir==OBN) aPol[1].AdjustY( -(rPara.nLineLen) ); + else aPol[1].AdjustY(rPara.nLineLen ); + } + } + if (!rPara.bFixedAngle) { + // TODO: Implementation missing. + } + rPoly=aPol; +} + +void SdrCaptionObj::ImpCalcTail(const ImpCaptParams& rPara, tools::Polygon& rPoly, tools::Rectangle const & rRect) +{ + switch (rPara.eType) { + case SdrCaptionType::Type1: ImpCalcTail1(rPara,rPoly,rRect); break; + case SdrCaptionType::Type2: ImpCalcTail2(rPara,rPoly,rRect); break; + case SdrCaptionType::Type3: ImpCalcTail3(rPara,rPoly,rRect); break; + case SdrCaptionType::Type4: ImpCalcTail3(rPara,rPoly,rRect); break; + } +} + +bool SdrCaptionObj::BegCreate(SdrDragStat& rStat) +{ + if (getRectangle().IsEmpty()) + return false; // Create currently only works with the given Rect + + ImpCaptParams aPara; + ImpGetCaptParams(aPara); + moveRectanglePosition(rStat.GetNow().X(), rStat.GetNow().Y()); + aTailPoly[0]=rStat.GetStart(); + ImpCalcTail(aPara,aTailPoly, getRectangle()); + rStat.SetActionRect(getRectangle()); + return true; +} + +bool SdrCaptionObj::MovCreate(SdrDragStat& rStat) +{ + ImpCaptParams aPara; + ImpGetCaptParams(aPara); + moveRectanglePosition(rStat.GetNow().X(), rStat.GetNow().Y()); + ImpCalcTail(aPara,aTailPoly, getRectangle()); + rStat.SetActionRect(getRectangle()); + SetBoundRectDirty(); + m_bSnapRectDirty=true; + return true; +} + +bool SdrCaptionObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + ImpCaptParams aPara; + ImpGetCaptParams(aPara); + moveRectanglePosition(rStat.GetNow().X(), rStat.GetNow().Y()); + ImpCalcTail(aPara,aTailPoly, getRectangle()); + SetBoundAndSnapRectsDirty(); + return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2); +} + +bool SdrCaptionObj::BckCreate(SdrDragStat& /*rStat*/) +{ + return false; +} + +void SdrCaptionObj::BrkCreate(SdrDragStat& /*rStat*/) +{ +} + +basegfx::B2DPolyPolygon SdrCaptionObj::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const +{ + basegfx::B2DPolyPolygon aRetval; + const basegfx::B2DRange aRange =vcl::unotools::b2DRectangleFromRectangle(getRectangle()); + aRetval.append(basegfx::utils::createPolygonFromRect(aRange)); + aRetval.append(aTailPoly.getB2DPolygon()); + return aRetval; +} + +PointerStyle SdrCaptionObj::GetCreatePointer() const +{ + return PointerStyle::DrawCaption; +} + +void SdrCaptionObj::NbcMove(const Size& rSiz) +{ + SdrRectObj::NbcMove(rSiz); + MovePoly(aTailPoly,rSiz); + if(mbFixedTail) + SetTailPos(GetFixedTailPos()); +} + +void SdrCaptionObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + SdrRectObj::NbcResize(rRef,xFact,yFact); + ResizePoly(aTailPoly,rRef,xFact,yFact); + ImpRecalcTail(); + if(mbFixedTail) + SetTailPos(GetFixedTailPos()); +} + +void SdrCaptionObj::NbcSetRelativePos(const Point& rPnt) +{ + Point aRelPos0(aTailPoly.GetPoint(0)-m_aAnchor); + Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y()); + NbcMove(aSiz); // This also calls SetRectsDirty() +} + +Point SdrCaptionObj::GetRelativePos() const +{ + return aTailPoly.GetPoint(0)-m_aAnchor; +} + +const tools::Rectangle& SdrCaptionObj::GetLogicRect() const +{ + return getRectangle(); +} + +void SdrCaptionObj::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + SdrRectObj::NbcSetLogicRect(rRect); + ImpRecalcTail(); +} + +const Point& SdrCaptionObj::GetTailPos() const +{ + return aTailPoly[0]; +} + +void SdrCaptionObj::SetTailPos(const Point& rPos) +{ + if (aTailPoly.GetSize()==0 || aTailPoly[0]!=rPos) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetTailPos(rPos); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrCaptionObj::NbcSetTailPos(const Point& rPos) +{ + aTailPoly[0]=rPos; + ImpRecalcTail(); +} + +sal_uInt32 SdrCaptionObj::GetSnapPointCount() const +{ + // TODO: Implementation missing. + return 0; +} + +Point SdrCaptionObj::GetSnapPoint(sal_uInt32 /*i*/) const +{ + // TODO: Implementation missing. + return Point(0,0); +} + +void SdrCaptionObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + SdrRectObj::Notify(rBC,rHint); + ImpRecalcTail(); +} + +std::unique_ptr SdrCaptionObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrCaptionObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrRectObj::SaveGeoData(rGeo); + SdrCaptObjGeoData& rCGeo=static_cast(rGeo); + rCGeo.aTailPoly=aTailPoly; +} + +void SdrCaptionObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrRectObj::RestoreGeoData(rGeo); + const SdrCaptObjGeoData& rCGeo=static_cast(rGeo); + aTailPoly=rCGeo.aTailPoly; +} + +rtl::Reference SdrCaptionObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + rtl::Reference pRect = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText); + rtl::Reference pTail = ImpConvertMakeObj(basegfx::B2DPolyPolygon(aTailPoly.getB2DPolygon()), false, bBezier); + rtl::Reference pRet; + if (pTail && !pRect) + pRet = std::move(pTail); + else if (pRect && !pTail) + pRet = std::move(pRect); + else if (pTail && pRect) + { + if (pTail->GetSubList()) + { + pTail->GetSubList()->NbcInsertObject(pRect.get()); + pRet = std::move(pTail); + } + else if (pRect->GetSubList()) + { + pRect->GetSubList()->NbcInsertObject(pTail.get(),0); + pRet = std::move(pRect); + } + else + { + rtl::Reference pGrp = new SdrObjGroup(getSdrModelFromSdrObject()); + pGrp->GetSubList()->NbcInsertObject(pRect.get()); + pGrp->GetSubList()->NbcInsertObject(pTail.get(),0); + pRet = pGrp; + } + } + return pRet; +} + +namespace { + +void handleNegativeScale(basegfx::B2DTuple & scale, double * rotate) { + assert(rotate != nullptr); + + // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings + // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly + if(basegfx::fTools::less(scale.getX(), 0.0) && basegfx::fTools::less(scale.getY(), 0.0)) + { + scale.setX(fabs(scale.getX())); + scale.setY(fabs(scale.getY())); + *rotate = fmod(*rotate + M_PI, 2 * M_PI); + } +} + +} + +// #i32599# +// Add own implementation for TRSetBaseGeometry to handle TailPos over changes. +void SdrCaptionObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/) +{ + // break up matrix + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + rMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + handleNegativeScale(aScale, &fRotate); + + // if anchor is used, make position relative to it + if(getSdrModelFromSdrObject().IsWriter()) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build BaseRect + Point aPoint(FRound(aTranslate.getX()), FRound(aTranslate.getY())); + tools::Rectangle aBaseRect(aPoint, Size(FRound(aScale.getX()), FRound(aScale.getY()))); + + // set BaseRect, but rescue TailPos over this call + const Point aTailPoint = GetTailPos(); + SetSnapRect(aBaseRect); + SetTailPos(aTailPoint); + ImpRecalcTail(); +} + +// geometry access +basegfx::B2DPolygon SdrCaptionObj::getTailPolygon() const +{ + return aTailPoly.getB2DPolygon(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdocirc.cxx b/svx/source/svdraw/svdocirc.cxx new file mode 100644 index 0000000000..becc496c76 --- /dev/null +++ b/svx/source/svdraw/svdocirc.cxx @@ -0,0 +1,1157 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +static Point GetAnglePnt(const tools::Rectangle& rR, Degree100 nAngle) +{ + Point aCenter(rR.Center()); + tools::Long nWdt=rR.Right()-rR.Left(); + tools::Long nHgt=rR.Bottom()-rR.Top(); + tools::Long nMaxRad=(std::max(nWdt,nHgt)+1) /2; + double a = toRadians(nAngle); + Point aRetval(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad)); + if (nWdt==0) aRetval.setX(0 ); + if (nHgt==0) aRetval.setY(0 ); + if (nWdt!=nHgt) { + if (nWdt>nHgt) { + if (nWdt!=0) { + // stop possible overruns for very large objects + if (std::abs(nHgt)>32767 || std::abs(aRetval.Y())>32767) { + aRetval.setY(BigMulDiv(aRetval.Y(),nHgt,nWdt) ); + } else { + aRetval.setY(aRetval.Y()*nHgt/nWdt ); + } + } + } else { + if (nHgt!=0) { + // stop possible overruns for very large objects + if (std::abs(nWdt)>32767 || std::abs(aRetval.X())>32767) { + aRetval.setX(BigMulDiv(aRetval.X(),nWdt,nHgt) ); + } else { + aRetval.setX(aRetval.X()*nWdt/nHgt ); + } + } + } + } + aRetval+=aCenter; + return aRetval; +} + + +// BaseProperties section + +std::unique_ptr SdrCircObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrCircObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +SdrCircKind ToSdrCircKind(SdrObjKind eKind) +{ + switch (eKind) + { + case SdrObjKind::CircleOrEllipse: return SdrCircKind::Full; + case SdrObjKind::CircleSection: return SdrCircKind::Section; + case SdrObjKind::CircleArc: return SdrCircKind::Arc; + case SdrObjKind::CircleCut: return SdrCircKind::Cut; + default: assert(false); + } + return SdrCircKind::Full; +} + +SdrCircObj::SdrCircObj( + SdrModel& rSdrModel, + SdrCircKind eNewKind) +: SdrRectObj(rSdrModel) +{ + nStartAngle=0_deg100; + nEndAngle=36000_deg100; + meCircleKind=eNewKind; + m_bClosedObj=eNewKind!=SdrCircKind::Arc; +} + +SdrCircObj::SdrCircObj(SdrModel& rSdrModel, SdrCircObj const & rSource) +: SdrRectObj(rSdrModel, rSource) +{ + meCircleKind = rSource.meCircleKind; + nStartAngle = rSource.nStartAngle; + nEndAngle = rSource.nEndAngle; + m_bClosedObj = rSource.m_bClosedObj; +} + +SdrCircObj::SdrCircObj( + SdrModel& rSdrModel, + SdrCircKind eNewKind, + const tools::Rectangle& rRect) +: SdrRectObj(rSdrModel, rRect) +{ + nStartAngle=0_deg100; + nEndAngle=36000_deg100; + meCircleKind=eNewKind; + m_bClosedObj=eNewKind!=SdrCircKind::Arc; +} + +SdrCircObj::SdrCircObj( + SdrModel& rSdrModel, + SdrCircKind eNewKind, + const tools::Rectangle& rRect, + Degree100 nNewStartAngle, + Degree100 nNewEndAngle) +: SdrRectObj(rSdrModel, rRect) +{ + Degree100 nAngleDif=nNewEndAngle-nNewStartAngle; + nStartAngle=NormAngle36000(nNewStartAngle); + nEndAngle=NormAngle36000(nNewEndAngle); + if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle + meCircleKind=eNewKind; + m_bClosedObj=eNewKind!=SdrCircKind::Arc; +} + +SdrCircObj::~SdrCircObj() +{ +} + +void SdrCircObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + bool bCanConv=!HasText() || ImpCanConvTextToCurve(); + rInfo.bEdgeRadiusAllowed = false; + rInfo.bCanConvToPath=bCanConv; + rInfo.bCanConvToPoly=bCanConv; + rInfo.bCanConvToContour = !IsFontwork() && (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrCircObj::GetObjIdentifier() const +{ + switch (meCircleKind) + { + case SdrCircKind::Full: return SdrObjKind::CircleOrEllipse; + case SdrCircKind::Section: return SdrObjKind::CircleSection; + case SdrCircKind::Cut: return SdrObjKind::CircleCut; + case SdrCircKind::Arc: return SdrObjKind::CircleArc; + default: assert(false); + } + return SdrObjKind::CircleOrEllipse; +} + +bool SdrCircObj::PaintNeedsXPolyCirc() const +{ + // XPoly is necessary for all rotated ellipse objects, circle and + // ellipse segments. + // If not WIN, then (for now) also for circle/ellipse segments and circle/ + // ellipse arcs (for precision) + bool bNeed = maGeo.m_nRotationAngle || maGeo.m_nShearAngle || meCircleKind == SdrCircKind::Cut; + // If not WIN, then for everything except full circle (for now!) + if (meCircleKind!=SdrCircKind::Full) bNeed = true; + + const SfxItemSet& rSet = GetObjectItemSet(); + if(!bNeed) + { + // XPoly is necessary for everything that isn't LineSolid or LineNone + drawing::LineStyle eLine = rSet.Get(XATTR_LINESTYLE).GetValue(); + bNeed = eLine != drawing::LineStyle_NONE && eLine != drawing::LineStyle_SOLID; + + // XPoly is necessary for thick lines + if(!bNeed && eLine != drawing::LineStyle_NONE) + bNeed = rSet.Get(XATTR_LINEWIDTH).GetValue() != 0; + + // XPoly is necessary for circle arcs with line ends + if(!bNeed && meCircleKind == SdrCircKind::Arc) + { + // start of the line is here if StartPolygon, StartWidth!=0 + bNeed=rSet.Get(XATTR_LINESTART).GetLineStartValue().count() != 0 && + rSet.Get(XATTR_LINESTARTWIDTH).GetValue() != 0; + + if(!bNeed) + { + // end of the line is here if EndPolygon, EndWidth!=0 + bNeed = rSet.Get(XATTR_LINEEND).GetLineEndValue().count() != 0 && + rSet.Get(XATTR_LINEENDWIDTH).GetValue() != 0; + } + } + } + + // XPoly is necessary if Fill !=None and !=Solid + if(!bNeed && meCircleKind != SdrCircKind::Arc) + { + drawing::FillStyle eFill=rSet.Get(XATTR_FILLSTYLE).GetValue(); + bNeed = eFill != drawing::FillStyle_NONE && eFill != drawing::FillStyle_SOLID; + } + + if(!bNeed && meCircleKind != SdrCircKind::Full && nStartAngle == nEndAngle) + bNeed = true; // otherwise we're drawing a full circle + + return bNeed; +} + +basegfx::B2DPolygon SdrCircObj::ImpCalcXPolyCirc(const SdrCircKind eCircleKind, const tools::Rectangle& rRect1, Degree100 nStart, Degree100 nEnd) const +{ + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRect1); + basegfx::B2DPolygon aCircPolygon; + + if(SdrCircKind::Full == eCircleKind) + { + // create full circle. Do not use createPolygonFromEllipse; it's necessary + // to get the start point to the bottom of the circle to keep compatible to + // old geometry creation + aCircPolygon = basegfx::utils::createPolygonFromUnitCircle(1); + + // needs own scaling and translation from unit circle to target size (same as + // would be in createPolygonFromEllipse) + const basegfx::B2DPoint aCenter(aRange.getCenter()); + const basegfx::B2DHomMatrix aMatrix(basegfx::utils::createScaleTranslateB2DHomMatrix( + aRange.getWidth() / 2.0, aRange.getHeight() / 2.0, + aCenter.getX(), aCenter.getY())); + aCircPolygon.transform(aMatrix); + } + else + { + // mirror start, end for geometry creation since model coordinate system is mirrored in Y + const double fStart(toRadians((36000_deg100 - nEnd) % 36000_deg100)); + const double fEnd(toRadians((36000_deg100 - nStart) % 36000_deg100)); + + // create circle segment. This is not closed by default + aCircPolygon = basegfx::utils::createPolygonFromEllipseSegment( + aRange.getCenter(), aRange.getWidth() / 2.0, aRange.getHeight() / 2.0, + fStart, fEnd); + + // check closing states + const bool bCloseSegment(SdrCircKind::Arc != eCircleKind); + const bool bCloseUsingCenter(SdrCircKind::Section == eCircleKind); + + if(bCloseSegment) + { + if(bCloseUsingCenter) + { + // add center point at start (for historical reasons) + basegfx::B2DPolygon aSector; + aSector.append(aRange.getCenter()); + aSector.append(aCircPolygon); + aCircPolygon = aSector; + } + + // close + aCircPolygon.setClosed(true); + } + } + + // #i76950# + if (maGeo.m_nShearAngle || maGeo.m_nRotationAngle) + { + // translate top left to (0,0) + const basegfx::B2DPoint aTopLeft(aRange.getMinimum()); + basegfx::B2DHomMatrix aMatrix(basegfx::utils::createTranslateB2DHomMatrix( + -aTopLeft.getX(), -aTopLeft.getY())); + + // shear, rotate and back to top left (if needed) + aMatrix = basegfx::utils::createShearXRotateTranslateB2DHomMatrix( + -maGeo.mfTanShearAngle, + maGeo.m_nRotationAngle ? toRadians(36000_deg100 - maGeo.m_nRotationAngle) : 0.0, + aTopLeft) * aMatrix; + + // apply transformation + aCircPolygon.transform(aMatrix); + } + + return aCircPolygon; +} + +void SdrCircObj::RecalcXPoly() +{ + basegfx::B2DPolygon aPolyCirc(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle)); + mpXPoly = XPolygon(aPolyCirc); +} + +OUString SdrCircObj::TakeObjNameSingul() const +{ + TranslateId pID=STR_ObjNameSingulCIRC; + if (getRectangle().GetWidth() == getRectangle().GetHeight() && maGeo.m_nShearAngle == 0_deg100) + { + switch (meCircleKind) { + case SdrCircKind::Full: pID=STR_ObjNameSingulCIRC; break; + case SdrCircKind::Section: pID=STR_ObjNameSingulSECT; break; + case SdrCircKind::Arc: pID=STR_ObjNameSingulCARC; break; + case SdrCircKind::Cut: pID=STR_ObjNameSingulCCUT; break; + default: break; + } + } else { + switch (meCircleKind) { + case SdrCircKind::Full: pID=STR_ObjNameSingulCIRCE; break; + case SdrCircKind::Section: pID=STR_ObjNameSingulSECTE; break; + case SdrCircKind::Arc: pID=STR_ObjNameSingulCARCE; break; + case SdrCircKind::Cut: pID=STR_ObjNameSingulCCUTE; break; + default: break; + } + } + OUString sName(SvxResId(pID)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + return sName; +} + +OUString SdrCircObj::TakeObjNamePlural() const +{ + TranslateId pID=STR_ObjNamePluralCIRC; + if (getRectangle().GetWidth() == getRectangle().GetHeight() && maGeo.m_nShearAngle == 0_deg100) + { + switch (meCircleKind) { + case SdrCircKind::Full: pID=STR_ObjNamePluralCIRC; break; + case SdrCircKind::Section: pID=STR_ObjNamePluralSECT; break; + case SdrCircKind::Arc: pID=STR_ObjNamePluralCARC; break; + case SdrCircKind::Cut: pID=STR_ObjNamePluralCCUT; break; + default: break; + } + } else { + switch (meCircleKind) { + case SdrCircKind::Full: pID=STR_ObjNamePluralCIRCE; break; + case SdrCircKind::Section: pID=STR_ObjNamePluralSECTE; break; + case SdrCircKind::Arc: pID=STR_ObjNamePluralCARCE; break; + case SdrCircKind::Cut: pID=STR_ObjNamePluralCCUTE; break; + default: break; + } + } + return SvxResId(pID); +} + +rtl::Reference SdrCircObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrCircObj(rTargetModel, *this); +} + +basegfx::B2DPolyPolygon SdrCircObj::TakeXorPoly() const +{ + const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle)); + return basegfx::B2DPolyPolygon(aCircPolygon); +} + +namespace { + +struct ImpCircUser : public SdrDragStatUserData +{ + tools::Rectangle aR; + Point aCenter; + Point aP1; + tools::Long nHgt; + tools::Long nWdt; + Degree100 nStart; + Degree100 nEnd; + +public: + ImpCircUser() + : nHgt(0), + nWdt(0), + nStart(0), + nEnd(0) + {} + void SetCreateParams(SdrDragStat const & rStat); +}; + +} + +sal_uInt32 SdrCircObj::GetHdlCount() const +{ + if(SdrCircKind::Full != meCircleKind) + { + return 10; + } + else + { + return 8; + } +} + +void SdrCircObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + for (sal_uInt32 nHdlNum=(SdrCircKind::Full==meCircleKind)?2:0; nHdlNum<=9; ++nHdlNum) + { + Point aPnt; + SdrHdlKind eLocalKind(SdrHdlKind::Move); + sal_uInt32 nPNum(0); + tools::Rectangle aRectangle = getRectangle(); + switch (nHdlNum) + { + case 0: + aPnt = GetAnglePnt(aRectangle, nStartAngle); + eLocalKind = SdrHdlKind::Circle; + nPNum = 1; + break; + case 1: + aPnt = GetAnglePnt(aRectangle, nEndAngle); + eLocalKind = SdrHdlKind::Circle; + nPNum = 2; + break; + case 2: + aPnt = aRectangle.TopLeft(); + eLocalKind = SdrHdlKind::UpperLeft; + break; + case 3: + aPnt = aRectangle.TopCenter(); + eLocalKind = SdrHdlKind::Upper; + break; + case 4: + aPnt = aRectangle.TopRight(); + eLocalKind = SdrHdlKind::UpperRight; + break; + case 5: + aPnt = aRectangle.LeftCenter(); + eLocalKind = SdrHdlKind::Left; + break; + case 6: + aPnt = aRectangle.RightCenter(); + eLocalKind = SdrHdlKind::Right; + break; + case 7: + aPnt = aRectangle.BottomLeft(); + eLocalKind = SdrHdlKind::LowerLeft; + break; + case 8: + aPnt = aRectangle.BottomCenter(); + eLocalKind = SdrHdlKind::Lower; + break; + case 9: + aPnt = aRectangle.BottomRight(); + eLocalKind = SdrHdlKind::LowerRight; + break; + } + + if (maGeo.m_nShearAngle) + { + ShearPoint(aPnt, aRectangle.TopLeft(), maGeo.mfTanShearAngle); + } + + if (maGeo.m_nRotationAngle) + { + RotatePoint(aPnt, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + } + + std::unique_ptr pH(new SdrHdl(aPnt,eLocalKind)); + pH->SetPointNum(nPNum); + pH->SetObj(const_cast(this)); + pH->SetRotationAngle(maGeo.m_nRotationAngle); + rHdlList.AddHdl(std::move(pH)); + } +} + + +bool SdrCircObj::hasSpecialDrag() const +{ + return true; +} + +bool SdrCircObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if(bAngle) + { + if(1 == rDrag.GetHdl()->GetPointNum() || 2 == rDrag.GetHdl()->GetPointNum()) + { + rDrag.SetNoSnap(); + } + + return true; + } + + return SdrTextObj::beginSpecialDrag(rDrag); +} + +bool SdrCircObj::applySpecialDrag(SdrDragStat& rDrag) +{ + const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if(bAngle) + { + Point aPt(rDrag.GetNow()); + + if (maGeo.m_nRotationAngle) + RotatePoint(aPt, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + if (maGeo.m_nShearAngle) + ShearPoint(aPt, getRectangle().TopLeft(), -maGeo.mfTanShearAngle); + + aPt -= getRectangle().Center(); + + tools::Long nWdt = getRectangle().Right() - getRectangle().Left(); + tools::Long nHgt = getRectangle().Bottom() - getRectangle().Top(); + + if(nWdt>=nHgt) + { + aPt.setY(BigMulDiv(aPt.Y(),nWdt,nHgt) ); + } + else + { + aPt.setX(BigMulDiv(aPt.X(),nHgt,nWdt) ); + } + + Degree100 nAngle=NormAngle36000(GetAngle(aPt)); + + if (rDrag.GetView() && rDrag.GetView()->IsAngleSnapEnabled()) + { + Degree100 nSA=rDrag.GetView()->GetSnapAngle(); + + if (nSA) + { + nAngle+=nSA/2_deg100; + nAngle/=nSA; + nAngle*=nSA; + nAngle=NormAngle36000(nAngle); + } + } + + if(1 == rDrag.GetHdl()->GetPointNum()) + { + nStartAngle = nAngle; + } + else if(2 == rDrag.GetHdl()->GetPointNum()) + { + nEndAngle = nAngle; + } + + SetBoundAndSnapRectsDirty(); + SetXPolyDirty(); + ImpSetCircInfoToAttr(); + SetChanged(); + + return true; + } + else + { + return SdrTextObj::applySpecialDrag(rDrag); + } +} + +OUString SdrCircObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment) + { + OUStringBuffer aBuf(ImpGetDescriptionStr(STR_ViewCreateObj)); + const sal_uInt32 nPointCount(rDrag.GetPointCount()); + + if(SdrCircKind::Full != meCircleKind && nPointCount > 2) + { + const ImpCircUser* pU = static_cast(rDrag.GetUser()); + Degree100 nAngle; + + aBuf.append(" ("); + + if(3 == nPointCount) + { + nAngle = pU->nStart; + } + else + { + nAngle = pU->nEnd; + } + + aBuf.append(SdrModel::GetAngleString(nAngle)); + aBuf.append(')'); + } + + return aBuf.makeStringAndClear(); + } + else + { + const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if(bAngle) + { + const Degree100 nAngle(1 == rDrag.GetHdl()->GetPointNum() ? nStartAngle : nEndAngle); + + return ImpGetDescriptionStr(STR_DragCircAngle) + + " (" + + SdrModel::GetAngleString(nAngle) + + ")"; + } + else + { + return SdrTextObj::getSpecialDragComment(rDrag); + } + } +} + + +void ImpCircUser::SetCreateParams(SdrDragStat const & rStat) +{ + rStat.TakeCreateRect(aR); + aR.Normalize(); + aCenter=aR.Center(); + nWdt=aR.Right()-aR.Left(); + nHgt=aR.Bottom()-aR.Top(); + nStart=0_deg100; + nEnd=36000_deg100; + if (rStat.GetPointCount()>2) { + Point aP(rStat.GetPoint(2)-aCenter); + if (nWdt==0) aP.setX(0 ); + if (nHgt==0) aP.setY(0 ); + if (nWdt>=nHgt) { + if (nHgt!=0) aP.setY(aP.Y()*nWdt/nHgt ); + } else { + if (nWdt!=0) aP.setX(aP.X()*nHgt/nWdt ); + } + nStart=NormAngle36000(GetAngle(aP)); + if (rStat.GetView()!=nullptr && rStat.GetView()->IsAngleSnapEnabled()) { + Degree100 nSA=rStat.GetView()->GetSnapAngle(); + if (nSA) { // angle snapping + nStart+=nSA/2_deg100; + nStart/=nSA; + nStart*=nSA; + nStart=NormAngle36000(nStart); + } + } + aP1 = GetAnglePnt(aR,nStart); + nEnd=nStart; + } else aP1=aCenter; + if (rStat.GetPointCount()<=3) + return; + + Point aP(rStat.GetPoint(3)-aCenter); + if (nWdt>=nHgt) { + aP.setY(BigMulDiv(aP.Y(),nWdt,nHgt) ); + } else { + aP.setX(BigMulDiv(aP.X(),nHgt,nWdt) ); + } + nEnd=NormAngle36000(GetAngle(aP)); + if (rStat.GetView()!=nullptr && rStat.GetView()->IsAngleSnapEnabled()) { + Degree100 nSA=rStat.GetView()->GetSnapAngle(); + if (nSA) { // angle snapping + nEnd+=nSA/2_deg100; + nEnd/=nSA; + nEnd*=nSA; + nEnd=NormAngle36000(nEnd); + } + } +} + +void SdrCircObj::ImpSetCreateParams(SdrDragStat& rStat) +{ + ImpCircUser* pU=static_cast(rStat.GetUser()); + if (pU==nullptr) { + pU=new ImpCircUser; + rStat.SetUser(std::unique_ptr(pU)); + } + pU->SetCreateParams(rStat); +} + +bool SdrCircObj::BegCreate(SdrDragStat& rStat) +{ + rStat.SetOrtho4Possible(); + tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow()); + aRect1.Normalize(); + rStat.SetActionRect(aRect1); + setRectangle(aRect1); + ImpSetCreateParams(rStat); + return true; +} + +bool SdrCircObj::MovCreate(SdrDragStat& rStat) +{ + ImpSetCreateParams(rStat); + ImpCircUser* pU=static_cast(rStat.GetUser()); + rStat.SetActionRect(pU->aR); + setRectangle(pU->aR); // for ObjName + ImpJustifyRect(maRectangle); + nStartAngle=pU->nStart; + nEndAngle=pU->nEnd; + SetBoundRectDirty(); + m_bSnapRectDirty=true; + SetXPolyDirty(); + + // #i103058# push current angle settings to ItemSet to + // allow FullDrag visualisation + if(rStat.GetPointCount() >= 4) + { + ImpSetCircInfoToAttr(); + } + + return true; +} + +bool SdrCircObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + ImpSetCreateParams(rStat); + ImpCircUser* pU=static_cast(rStat.GetUser()); + bool bRet = false; + if (eCmd==SdrCreateCmd::ForceEnd && rStat.GetPointCount()<4) meCircleKind=SdrCircKind::Full; + if (meCircleKind==SdrCircKind::Full) { + bRet=rStat.GetPointCount()>=2; + if (bRet) { + tools::Rectangle aRectangle(pU->aR); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + } + } else { + rStat.SetNoSnap(rStat.GetPointCount()>=2); + rStat.SetOrtho4Possible(rStat.GetPointCount()<2); + bRet=rStat.GetPointCount()>=4; + if (bRet) { + tools::Rectangle aRectangle(pU->aR); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + nStartAngle=pU->nStart; + nEndAngle=pU->nEnd; + } + } + m_bClosedObj=meCircleKind!=SdrCircKind::Arc; + SetBoundAndSnapRectsDirty(); + SetXPolyDirty(); + ImpSetCircInfoToAttr(); + if (bRet) + rStat.SetUser(nullptr); + return bRet; +} + +void SdrCircObj::BrkCreate(SdrDragStat& rStat) +{ + rStat.SetUser(nullptr); +} + +bool SdrCircObj::BckCreate(SdrDragStat& rStat) +{ + rStat.SetNoSnap(rStat.GetPointCount()>=3); + rStat.SetOrtho4Possible(rStat.GetPointCount()<3); + return meCircleKind!=SdrCircKind::Full; +} + +basegfx::B2DPolyPolygon SdrCircObj::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + const ImpCircUser* pU = static_cast(rDrag.GetUser()); + + if(rDrag.GetPointCount() < 4) + { + // force to OBJ_CIRC to get full visualisation + basegfx::B2DPolyPolygon aRetval(ImpCalcXPolyCirc(SdrCircKind::Full, pU->aR, pU->nStart, pU->nEnd)); + + if(3 == rDrag.GetPointCount()) + { + // add edge to first point on ellipse + basegfx::B2DPolygon aNew; + + aNew.append(basegfx::B2DPoint(pU->aCenter.X(), pU->aCenter.Y())); + aNew.append(basegfx::B2DPoint(pU->aP1.X(), pU->aP1.Y())); + aRetval.append(aNew); + } + + return aRetval; + } + else + { + return basegfx::B2DPolyPolygon(ImpCalcXPolyCirc(meCircleKind, pU->aR, pU->nStart, pU->nEnd)); + } +} + +PointerStyle SdrCircObj::GetCreatePointer() const +{ + switch (meCircleKind) { + case SdrCircKind::Full: return PointerStyle::DrawEllipse; + case SdrCircKind::Section: return PointerStyle::DrawPie; + case SdrCircKind::Arc: return PointerStyle::DrawArc; + case SdrCircKind::Cut: return PointerStyle::DrawCircleCut; + default: break; + } // switch + return PointerStyle::Cross; +} + +void SdrCircObj::NbcMove(const Size& aSize) +{ + moveRectangle(aSize.Width(), aSize.Height()); + moveOutRectangle(aSize.Width(), aSize.Height()); + maSnapRect.Move(aSize); + SetXPolyDirty(); + SetBoundAndSnapRectsDirty(true); +} + +void SdrCircObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + Degree100 nAngle0 = maGeo.m_nRotationAngle; + bool bNoShearRota = (maGeo.m_nRotationAngle == 0_deg100 && maGeo.m_nShearAngle == 0_deg100); + SdrTextObj::NbcResize(rRef,xFact,yFact); + bNoShearRota |= (maGeo.m_nRotationAngle == 0_deg100 && maGeo.m_nShearAngle == 0_deg100); + if (meCircleKind!=SdrCircKind::Full) { + bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0); + bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0); + if (bXMirr || bYMirr) { + // At bXMirr!=bYMirr we should actually swap both line ends. + // That, however, is pretty bad (because of forced "hard" formatting). + // Alternatively, we could implement a bMirrored flag (maybe even + // a more general one, e. g. for mirrored text, ...). + Degree100 nS0=nStartAngle; + Degree100 nE0=nEndAngle; + if (bNoShearRota) { + // the RectObj already mirrors at VMirror because of a 180deg rotation + if (! (bXMirr && bYMirr)) { + Degree100 nTmp=nS0; + nS0=18000_deg100-nE0; + nE0=18000_deg100-nTmp; + } + } else { // mirror contorted ellipses + if (bXMirr!=bYMirr) { + nS0+=nAngle0; + nE0+=nAngle0; + if (bXMirr) { + Degree100 nTmp=nS0; + nS0=18000_deg100-nE0; + nE0=18000_deg100-nTmp; + } + if (bYMirr) { + Degree100 nTmp=nS0; + nS0=-nE0; + nE0=-nTmp; + } + nS0 -= maGeo.m_nRotationAngle; + nE0 -= maGeo.m_nRotationAngle; + } + } + Degree100 nAngleDif=nE0-nS0; + nStartAngle=NormAngle36000(nS0); + nEndAngle =NormAngle36000(nE0); + if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle + } + } + SetXPolyDirty(); + ImpSetCircInfoToAttr(); +} + +void SdrCircObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + SdrTextObj::NbcShear(rRef,nAngle,tn,bVShear); + SetXPolyDirty(); + ImpSetCircInfoToAttr(); +} + +void SdrCircObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + bool bFreeMirr=meCircleKind!=SdrCircKind::Full; + Point aTmpPt1; + Point aTmpPt2; + if (bFreeMirr) { // some preparations for using an arbitrary axis of reflection + Point aCenter(getRectangle().Center()); + tools::Long nWdt = getRectangle().GetWidth() - 1; + tools::Long nHgt = getRectangle().GetHeight() - 1; + tools::Long nMaxRad=(std::max(nWdt,nHgt)+1) /2; + // starting point + double a = toRadians(nStartAngle); + aTmpPt1=Point(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad)); + if (nWdt==0) aTmpPt1.setX(0 ); + if (nHgt==0) aTmpPt1.setY(0 ); + aTmpPt1+=aCenter; + // finishing point + a = toRadians(nEndAngle); + aTmpPt2=Point(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad)); + if (nWdt==0) aTmpPt2.setX(0 ); + if (nHgt==0) aTmpPt2.setY(0 ); + aTmpPt2+=aCenter; + if (maGeo.m_nRotationAngle) + { + RotatePoint(aTmpPt1, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + RotatePoint(aTmpPt2, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + } + if (maGeo.m_nShearAngle) + { + ShearPoint(aTmpPt1, getRectangle().TopLeft(), maGeo.mfTanShearAngle); + ShearPoint(aTmpPt2, getRectangle().TopLeft(), maGeo.mfTanShearAngle); + } + } + SdrTextObj::NbcMirror(rRef1,rRef2); + if (meCircleKind!=SdrCircKind::Full) { // adapt starting and finishing angle + MirrorPoint(aTmpPt1,rRef1,rRef2); + MirrorPoint(aTmpPt2,rRef1,rRef2); + // unrotate: + if (maGeo.m_nRotationAngle) + { + RotatePoint(aTmpPt1, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); // -sin for reversion + RotatePoint(aTmpPt2, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); // -sin for reversion + } + // unshear: + if (maGeo.m_nShearAngle) + { + ShearPoint(aTmpPt1, getRectangle().TopLeft(), -maGeo.mfTanShearAngle); // -tan for reversion + ShearPoint(aTmpPt2, getRectangle().TopLeft(), -maGeo.mfTanShearAngle); // -tan for reversion + } + Point aCenter(getRectangle().Center()); + aTmpPt1-=aCenter; + aTmpPt2-=aCenter; + // because it's mirrored, the angles are swapped, too + nStartAngle=GetAngle(aTmpPt2); + nEndAngle =GetAngle(aTmpPt1); + Degree100 nAngleDif=nEndAngle-nStartAngle; + nStartAngle=NormAngle36000(nStartAngle); + nEndAngle =NormAngle36000(nEndAngle); + if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle + } + SetXPolyDirty(); + ImpSetCircInfoToAttr(); +} + +std::unique_ptr SdrCircObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrCircObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrRectObj::SaveGeoData(rGeo); + SdrCircObjGeoData& rCGeo=static_cast(rGeo); + rCGeo.nStartAngle=nStartAngle; + rCGeo.nEndAngle =nEndAngle; +} + +void SdrCircObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrRectObj::RestoreGeoData(rGeo); + const SdrCircObjGeoData& rCGeo=static_cast(rGeo); + nStartAngle=rCGeo.nStartAngle; + nEndAngle =rCGeo.nEndAngle; + SetXPolyDirty(); + ImpSetCircInfoToAttr(); +} + +static void Union(tools::Rectangle& rR, const Point& rP) +{ + if (rP.X()rR.Right ()) rR.SetRight(rP.X() ); + if (rP.Y()rR.Bottom()) rR.SetBottom(rP.Y() ); +} + +void SdrCircObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + rRect = getRectangle(); + if (meCircleKind!=SdrCircKind::Full) { + const Point aPntStart(GetAnglePnt(getRectangle(), nStartAngle)); + const Point aPntEnd(GetAnglePnt(getRectangle(), nEndAngle)); + Degree100 a=nStartAngle; + Degree100 e=nEndAngle; + rRect.SetLeft(getRectangle().Right() ); + rRect.SetRight(getRectangle().Left() ); + rRect.SetTop(getRectangle().Bottom() ); + rRect.SetBottom(getRectangle().Top() ); + Union(rRect,aPntStart); + Union(rRect,aPntEnd); + if ((a<=18000_deg100 && e>=18000_deg100) || (a>e && (a<=18000_deg100 || e>=18000_deg100))) { + Union(rRect, getRectangle().LeftCenter()); + } + if ((a<=27000_deg100 && e>=27000_deg100) || (a>e && (a<=27000_deg100 || e>=27000_deg100))) { + Union(rRect, getRectangle().BottomCenter()); + } + if (a>e) { + Union(rRect, getRectangle().RightCenter()); + } + if ((a<=9000_deg100 && e>=9000_deg100) || (a>e && (a<=9000_deg100 || e>=9000_deg100))) { + Union(rRect, getRectangle().TopCenter()); + } + if (meCircleKind==SdrCircKind::Section) { + Union(rRect, getRectangle().Center()); + } + if (maGeo.m_nRotationAngle) + { + Point aDst(rRect.TopLeft()); + aDst -= getRectangle().TopLeft(); + Point aDst0(aDst); + RotatePoint(aDst,Point(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aDst-=aDst0; + rRect.Move(aDst.X(),aDst.Y()); + } + } + if (maGeo.m_nShearAngle==0_deg100) + return; + + tools::Long nDst = FRound((rRect.Bottom() - rRect.Top()) * maGeo.mfTanShearAngle); + if (maGeo.m_nShearAngle > 0_deg100) + { + Point aRef(rRect.TopLeft()); + rRect.AdjustLeft( -nDst ); + Point aTmpPt(rRect.TopLeft()); + RotatePoint(aTmpPt, aRef, maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aTmpPt-=rRect.TopLeft(); + rRect.Move(aTmpPt.X(),aTmpPt.Y()); + } else { + rRect.AdjustRight( -nDst ); + } +} + +void SdrCircObj::RecalcSnapRect() +{ + if (PaintNeedsXPolyCirc()) { + maSnapRect=GetXPoly().GetBoundRect(); + } else { + TakeUnrotatedSnapRect(maSnapRect); + } +} + +void SdrCircObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + if (maGeo.m_nRotationAngle || maGeo.m_nShearAngle || meCircleKind != SdrCircKind::Full) + { + tools::Rectangle aSR0(GetSnapRect()); + tools::Long nWdt0=aSR0.Right()-aSR0.Left(); + tools::Long nHgt0=aSR0.Bottom()-aSR0.Top(); + tools::Long nWdt1=rRect.Right()-rRect.Left(); + tools::Long nHgt1=rRect.Bottom()-rRect.Top(); + NbcResize(maSnapRect.TopLeft(),Fraction(nWdt1,nWdt0),Fraction(nHgt1,nHgt0)); + NbcMove(Size(rRect.Left()-aSR0.Left(),rRect.Top()-aSR0.Top())); + } else { + setRectangle(rRect); + ImpJustifyRect(maRectangle); + } + SetBoundAndSnapRectsDirty(); + SetXPolyDirty(); + ImpSetCircInfoToAttr(); +} + +sal_uInt32 SdrCircObj::GetSnapPointCount() const +{ + if (meCircleKind==SdrCircKind::Full) { + return 1; + } else { + return 3; + } +} + +Point SdrCircObj::GetSnapPoint(sal_uInt32 i) const +{ + switch (i) + { + case 1 : return GetAnglePnt(getRectangle(), nStartAngle); + case 2 : return GetAnglePnt(getRectangle(), nEndAngle); + default: return getRectangle().Center(); + } +} + +void SdrCircObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + SetXPolyDirty(); + SdrRectObj::Notify(rBC,rHint); + ImpSetAttrToCircInfo(); +} + + +void SdrCircObj::ImpSetAttrToCircInfo() +{ + const SfxItemSet& rSet = GetObjectItemSet(); + SdrCircKind eNewKind = rSet.Get(SDRATTR_CIRCKIND).GetValue(); + + Degree100 nNewStart = rSet.Get(SDRATTR_CIRCSTARTANGLE).GetValue(); + Degree100 nNewEnd = rSet.Get(SDRATTR_CIRCENDANGLE).GetValue(); + + bool bKindChg = meCircleKind != eNewKind; + bool bAngleChg = nNewStart != nStartAngle || nNewEnd != nEndAngle; + + if(bKindChg || bAngleChg) + { + meCircleKind = eNewKind; + nStartAngle = nNewStart; + nEndAngle = nNewEnd; + + if(bKindChg || (meCircleKind != SdrCircKind::Full && bAngleChg)) + { + SetXPolyDirty(); + SetBoundAndSnapRectsDirty(); + } + } +} + +void SdrCircObj::ImpSetCircInfoToAttr() +{ + const SfxItemSet& rSet = GetObjectItemSet(); + + SdrCircKind eOldKindA = rSet.Get(SDRATTR_CIRCKIND).GetValue(); + Degree100 nOldStartAngle = rSet.Get(SDRATTR_CIRCSTARTANGLE).GetValue(); + Degree100 nOldEndAngle = rSet.Get(SDRATTR_CIRCENDANGLE).GetValue(); + + if(meCircleKind == eOldKindA && nStartAngle == nOldStartAngle && nEndAngle == nOldEndAngle) + return; + + // since SetItem() implicitly calls ImpSetAttrToCircInfo() + // setting the item directly is necessary here. + if(meCircleKind != eOldKindA) + { + GetProperties().SetObjectItemDirect(SdrCircKindItem(meCircleKind)); + } + + if(nStartAngle != nOldStartAngle) + { + GetProperties().SetObjectItemDirect(makeSdrCircStartAngleItem(nStartAngle)); + } + + if(nEndAngle != nOldEndAngle) + { + GetProperties().SetObjectItemDirect(makeSdrCircEndAngleItem(nEndAngle)); + } + + SetXPolyDirty(); + ImpSetAttrToCircInfo(); +} + +rtl::Reference SdrCircObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + const bool bFill(meCircleKind != SdrCircKind::Arc); + const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle)); + rtl::Reference pRet = ImpConvertMakeObj(basegfx::B2DPolyPolygon(aCircPolygon), bFill, bBezier); + + if(bAddText) + { + pRet = ImpConvertAddText(std::move(pRet), bBezier); + } + + return pRet; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoedge.cxx b/svx/source/svdraw/svdoedge.cxx new file mode 100644 index 0000000000..19c498948d --- /dev/null +++ b/svx/source/svdraw/svdoedge.cxx @@ -0,0 +1,2715 @@ +/* -*- 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 +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void SdrObjConnection::ResetVars() +{ + m_pSdrObj=nullptr; + m_nConId=0; + m_bBestConn=true; + m_bBestVertex=true; + m_bAutoVertex=false; + m_bAutoCorner=false; +} + +bool SdrObjConnection::TakeGluePoint(SdrGluePoint& rGP) const +{ + bool bRet = false; + if (m_pSdrObj!=nullptr) { // one object has to be docked already! + if (m_bAutoVertex) { + rGP=m_pSdrObj->GetVertexGluePoint(m_nConId); + bRet = true; + } else if (m_bAutoCorner) { + rGP=m_pSdrObj->GetCornerGluePoint(m_nConId); + bRet = true; + } else { + const SdrGluePointList* pGPL=m_pSdrObj->GetGluePointList(); + if (pGPL!=nullptr) { + sal_uInt16 nNum=pGPL->FindGluePoint(m_nConId); + if (nNum!=SDRGLUEPOINT_NOTFOUND) { + rGP=(*pGPL)[nNum]; + bRet = true; + } + } + } + } + if (bRet) { + Point aPt(rGP.GetAbsolutePos(*m_pSdrObj)); + aPt+=m_aObjOfs; + rGP.SetPos(aPt); + } + return bRet; +} + +Point& SdrEdgeInfoRec::ImpGetLineOffsetPoint(SdrEdgeLineCode eLineCode) +{ + switch (eLineCode) { + case SdrEdgeLineCode::Obj1Line2 : return m_aObj1Line2; + case SdrEdgeLineCode::Obj1Line3 : return m_aObj1Line3; + case SdrEdgeLineCode::Obj2Line2 : return m_aObj2Line2; + case SdrEdgeLineCode::Obj2Line3 : return m_aObj2Line3; + case SdrEdgeLineCode::MiddleLine: return m_aMiddleLine; + } // switch + return m_aMiddleLine; +} + +sal_uInt16 SdrEdgeInfoRec::ImpGetPolyIdx(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const +{ + switch (eLineCode) { + case SdrEdgeLineCode::Obj1Line2 : return 1; + case SdrEdgeLineCode::Obj1Line3 : return 2; + case SdrEdgeLineCode::Obj2Line2 : return rXP.GetPointCount()-3; + case SdrEdgeLineCode::Obj2Line3 : return rXP.GetPointCount()-4; + case SdrEdgeLineCode::MiddleLine: return m_nMiddleLine; + } // switch + return 0; +} + +bool SdrEdgeInfoRec::ImpIsHorzLine(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const +{ + sal_uInt16 nIdx=ImpGetPolyIdx(eLineCode,rXP); + bool bHorz=m_nAngle1==0 || m_nAngle1==18000; + if (eLineCode==SdrEdgeLineCode::Obj2Line2 || eLineCode==SdrEdgeLineCode::Obj2Line3) { + nIdx=rXP.GetPointCount()-nIdx; + bHorz=m_nAngle2==0 || m_nAngle2==18000; + } + if ((nIdx & 1)==1) bHorz=!bHorz; + return bHorz; +} + +void SdrEdgeInfoRec::ImpSetLineOffset(SdrEdgeLineCode eLineCode, const XPolygon& rXP, tools::Long nVal) +{ + Point& rPt=ImpGetLineOffsetPoint(eLineCode); + if (ImpIsHorzLine(eLineCode,rXP)) rPt.setY(nVal ); + else rPt.setX(nVal ); +} + +tools::Long SdrEdgeInfoRec::ImpGetLineOffset(SdrEdgeLineCode eLineCode, const XPolygon& rXP) const +{ + const Point& rPt = const_cast(this)->ImpGetLineOffsetPoint(eLineCode); + if (ImpIsHorzLine(eLineCode,rXP)) + return rPt.Y(); + else + return rPt.X(); +} + + +// BaseProperties section + +std::unique_ptr SdrEdgeObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrEdgeObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +SdrEdgeObj::SdrEdgeObj(SdrModel& rSdrModel) +: SdrTextObj(rSdrModel), + m_nNotifyingCount(0), + m_bEdgeTrackDirty(false), + m_bEdgeTrackUserDefined(false), + // Default is to allow default connects + mbSuppressDefaultConnect(false), + mbBoundRectCalculationRunning(false), + mbSuppressed(false) +{ + m_bClosedObj=false; + m_bIsEdge=true; + m_pEdgeTrack = XPolygon(); +} + +SdrEdgeObj::SdrEdgeObj(SdrModel& rSdrModel, SdrEdgeObj const & rSource) +: SdrTextObj(rSdrModel, rSource), + m_nNotifyingCount(0), + m_bEdgeTrackDirty(false), + m_bEdgeTrackUserDefined(false), + // Default is to allow default connects + mbSuppressDefaultConnect(false), + mbBoundRectCalculationRunning(false), + mbSuppressed(false) +{ + m_bClosedObj = false; + m_bIsEdge = true; + m_pEdgeTrack = rSource.m_pEdgeTrack; + m_bEdgeTrackDirty=rSource.m_bEdgeTrackDirty; + m_aCon1 =rSource.m_aCon1; + m_aCon2 =rSource.m_aCon2; + m_aCon1.m_pSdrObj=nullptr; + m_aCon2.m_pSdrObj=nullptr; + m_aEdgeInfo=rSource.m_aEdgeInfo; +} + +SdrEdgeObj::~SdrEdgeObj() +{ + SdrEdgeObj::DisconnectFromNode(true); + SdrEdgeObj::DisconnectFromNode(false); +} + +void SdrEdgeObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + // call parent + SdrTextObj::handlePageChange(pOldPage, pNewPage); + + if(nullptr != GetConnection(true).GetSdrObject() || nullptr != GetConnection(false).GetSdrObject()) + { + // check broadcasters; when we are not inserted we do not need broadcasters + // TTTT not yet added, but keep hint to do this here + // mpCon1->ownerPageChange(); + // mpCon2->ownerPageChange(); + } +} + +void SdrEdgeObj::ImpSetAttrToEdgeInfo() +{ + const SfxItemSet& rSet = GetObjectItemSet(); + SdrEdgeKind eKind = rSet.Get(SDRATTR_EDGEKIND).GetValue(); + sal_Int32 nVal1 = rSet.Get(SDRATTR_EDGELINE1DELTA).GetValue(); + sal_Int32 nVal2 = rSet.Get(SDRATTR_EDGELINE2DELTA).GetValue(); + sal_Int32 nVal3 = rSet.Get(SDRATTR_EDGELINE3DELTA).GetValue(); + + if(eKind == SdrEdgeKind::OrthoLines || eKind == SdrEdgeKind::Bezier) + { + sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 }; + sal_uInt16 n = 0; + + if(m_aEdgeInfo.m_nObj1Lines >= 2 && n < 3) + { + m_aEdgeInfo.ImpSetLineOffset(SdrEdgeLineCode::Obj1Line2, *m_pEdgeTrack, nVals[n]); + n++; + } + + if(m_aEdgeInfo.m_nObj1Lines >= 3 && n < 3) + { + m_aEdgeInfo.ImpSetLineOffset(SdrEdgeLineCode::Obj1Line3, *m_pEdgeTrack, nVals[n]); + n++; + } + + if(m_aEdgeInfo.m_nMiddleLine != 0xFFFF && n < 3) + { + m_aEdgeInfo.ImpSetLineOffset(SdrEdgeLineCode::MiddleLine, *m_pEdgeTrack, nVals[n]); + n++; + } + + if(m_aEdgeInfo.m_nObj2Lines >= 3 && n < 3) + { + m_aEdgeInfo.ImpSetLineOffset(SdrEdgeLineCode::Obj2Line3, *m_pEdgeTrack, nVals[n]); + n++; + } + + if(m_aEdgeInfo.m_nObj2Lines >= 2 && n < 3) + { + m_aEdgeInfo.ImpSetLineOffset(SdrEdgeLineCode::Obj2Line2, *m_pEdgeTrack, nVals[n]); + n++; + } + + // Do not overwrite existing value with default. ImpSetAttrToEdgeInfo() is called several + // times with a set, that does not have SDRATTR_EDGEOOXMLCURVE item. + if (rSet.HasItem(SDRATTR_EDGEOOXMLCURVE)) + m_aEdgeInfo.m_bUseOOXMLCurve = rSet.Get(SDRATTR_EDGEOOXMLCURVE).GetValue(); + } + else if(eKind == SdrEdgeKind::ThreeLines) + { + bool bHor1 = m_aEdgeInfo.m_nAngle1 == 0 || m_aEdgeInfo.m_nAngle1 == 18000; + bool bHor2 = m_aEdgeInfo.m_nAngle2 == 0 || m_aEdgeInfo.m_nAngle2 == 18000; + + if(bHor1) + { + m_aEdgeInfo.m_aObj1Line2.setX( nVal1 ); + } + else + { + m_aEdgeInfo.m_aObj1Line2.setY( nVal1 ); + } + + if(bHor2) + { + m_aEdgeInfo.m_aObj2Line2.setX( nVal2 ); + } + else + { + m_aEdgeInfo.m_aObj2Line2.setY( nVal2 ); + } + } + + ImpDirtyEdgeTrack(); +} + +void SdrEdgeObj::ImpSetEdgeInfoToAttr() +{ + const SfxItemSet& rSet = GetObjectItemSet(); + SdrEdgeKind eKind = rSet.Get(SDRATTR_EDGEKIND).GetValue(); + sal_Int32 nValCnt = rSet.Get(SDRATTR_EDGELINEDELTACOUNT).GetValue(); + sal_Int32 nVal1 = rSet.Get(SDRATTR_EDGELINE1DELTA).GetValue(); + sal_Int32 nVal2 = rSet.Get(SDRATTR_EDGELINE2DELTA).GetValue(); + sal_Int32 nVal3 = rSet.Get(SDRATTR_EDGELINE3DELTA).GetValue(); + sal_Int32 nVals[3] = { nVal1, nVal2, nVal3 }; + sal_uInt16 n = 0; + + if(eKind == SdrEdgeKind::OrthoLines || eKind == SdrEdgeKind::Bezier) + { + if(m_aEdgeInfo.m_nObj1Lines >= 2 && n < 3) + { + nVals[n] = m_aEdgeInfo.ImpGetLineOffset(SdrEdgeLineCode::Obj1Line2, *m_pEdgeTrack); + n++; + } + + if(m_aEdgeInfo.m_nObj1Lines >= 3 && n < 3) + { + nVals[n] = m_aEdgeInfo.ImpGetLineOffset(SdrEdgeLineCode::Obj1Line3, *m_pEdgeTrack); + n++; + } + + if(m_aEdgeInfo.m_nMiddleLine != 0xFFFF && n < 3) + { + nVals[n] = m_aEdgeInfo.ImpGetLineOffset(SdrEdgeLineCode::MiddleLine, *m_pEdgeTrack); + n++; + } + + if(m_aEdgeInfo.m_nObj2Lines >= 3 && n < 3) + { + nVals[n] = m_aEdgeInfo.ImpGetLineOffset(SdrEdgeLineCode::Obj2Line3, *m_pEdgeTrack); + n++; + } + + if(m_aEdgeInfo.m_nObj2Lines >= 2 && n < 3) + { + nVals[n] = m_aEdgeInfo.ImpGetLineOffset(SdrEdgeLineCode::Obj2Line2, *m_pEdgeTrack); + n++; + } + } + else if(eKind == SdrEdgeKind::ThreeLines) + { + bool bHor1 = m_aEdgeInfo.m_nAngle1 == 0 || m_aEdgeInfo.m_nAngle1 == 18000; + bool bHor2 = m_aEdgeInfo.m_nAngle2 == 0 || m_aEdgeInfo.m_nAngle2 == 18000; + + n = 2; + nVals[0] = bHor1 ? m_aEdgeInfo.m_aObj1Line2.X() : m_aEdgeInfo.m_aObj1Line2.Y(); + nVals[1] = bHor2 ? m_aEdgeInfo.m_aObj2Line2.X() : m_aEdgeInfo.m_aObj2Line2.Y(); + } + + if(!(n != nValCnt || nVals[0] != nVal1 || nVals[1] != nVal2 || nVals[2] != nVal3)) + return; + + // Here no more notifying is necessary, just local changes are OK. + if(n != nValCnt) + { + GetProperties().SetObjectItemDirect(SdrEdgeLineDeltaCountItem(n)); + } + + if(nVals[0] != nVal1) + { + GetProperties().SetObjectItemDirect(makeSdrEdgeLine1DeltaItem(nVals[0])); + } + + if(nVals[1] != nVal2) + { + GetProperties().SetObjectItemDirect(makeSdrEdgeLine2DeltaItem(nVals[1])); + } + + if(nVals[2] != nVal3) + { + GetProperties().SetObjectItemDirect(makeSdrEdgeLine3DeltaItem(nVals[2])); + } + + if(n < 3) + { + GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE3DELTA); + } + + if(n < 2) + { + GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE2DELTA); + } + + if(n < 1) + { + GetProperties().ClearObjectItemDirect(SDRATTR_EDGELINE1DELTA); + } + + GetProperties().SetObjectItemDirect( + SfxBoolItem(SDRATTR_EDGEOOXMLCURVE, m_aEdgeInfo.m_bUseOOXMLCurve)); +} + +void SdrEdgeObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + // #i54102# allow rotation, mirror and shear + rInfo.bRotateFreeAllowed = true; + rInfo.bRotate90Allowed = true; + rInfo.bMirrorFreeAllowed = true; + rInfo.bMirror45Allowed = true; + rInfo.bMirror90Allowed = true; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed = true; + rInfo.bEdgeRadiusAllowed = false; + bool bCanConv=!HasText() || ImpCanConvTextToCurve(); + rInfo.bCanConvToPath=bCanConv; + rInfo.bCanConvToPoly=bCanConv; + rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrEdgeObj::GetObjIdentifier() const +{ + return SdrObjKind::Edge; +} + +const tools::Rectangle& SdrEdgeObj::GetCurrentBoundRect() const +{ + if(m_bEdgeTrackDirty) + { + const_cast(this)->ImpRecalcEdgeTrack(); + } + + return SdrTextObj::GetCurrentBoundRect(); +} + +const tools::Rectangle& SdrEdgeObj::GetSnapRect() const +{ + if(m_bEdgeTrackDirty) + { + const_cast(this)->ImpRecalcEdgeTrack(); + } + + return SdrTextObj::GetSnapRect(); +} + +void SdrEdgeObj::RecalcSnapRect() +{ + maSnapRect=m_pEdgeTrack->GetBoundRect(); +} + +void SdrEdgeObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + rRect=GetSnapRect(); +} + +SdrGluePoint SdrEdgeObj::GetVertexGluePoint(sal_uInt16 nNum) const +{ + Point aPt; + sal_uInt16 nPointCount=m_pEdgeTrack->GetPointCount(); + if (nPointCount>0) + { + Point aOfs = GetSnapRect().Center(); + if (nNum==2 && GetConnectedNode(true)==nullptr) aPt=(*m_pEdgeTrack)[0]; + else if (nNum==3 && GetConnectedNode(false)==nullptr) aPt=(*m_pEdgeTrack)[nPointCount-1]; + else { + if ((nPointCount & 1) ==1) { + aPt=(*m_pEdgeTrack)[nPointCount/2]; + } else { + Point aPt1((*m_pEdgeTrack)[nPointCount/2-1]); + Point aPt2((*m_pEdgeTrack)[nPointCount/2]); + aPt1+=aPt2; + aPt1.setX( aPt1.X() / 2 ); + aPt1.setY( aPt1.Y() / 2 ); + aPt=aPt1; + } + } + aPt-=aOfs; + } + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + return aGP; +} + +SdrGluePoint SdrEdgeObj::GetCornerGluePoint(sal_uInt16 nNum) const +{ + return GetVertexGluePoint(nNum); +} + +const SdrGluePointList* SdrEdgeObj::GetGluePointList() const +{ + return nullptr; // no user defined gluepoints for connectors +} + +SdrGluePointList* SdrEdgeObj::ForceGluePointList() +{ + return nullptr; // no user defined gluepoints for connectors +} + +void SdrEdgeObj::ConnectToNode(bool bTail1, SdrObject* pObj) +{ + SdrObjConnection& rCon=GetConnection(bTail1); + DisconnectFromNode(bTail1); + if (pObj!=nullptr) { + pObj->AddListener(*this); + rCon.m_pSdrObj=pObj; + + // #i120437# If connection is set, reset bEdgeTrackUserDefined + m_bEdgeTrackUserDefined = false; + + ImpDirtyEdgeTrack(); + } +} + +void SdrEdgeObj::DisconnectFromNode(bool bTail1) +{ + SdrObjConnection& rCon=GetConnection(bTail1); + if (rCon.m_pSdrObj!=nullptr) { + rCon.m_pSdrObj->RemoveListener(*this); + rCon.m_pSdrObj=nullptr; + } +} + +SdrObject* SdrEdgeObj::GetConnectedNode(bool bTail1) const +{ + SdrObject* pObj(GetConnection(bTail1).m_pSdrObj); + + if(nullptr != pObj + && (pObj->getSdrPageFromSdrObject() != getSdrPageFromSdrObject() || !pObj->IsInserted())) + { + pObj = nullptr; + } + + return pObj; +} + +bool SdrEdgeObj::CheckNodeConnection(bool bTail1) const +{ + bool bRet = false; + const SdrObjConnection& rCon=GetConnection(bTail1); + sal_uInt16 nPointCount=m_pEdgeTrack->GetPointCount(); + + if(nullptr != rCon.m_pSdrObj && rCon.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject() && 0 != nPointCount) + { + const SdrGluePointList* pGPL=rCon.m_pSdrObj->GetGluePointList(); + sal_uInt16 nGluePointCnt=pGPL==nullptr ? 0 : pGPL->GetCount(); + sal_uInt16 nGesAnz=nGluePointCnt+8; + Point aTail(bTail1 ? (*m_pEdgeTrack)[0] : (*m_pEdgeTrack)[sal_uInt16(nPointCount-1)]); + for (sal_uInt16 i=0; iGetVertexGluePoint(i-nGluePointCnt)); + bRet=aTail==aPt.GetAbsolutePos(*rCon.m_pSdrObj); + } else { // Corner + SdrGluePoint aPt(rCon.m_pSdrObj->GetCornerGluePoint(i-nGluePointCnt-4)); + bRet=aTail==aPt.GetAbsolutePos(*rCon.m_pSdrObj); + } + } + } + return bRet; +} + +void SdrEdgeObj::ImpSetTailPoint(bool bTail1, const Point& rPt) +{ + sal_uInt16 nPointCount=m_pEdgeTrack->GetPointCount(); + if (nPointCount==0) { + (*m_pEdgeTrack)[0]=rPt; + (*m_pEdgeTrack)[1]=rPt; + } else if (nPointCount==1) { + if (!bTail1) (*m_pEdgeTrack)[1]=rPt; + else { (*m_pEdgeTrack)[1]=(*m_pEdgeTrack)[0]; (*m_pEdgeTrack)[0]=rPt; } + } else { + if (!bTail1) (*m_pEdgeTrack)[sal_uInt16(nPointCount-1)]=rPt; + else (*m_pEdgeTrack)[0]=rPt; + } + ImpRecalcEdgeTrack(); + SetBoundAndSnapRectsDirty(); +} + +void SdrEdgeObj::ImpDirtyEdgeTrack() +{ + if ( !m_bEdgeTrackUserDefined || !getSdrModelFromSdrObject().isLocked() ) + m_bEdgeTrackDirty = true; +} + +void SdrEdgeObj::ImpUndirtyEdgeTrack() +{ + if (m_bEdgeTrackDirty && getSdrModelFromSdrObject().isLocked()) + { + ImpRecalcEdgeTrack(); + } +} + +void SdrEdgeObj::ImpRecalcEdgeTrack() +{ + // #i120437# if bEdgeTrackUserDefined, do not recalculate + if(m_bEdgeTrackUserDefined) + { + return; + } + + // #i120437# also not when model locked during import, but remember + if(getSdrModelFromSdrObject().isLocked()) + { + mbSuppressed = true; + return; + } + + // #i110649# + if(mbBoundRectCalculationRunning) + { + // This object is involved into another ImpRecalcEdgeTrack() call + // from another SdrEdgeObj. Do not calculate again to avoid loop. + // Also, do not change bEdgeTrackDirty so that it gets recalculated + // later at the first non-looping call. + } + else + { + // To not run in a depth loop, use a coloring algorithm on + // SdrEdgeObj BoundRect calculations + mbBoundRectCalculationRunning = true; + + if(mbSuppressed) + { + // #i123048# If layouting was ever suppressed, it needs to be done once + // and the attr need to be set at EdgeInfo, else these attr *will be lost* + // in the following call to ImpSetEdgeInfoToAttr() since they were never + // set before (!) + *m_pEdgeTrack=ImpCalcEdgeTrack(*m_pEdgeTrack,m_aCon1,m_aCon2,&m_aEdgeInfo); + ImpSetAttrToEdgeInfo(); + mbSuppressed = false; + } + + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetCurrentBoundRect(); + SetBoundAndSnapRectsDirty(); + *m_pEdgeTrack=ImpCalcEdgeTrack(*m_pEdgeTrack,m_aCon1,m_aCon2,&m_aEdgeInfo); + ImpSetEdgeInfoToAttr(); // copy values from aEdgeInfo into the pool + m_bEdgeTrackDirty=false; + + // Only redraw here, no object change + ActionChanged(); + + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + + mbBoundRectCalculationRunning = false; + } +} + +SdrEscapeDirection SdrEdgeObj::ImpCalcEscAngle(SdrObject const * pObj, const Point& rPt) +{ + if (pObj==nullptr) return SdrEscapeDirection::ALL; + tools::Rectangle aR(pObj->GetSnapRect()); + tools::Long dxl=rPt.X()-aR.Left(); + tools::Long dyo=rPt.Y()-aR.Top(); + tools::Long dxr=aR.Right()-rPt.X(); + tools::Long dyu=aR.Bottom()-rPt.Y(); + bool bxMitt=std::abs(dxl-dxr)<2; + bool byMitt=std::abs(dyo-dyu)<2; + tools::Long dx=std::min(dxl,dxr); + tools::Long dy=std::min(dyo,dyu); + bool bDiag=std::abs(dx-dy)<2; + if (bxMitt && byMitt) return SdrEscapeDirection::ALL; // in the center + if (bDiag) { // diagonally + SdrEscapeDirection nRet=SdrEscapeDirection::SMART; + if (byMitt) nRet|=SdrEscapeDirection::VERT; + if (bxMitt) nRet|=SdrEscapeDirection::HORZ; + if (dxl=aP2.X()) aP2.setX(rMeeting.X() ); + if (bObn && rMeeting.Y()<=aP2.Y()) aP2.setY(rMeeting.Y() ); + if (bUnt && rMeeting.Y()>=aP2.Y()) aP2.setY(rMeeting.Y() ); + aXP.Insert(XPOLY_APPEND,aP2,PolyFlags::Normal); + + Point aP3(aP2); + if ((bLks && rMeeting.X()>aP2.X()) || (bRts && rMeeting.X()aP3.Y()) aP3.setY(rMeeting.Y() ); + } + aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal); + if (aP3.Y()!=rMeeting.Y()) { + aP3.setX(rMeeting.X() ); + aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal); + } + } + if ((bObn && rMeeting.Y()>aP2.Y()) || (bUnt && rMeeting.Y()aP3.X()) aP3.setX(rMeeting.X() ); + } + aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal); + if (aP3.X()!=rMeeting.X()) { + aP3.setY(rMeeting.Y() ); + aXP.Insert(XPOLY_APPEND,aP3,PolyFlags::Normal); + } + } +#ifdef DBG_UTIL + if (aXP.GetPointCount()>4) { + OSL_FAIL("SdrEdgeObj::ImpCalcObjToCenter(): Polygon has more than 4 points!"); + } +#endif + return aXP; +} + +XPolygon SdrEdgeObj::ImpCalcEdgeTrack(const XPolygon& rTrack0, SdrObjConnection& rCon1, SdrObjConnection& rCon2, SdrEdgeInfoRec* pInfo) const +{ + Point aPt1,aPt2; + SdrGluePoint aGP1,aGP2; + SdrEscapeDirection nEsc1=SdrEscapeDirection::ALL,nEsc2=SdrEscapeDirection::ALL; + tools::Rectangle aBoundRect1; + tools::Rectangle aBoundRect2; + tools::Rectangle aBewareRect1; + tools::Rectangle aBewareRect2; + // first, get the old corner points + if (rTrack0.GetPointCount()!=0) { + aPt1=rTrack0[0]; + sal_uInt16 nSiz=rTrack0.GetPointCount(); + nSiz--; + aPt2=rTrack0[nSiz]; + } + else + { + auto aRectangle = getOutRectangle(); + if (!aRectangle.IsEmpty()) { + aPt1 = aRectangle.TopLeft(); + aPt2 = aRectangle.BottomRight(); + } + } + + // #i54102# To allow interactive preview, do also if not inserted + const bool bCon1(nullptr != rCon1.m_pSdrObj && rCon1.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + const bool bCon2(nullptr != rCon2.m_pSdrObj && rCon2.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + const SfxItemSet& rSet = GetObjectItemSet(); + + if (bCon1) + { + if (rCon1.m_pSdrObj==static_cast(this)) + { + // check, just in case + aBoundRect1 = getOutRectangle(); + } + else + { + if (getSdrModelFromSdrObject().GetCompatibilityFlag(SdrCompatibilityFlag::ConnectorUseSnapRect)) + aBoundRect1 = rCon1.m_pSdrObj->GetSnapRect(); + else + aBoundRect1 = rCon1.m_pSdrObj->GetCurrentBoundRect(); + } + + aBoundRect1.Move(rCon1.m_aObjOfs.X(),rCon1.m_aObjOfs.Y()); + aBewareRect1=aBoundRect1; + sal_Int32 nH = rSet.Get(SDRATTR_EDGENODE1HORZDIST).GetValue(); + sal_Int32 nV = rSet.Get(SDRATTR_EDGENODE1VERTDIST).GetValue(); + aBewareRect1.AdjustLeft( -nH ); + aBewareRect1.AdjustRight(nH ); + aBewareRect1.AdjustTop( -nV ); + aBewareRect1.AdjustBottom(nV ); + } + else + { + aBoundRect1=tools::Rectangle(aPt1,aPt1); + aBoundRect1.Move(rCon1.m_aObjOfs.X(),rCon1.m_aObjOfs.Y()); + aBewareRect1=aBoundRect1; + } + + if (bCon2) + { + if (rCon2.m_pSdrObj==static_cast(this)) + { // check, just in case + aBoundRect2 = getOutRectangle(); + } + else + { + if (getSdrModelFromSdrObject().GetCompatibilityFlag(SdrCompatibilityFlag::ConnectorUseSnapRect)) + aBoundRect2 = rCon2.m_pSdrObj->GetSnapRect(); + else + aBoundRect2 = rCon2.m_pSdrObj->GetCurrentBoundRect(); + } + + aBoundRect2.Move(rCon2.m_aObjOfs.X(),rCon2.m_aObjOfs.Y()); + aBewareRect2=aBoundRect2; + sal_Int32 nH = rSet.Get(SDRATTR_EDGENODE2HORZDIST).GetValue(); + sal_Int32 nV = rSet.Get(SDRATTR_EDGENODE2VERTDIST).GetValue(); + aBewareRect2.AdjustLeft( -nH ); + aBewareRect2.AdjustRight(nH ); + aBewareRect2.AdjustTop( -nV ); + aBewareRect2.AdjustBottom(nV ); + } + else + { + aBoundRect2=tools::Rectangle(aPt2,aPt2); + aBoundRect2.Move(rCon2.m_aObjOfs.X(),rCon2.m_aObjOfs.Y()); + aBewareRect2=aBoundRect2; + } + + XPolygon aBestXP; + sal_uIntPtr nBestQual=0xFFFFFFFF; + SdrEdgeInfoRec aBestInfo; + bool bAuto1=bCon1 && rCon1.m_bBestVertex; + bool bAuto2=bCon2 && rCon2.m_bBestVertex; + if (bAuto1) rCon1.m_bAutoVertex=true; + if (bAuto2) rCon2.m_bAutoVertex=true; + sal_uInt16 nBestAuto1=0; + sal_uInt16 nBestAuto2=0; + sal_uInt16 nCount1=bAuto1 ? 4 : 1; + sal_uInt16 nCount2=bAuto2 ? 4 : 1; + + for (sal_uInt16 nNum1=0; nNum1m_nAngle1=nAngle1; + pInfo->m_nAngle2=nAngle2; + pInfo->m_nObj1Lines=1; + pInfo->m_nObj2Lines=1; + pInfo->m_nMiddleLine=0xFFFF; + } + Point aPt1(rPt1); + Point aPt2(rPt2); + tools::Rectangle aBoundRect1 (rBoundRect1 ); + tools::Rectangle aBoundRect2 (rBoundRect2 ); + tools::Rectangle aBewareRect1(rBewareRect1); + tools::Rectangle aBewareRect2(rBewareRect2); + Point aMeeting((aPt1.X()+aPt2.X()+1)/2,(aPt1.Y()+aPt2.Y()+1)/2); + if (eKind==SdrEdgeKind::OneLine) { + XPolygon aXP(2); + aXP[0]=rPt1; + aXP[1]=rPt2; + if (pnQuality!=nullptr) { + *pnQuality=std::abs(rPt1.X()-rPt2.X())+std::abs(rPt1.Y()-rPt2.Y()); + } + return aXP; + } else if (eKind==SdrEdgeKind::ThreeLines) { + XPolygon aXP(4); + aXP[0]=rPt1; + aXP[1]=rPt1; + aXP[2]=rPt2; + aXP[3]=rPt2; + if (bRts1) aXP[1].setX(aBewareRect1.Right() ); //+=500; + if (bObn1) aXP[1].setY(aBewareRect1.Top() ); //-=500; + if (bLks1) aXP[1].setX(aBewareRect1.Left() ); //-=500; + if (bUnt1) aXP[1].setY(aBewareRect1.Bottom() ); //+=500; + if (bRts2) aXP[2].setX(aBewareRect2.Right() ); //+=500; + if (bObn2) aXP[2].setY(aBewareRect2.Top() ); //-=500; + if (bLks2) aXP[2].setX(aBewareRect2.Left() ); //-=500; + if (bUnt2) aXP[2].setY(aBewareRect2.Bottom() ); //+=500; + if (pnQuality!=nullptr) { + tools::Long nQ=std::abs(aXP[1].X()-aXP[0].X())+std::abs(aXP[1].Y()-aXP[0].Y()); + nQ+=std::abs(aXP[2].X()-aXP[1].X())+std::abs(aXP[2].Y()-aXP[1].Y()); + nQ+=std::abs(aXP[3].X()-aXP[2].X())+std::abs(aXP[3].Y()-aXP[2].Y()); + *pnQuality=nQ; + } + if (pInfo) { + pInfo->m_nObj1Lines=2; + pInfo->m_nObj2Lines=2; + if (bHor1) { + aXP[1].AdjustX(pInfo->m_aObj1Line2.X() ); + } else { + aXP[1].AdjustY(pInfo->m_aObj1Line2.Y() ); + } + if (bHor2) { + aXP[2].AdjustX(pInfo->m_aObj2Line2.X() ); + } else { + aXP[2].AdjustY(pInfo->m_aObj2Line2.Y() ); + } + } + return aXP; + } + sal_uInt16 nIntersections=0; + { + Point aC1(aBewareRect1.Center()); + Point aC2(aBewareRect2.Center()); + if (aBewareRect1.Left()<=aBewareRect2.Right() && aBewareRect1.Right()>=aBewareRect2.Left()) { + // overlapping on the x axis + tools::Long n1=std::max(aBewareRect1.Left(),aBewareRect2.Left()); + tools::Long n2=std::min(aBewareRect1.Right(),aBewareRect2.Right()); + aMeeting.setX((n1+n2+1)/2 ); + } else { + // otherwise the center point of the empty space + if (aC1.X()=aBewareRect2.Top()) { + // overlapping on the x axis + tools::Long n1=std::max(aBewareRect1.Top(),aBewareRect2.Top()); + tools::Long n2=std::min(aBewareRect1.Bottom(),aBewareRect2.Bottom()); + aMeeting.setY((n1+n2+1)/2 ); + } else { + // otherwise the center point of the empty space + if (aC1.Y()aBewareRect2.Left() && aBewareRect1.Left()aBewareRect2.Top() && aBewareRect1.Top()=aBewareRect2.Right(); + bool bX2Ok=aPt2.X()<=aBewareRect1.Left() || aPt2.X()>=aBewareRect1.Right(); + bool bY1Ok=aPt1.Y()<=aBewareRect2.Top() || aPt1.Y()>=aBewareRect2.Bottom(); + bool bY2Ok=aPt2.Y()<=aBewareRect1.Top() || aPt2.Y()>=aBewareRect1.Bottom(); + if (bLks1 && (bY1Ok || aBewareRect1.Left()aBewareRect2.Left()) && (bY2Ok || aBewareRect2.Right()>aBewareRect1.Left())) { + aMeeting.setX(nXMax ); + } + if (bObn1 && (bX1Ok || aBewareRect1.Top()aBewareRect2.Top()) && (bX2Ok || aBewareRect2.Bottom()>aBewareRect1.Top())) { + aMeeting.setY(nYMax ); + } + } else if (nMainCase==2) { + // case 2: + if (bHor1) { // both horizontal + /* 9 sub-cases: + (legend: line exits to the left (-|), right (|-)) + + 2.1: Facing; overlap only on y axis + * * * + |--| * + * * * + + 2.2, 2.3: Facing, offset vertically; no overlap on either + axis + |- * * * * * + * -| * * -| * + * * * , * * * + + 2.4, 2.5: One below the other; overlap only on y axis + * |- * * * * + * -| * * -| * + * * * , * |- * + + 2.6, 2.7: Not facing, offset vertically; no overlap on either + axis + * * |- * * * + * -| * * -| * + * * * , * * |- + + 2.8: Not facing; overlap only on y axis + * * * + * -| |- + * * * + + 2.9: The objects's BewareRects overlap on x and y axis + + These cases, with some modifications are also valid for + horizontal line exits. + Cases 2.1 through 2.7 are covered well enough with the + default meetings. Only for cases 2.8 and 2.9 do we determine + special meeting points here. + */ + + // normalization; be aR1 the one exiting to the right, + // be aR2 the one exiting to the left + tools::Rectangle aBewR1(bRts1 ? aBewareRect1 : aBewareRect2); + tools::Rectangle aBewR2(bRts1 ? aBewareRect2 : aBewareRect1); + tools::Rectangle aBndR1(bRts1 ? aBoundRect1 : aBoundRect2); + tools::Rectangle aBndR2(bRts1 ? aBoundRect2 : aBoundRect1); + if (aBewR1.Bottom()>aBewR2.Top() && aBewR1.Top()aBewR2.Left()) { + /* Cases 2.8, 2.9: + Case 2.8: always going around on the outside + (bDirect=false). + + Case 2.9 could also be a direct connection (in the + case that the BewareRects overlap only slightly and + the BoundRects don't overlap at all and if the + line exits would otherwise violate the respective + other object's BewareRect). + */ + bool bCase29Direct = false; + bool bCase29=aBewR1.Right()>aBewR2.Left(); + if (aBndR1.Right()<=aBndR2.Left()) { // case 2.9 without BoundRect overlap + if ((aPt1.Y()>aBewareRect2.Top() && aPt1.Y()aBewareRect1.Top() && aPt2.Y()aBewR2.Left() && aBewR1.Left()aBewR2.Top()) { + /* Cases 2.8, 2.9 + Case 2.8 always going around on the outside (bDirect=false). + + Case 2.9 could also be a direct connection (in the + case that the BewareRects overlap only slightly and + the BoundRects don't overlap at all and if the + line exits would otherwise violate the respective + other object's BewareRect). + */ + bool bCase29Direct = false; + bool bCase29=aBewR1.Bottom()>aBewR2.Top(); + if (aBndR1.Bottom()<=aBndR2.Top()) { // case 2.9 without BoundRect overlap + if ((aPt1.X()>aBewareRect2.Left() && aPt1.X()aBewareRect1.Left() && aPt2.X()=aPt2.X())) && + ((bUnt2 && aTmpR2.Bottom()<=aPt1.Y()) || (bObn2 && aTmpR2.Top ()>=aPt1.Y()))) || + (((bRts2 && aTmpR2.Right ()<=aPt1.X()) || (bLks2 && aTmpR2.Left()>=aPt1.X())) && + ((bUnt1 && aTmpR1.Bottom()<=aPt2.Y()) || (bObn1 && aTmpR1.Top ()>=aPt2.Y())))) { + // case 3.2 applies: connector with only 2 lines + if (bHor1) { + aMeeting.setX(aPt2.X() ); + aMeeting.setY(aPt1.Y() ); + } else { + aMeeting.setX(aPt1.X() ); + aMeeting.setY(aPt2.Y() ); + } + // in the case of overlapping BewareRects: + aBewareRect1=aTmpR1; + aBewareRect2=aTmpR2; + } else if ((((bRts1 && aBewareRect1.Right ()>aBewareRect2.Left ()) || + (bLks1 && aBewareRect1.Left ()aBewareRect1.Top ()) || + (bObn2 && aBewareRect2.Top ()aBewareRect1.Left ()) || + (bLks2 && aBewareRect2.Left ()aBewareRect2.Top ()) || + (bObn1 && aBewareRect1.Top ()m_nObj1Lines=nXP1Cnt; if (nXP1Cnt>1) pInfo->m_nObj1Lines--; + pInfo->m_nObj2Lines=nXP2Cnt; if (nXP2Cnt>1) pInfo->m_nObj2Lines--; + } + Point aEP1(aXP1[nXP1Cnt-1]); + Point aEP2(aXP2[nXP2Cnt-1]); + bool bInsMeetingPoint=aEP1.X()!=aEP2.X() && aEP1.Y()!=aEP2.Y(); + bool bHorzE1=aEP1.Y()==aXP1[nXP1Cnt-2].Y(); // is last line of XP1 horizontal? + bool bHorzE2=aEP2.Y()==aXP2[nXP2Cnt-2].Y(); // is last line of XP2 horizontal? + if (aEP1==aEP2 && ((bHorzE1 && bHorzE2 && aEP1.Y()==aEP2.Y()) || (!bHorzE1 && !bHorzE2 && aEP1.X()==aEP2.X()))) { + // special casing 'I' connectors + nXP1Cnt--; aXP1.Remove(nXP1Cnt,1); + nXP2Cnt--; aXP2.Remove(nXP2Cnt,1); + } + if (bInsMeetingPoint) { + aXP1.Insert(XPOLY_APPEND,aMeeting,PolyFlags::Normal); + if (pInfo) { + // Inserting a MeetingPoint adds 2 new lines, + // either might become the center line. + if (pInfo->m_nObj1Lines==pInfo->m_nObj2Lines) { + pInfo->m_nObj1Lines++; + pInfo->m_nObj2Lines++; + } else { + if (pInfo->m_nObj1Lines>pInfo->m_nObj2Lines) { + pInfo->m_nObj2Lines++; + pInfo->m_nMiddleLine=nXP1Cnt-1; + } else { + pInfo->m_nObj1Lines++; + pInfo->m_nMiddleLine=nXP1Cnt; + } + } + } + } else if (pInfo && aEP1!=aEP2 && nXP1Cnt+nXP2Cnt>=4) { + // By connecting both ends, another line is added, this becomes the center line. + pInfo->m_nMiddleLine=nXP1Cnt-1; + } + sal_uInt16 nNum=aXP2.GetPointCount(); + if (aXP1[nXP1Cnt-1]==aXP2[nXP2Cnt-1] && nXP1Cnt>1 && nXP2Cnt>1) nNum--; + while (nNum>0) { + nNum--; + aXP1.Insert(XPOLY_APPEND,aXP2[nNum],PolyFlags::Normal); + } + sal_uInt16 nPointCount=aXP1.GetPointCount(); + char cForm; + if (pInfo || pnQuality!=nullptr) { + if (nPointCount==2) cForm='I'; + else if (nPointCount==3) cForm='L'; + else if (nPointCount==4) { // Z or U + if (nAngle1==nAngle2) cForm='U'; + else cForm='Z'; + } else if (nPointCount==6) { // S or C or ... + if (nAngle1!=nAngle2) { + // For type S, line 2 has the same direction as line 4. + // For type C, the opposite is true. + Point aP1(aXP1[1]); + Point aP2(aXP1[2]); + Point aP3(aXP1[3]); + Point aP4(aXP1[4]); + if (aP1.Y()==aP2.Y()) { // else both lines are horizontal + if ((aP1.X()m_nObj1Lines=1; + pInfo->m_nObj2Lines=1; + if (cForm=='Z' || cForm=='U') { + pInfo->m_nMiddleLine=1; + } else { + pInfo->m_nMiddleLine=0xFFFF; + } + } else if (cForm=='S' || cForm=='C') { + pInfo->m_nObj1Lines=2; + pInfo->m_nObj2Lines=2; + pInfo->m_nMiddleLine=2; + } + } + } + else + { + cForm = 0; + } + if (pnQuality!=nullptr) { + sal_uIntPtr nQual=0; + sal_uIntPtr nQual0=nQual; // prevent overruns + bool bOverflow = false; + Point aPt0(aXP1[0]); + for (sal_uInt16 nPntNum=1; nPntNum=n2) nBesser=6; + else if (n1>=3*n3) nBesser=4; + else if (n1>=2*n3) nBesser=2; + if (aXP1[0].Y()!=aXP1[1].Y()) nBesser++; // vertical starting line gets a plus (for H/V-Prio) + if (nQual>nBesser) nQual-=nBesser; else nQual=0; + } + if (nTmp>=3) { + nQual0=nQual; + nQual+=static_cast(nTmp)*0x01000000; + if (nQual15) bOverflow = true; + } + if (nPointCount>=2) { // check exit angle again + Point aP1(aXP1[1]); aP1-=aXP1[0]; + Point aP2(aXP1[nPointCount-2]); aP2-=aXP1[nPointCount-1]; + tools::Long nAng1=0; if (aP1.X()<0) nAng1=18000; if (aP1.Y()>0) nAng1=27000; + if (aP1.Y()<0) nAng1=9000; + if (aP1.X()!=0 && aP1.Y()!=0) nAng1=1; // slant?! + tools::Long nAng2=0; if (aP2.X()<0) nAng2=18000; if (aP2.Y()>0) nAng2=27000; + if (aP2.Y()<0) nAng2=9000; + if (aP2.X()!=0 && aP2.Y()!=0) nAng2=1; // slant?! + if (nAng1!=nAngle1) nIntersections++; + if (nAng2!=nAngle2) nIntersections++; + } + + // For the quality check, use the original Rects and at the same time + // check whether one them was scaled down for the calculation of the + // Edges (e. g. case 2.9) + aBewareRect1=rBewareRect1; + aBewareRect2=rBewareRect2; + + for (sal_uInt16 i=0; iaBewareRect1.Left() && aPt1b.X()aBewareRect1.Top() && aPt1b.Y()aBewareRect2.Left() && aPt1b.X()aBewareRect2.Top() && aPt1b.Y()0 && nInt0==nIntersections) { + if (aPt0.Y()==aPt1b.Y()) { // horizontal line + if (aPt0.Y()>aBewareRect1.Top() && aPt0.Y()=aBewareRect1.Right()) || + (aPt1b.X()<=aBewareRect1.Left() && aPt0.X()>=aBewareRect1.Right()))) nIntersections++; + if (aPt0.Y()>aBewareRect2.Top() && aPt0.Y()=aBewareRect2.Right()) || + (aPt1b.X()<=aBewareRect2.Left() && aPt0.X()>=aBewareRect2.Right()))) nIntersections++; + } else { // vertical line + if (aPt0.X()>aBewareRect1.Left() && aPt0.X()=aBewareRect1.Bottom()) || + (aPt1b.Y()<=aBewareRect1.Top() && aPt0.Y()>=aBewareRect1.Bottom()))) nIntersections++; + if (aPt0.X()>aBewareRect2.Left() && aPt0.X()=aBewareRect2.Bottom()) || + (aPt1b.Y()<=aBewareRect2.Top() && aPt0.Y()>=aBewareRect2.Bottom()))) nIntersections++; + } + } + aPt0=aPt1b; + } + if (nPointCount<=1) nIntersections++; + nQual0=nQual; + nQual+=static_cast(nIntersections)*0x10000000; + if (nQual15) bOverflow = true; + + if (bOverflow || nQual==0xFFFFFFFF) nQual=0xFFFFFFFE; + *pnQuality=nQual; + } + if (pInfo) { // now apply line offsets to aXP1 + if (pInfo->m_nMiddleLine!=0xFFFF) { + sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(SdrEdgeLineCode::MiddleLine,aXP1); + if (pInfo->ImpIsHorzLine(SdrEdgeLineCode::MiddleLine,aXP1)) { + aXP1[nIdx].AdjustY(pInfo->m_aMiddleLine.Y() ); + aXP1[nIdx+1].AdjustY(pInfo->m_aMiddleLine.Y() ); + } else { + aXP1[nIdx].AdjustX(pInfo->m_aMiddleLine.X() ); + aXP1[nIdx+1].AdjustX(pInfo->m_aMiddleLine.X() ); + } + } + if (pInfo->m_nObj1Lines>=2) { + sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(SdrEdgeLineCode::Obj1Line2,aXP1); + if (pInfo->ImpIsHorzLine(SdrEdgeLineCode::Obj1Line2,aXP1)) { + aXP1[nIdx].AdjustY(pInfo->m_aObj1Line2.Y() ); + aXP1[nIdx+1].AdjustY(pInfo->m_aObj1Line2.Y() ); + } else { + aXP1[nIdx].AdjustX(pInfo->m_aObj1Line2.X() ); + aXP1[nIdx+1].AdjustX(pInfo->m_aObj1Line2.X() ); + } + } + if (pInfo->m_nObj1Lines>=3) { + sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(SdrEdgeLineCode::Obj1Line3,aXP1); + if (pInfo->ImpIsHorzLine(SdrEdgeLineCode::Obj1Line3,aXP1)) { + aXP1[nIdx].AdjustY(pInfo->m_aObj1Line3.Y() ); + aXP1[nIdx+1].AdjustY(pInfo->m_aObj1Line3.Y() ); + } else { + aXP1[nIdx].AdjustX(pInfo->m_aObj1Line3.X() ); + aXP1[nIdx+1].AdjustX(pInfo->m_aObj1Line3.X() ); + } + } + if (pInfo->m_nObj2Lines>=2) { + sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(SdrEdgeLineCode::Obj2Line2,aXP1); + if (pInfo->ImpIsHorzLine(SdrEdgeLineCode::Obj2Line2,aXP1)) { + aXP1[nIdx].AdjustY(pInfo->m_aObj2Line2.Y() ); + aXP1[nIdx+1].AdjustY(pInfo->m_aObj2Line2.Y() ); + } else { + aXP1[nIdx].AdjustX(pInfo->m_aObj2Line2.X() ); + aXP1[nIdx+1].AdjustX(pInfo->m_aObj2Line2.X() ); + } + } + if (pInfo->m_nObj2Lines>=3) { + sal_uInt16 nIdx=pInfo->ImpGetPolyIdx(SdrEdgeLineCode::Obj2Line3,aXP1); + if (pInfo->ImpIsHorzLine(SdrEdgeLineCode::Obj2Line3,aXP1)) { + aXP1[nIdx].AdjustY(pInfo->m_aObj2Line3.Y() ); + aXP1[nIdx+1].AdjustY(pInfo->m_aObj2Line3.Y() ); + } else { + aXP1[nIdx].AdjustX(pInfo->m_aObj2Line3.X() ); + aXP1[nIdx+1].AdjustX(pInfo->m_aObj2Line3.X() ); + } + } + } + // make the connector a bezier curve, if appropriate + if (eKind != SdrEdgeKind::Bezier || nPointCount <= 2) + return aXP1; + + if (pInfo && pInfo->m_bUseOOXMLCurve) // Routing method OOXML + { + // The additional points needed are located on the segments of the path of the + // corresponding bentConnector as calculated above. + auto SegmentPoint = [&aXP1](const sal_uInt16& nEnd, const double& fFactor) { + return Point( + aXP1[nEnd - 1].X() + FRound(fFactor * (aXP1[nEnd].X() - aXP1[nEnd - 1].X())), + aXP1[nEnd - 1].Y() + FRound(fFactor * (aXP1[nEnd].Y() - aXP1[nEnd - 1].Y()))); + }; + + // We change the path going from end to start. Thus inserting points does not affect the index + // of the preceding points. + // The end point has index nPointCount-1 and is a normal point and kept. + // Insert new control point in the middle of last segments. + Point aControl = SegmentPoint(nPointCount - 1, 0.5); + // Insert happens before specified index. + aXP1.Insert(nPointCount - 1, aControl, PolyFlags::Control); + for (sal_uInt16 nSegment = nPointCount - 2; nSegment > 1; --nSegment) + { + // We need a normal point at center of segment and control points at 1/4 and 3/4 of + // segment. At center and 1/4 are new points, at 3/4 will be replacement for the end + // point of the segment. + aControl = SegmentPoint(nSegment, 0.25); + Point aNormal = SegmentPoint(nSegment, 0.5); + aXP1.SetFlags(nSegment, PolyFlags::Control); + aXP1[nSegment] = SegmentPoint(nSegment, 0.75); + aXP1.Insert(nSegment, aNormal, PolyFlags::Normal); + aXP1.Insert(nSegment, aControl, PolyFlags::Control); + } + // The first segments needs a control point in the middle. It is replacement for the + // second point. + aXP1.SetFlags(1, PolyFlags::Control); + aXP1[1] = SegmentPoint(1, 0.5); + } + else // Routing method LO + { + Point* pPt1=&aXP1[0]; + Point* pPt2=&aXP1[1]; + Point* pPt3=&aXP1[nPointCount-2]; + Point* pPt4=&aXP1[nPointCount-1]; + tools::Long dx1=pPt2->X()-pPt1->X(); + tools::Long dy1=pPt2->Y()-pPt1->Y(); + tools::Long dx2=pPt3->X()-pPt4->X(); + tools::Long dy2=pPt3->Y()-pPt4->Y(); + if (cForm=='L') { // nPointCount==3 + aXP1.SetFlags(1,PolyFlags::Control); + Point aPt3(*pPt2); + aXP1.Insert(2,aPt3,PolyFlags::Control); + nPointCount=aXP1.GetPointCount(); + pPt2=&aXP1[1]; + pPt3=&aXP1[nPointCount-2]; + pPt2->AdjustX( -(dx1/3) ); + pPt2->AdjustY( -(dy1/3) ); + pPt3->AdjustX( -(dx2/3) ); + pPt3->AdjustY( -(dy2/3) ); + } else if (nPointCount>=4 && nPointCount<=6) { // Z or U or ... + // To all others, the end points of the original lines become control + // points for now. Thus, we need to do some more work for nPointCount>4! + aXP1.SetFlags(1,PolyFlags::Control); + aXP1.SetFlags(nPointCount-2,PolyFlags::Control); + // distance x1.5 + pPt2->AdjustX(dx1/2 ); + pPt2->AdjustY(dy1/2 ); + pPt3->AdjustX(dx2/2 ); + pPt3->AdjustY(dy2/2 ); + if (nPointCount==5) { + // add a control point before and after center + Point aCenter(aXP1[2]); + tools::Long dx1b=aCenter.X()-aXP1[1].X(); + tools::Long dy1b=aCenter.Y()-aXP1[1].Y(); + tools::Long dx2b=aCenter.X()-aXP1[3].X(); + tools::Long dy2b=aCenter.Y()-aXP1[3].Y(); + aXP1.Insert(2,aCenter,PolyFlags::Control); + aXP1.SetFlags(3,PolyFlags::Symmetric); + aXP1.Insert(4,aCenter,PolyFlags::Control); + aXP1[2].AdjustX( -(dx1b/2) ); + aXP1[2].AdjustY( -(dy1b/2) ); + aXP1[3].AdjustX( -((dx1b+dx2b)/4) ); + aXP1[3].AdjustY( -((dy1b+dy2b)/4) ); + aXP1[4].AdjustX( -(dx2b/2) ); + aXP1[4].AdjustY( -(dy2b/2) ); + } + if (nPointCount==6) { + Point aPt1b(aXP1[2]); + Point aPt2b(aXP1[3]); + aXP1.Insert(2,aPt1b,PolyFlags::Control); + aXP1.Insert(5,aPt2b,PolyFlags::Control); + tools::Long dx=aPt1b.X()-aPt2b.X(); + tools::Long dy=aPt1b.Y()-aPt2b.Y(); + aXP1[3].AdjustX( -(dx/2) ); + aXP1[3].AdjustY( -(dy/2) ); + aXP1.SetFlags(3,PolyFlags::Symmetric); + aXP1.Remove(4,1); // because it's identical with aXP1[3] + } + } + } + return aXP1; +} + +/* +There could be a maximum of 64 different developments with 5 lines, a +maximum of 32 developments with 4 lines, a maximum of 16 developments with +3 lines, a maximum of 8 developments with 2 lines. +This gives us a total of 124 possibilities. +Normalized for the 1st exit angle to the right, there remain 31 possibilities. +Now, normalizing away the vertical mirroring, we get to a total of 16 +characteristic developments with 1 through 5 lines: + +1 line (type "I") -- + +2 lines (type "L") __| + +3 lines (type "U") __ (type "Z") _ + __| _| + _ _ +4 lines #1 _| #2 | | #3 |_ #4 | | + _| _| _| _| + Of these, #1 is implausible, #2 is a rotated version of #3. This leaves + #2 (from now on referred to as 4.1) and #4 (from now on referred to as 4.2). + _ _ +5 lines #1 _| #2 _| #3 ___ #4 _ + _| _| _| _| _| |_ + _ _ _ + #5 |_ #6 |_ #7 _| | #8 ____ + _| _| _| |_ _| + Of these, 5.1, 5.2, 5.4 and 5.5 are implausible, 5.7 is a reversed version + of 5.3. This leaves 5.3 (type "4"), 5.6 (type "S") and 5.8 (type "C"). + +We now have discerned the 9 basic types to cover all 400 possible constellations +of object positions and exit angles. 4 of the 9 types have got a center +line (CL). The number of object margins per object varies between 0 and 3: + + CL O1 O2 Note +"I": n 0 0 +"L": n 0 0 +"U": n 0-1 0-1 +"Z": y 0 0 +4.2: y 0 1 = U+1, respectively 1+U +4.4: n 0-2 0-2 = Z+1 +"4": y 0 2 = Z+2 +"S": y 1 1 = 1+Z+1 +"C": n 0-3 0-3 = 1+U+1 +*/ + +void SdrEdgeObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + const SfxHintId nId = rHint.GetId(); + bool bDataChg=nId==SfxHintId::DataChanged; + bool bDying=nId==SfxHintId::Dying; + bool bObj1=m_aCon1.m_pSdrObj!=nullptr && m_aCon1.m_pSdrObj->GetBroadcaster()==&rBC; + bool bObj2=m_aCon2.m_pSdrObj!=nullptr && m_aCon2.m_pSdrObj->GetBroadcaster()==&rBC; + if (bDying && (bObj1 || bObj2)) { + // catch Dying, so AttrObj doesn't start broadcasting + // about an alleged change of template + if (bObj1) m_aCon1.m_pSdrObj=nullptr; + if (bObj2) m_aCon2.m_pSdrObj=nullptr; + return; + } + if ( bObj1 || bObj2 ) + { + m_bEdgeTrackUserDefined = false; + } + SdrTextObj::Notify(rBC,rHint); + if (m_nNotifyingCount!=0)return; + +// a locking flag + m_nNotifyingCount++; + const SdrHint* pSdrHint = ( rHint.GetId() == SfxHintId::ThisIsAnSdrHint ? static_cast(&rHint) : nullptr ); + + if (bDataChg) { // StyleSheet changed + ImpSetAttrToEdgeInfo(); // when changing templates, copy values from Pool to aEdgeInfo + } + if (bDataChg || + (bObj1 && m_aCon1.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()) || + (bObj2 && m_aCon2.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()) || + (pSdrHint && pSdrHint->GetKind()==SdrHintKind::ObjectRemoved)) + { + // broadcasting only, if on the same page + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetCurrentBoundRect(); + ImpDirtyEdgeTrack(); + + // only redraw here, object hasn't actually changed + ActionChanged(); + + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } + m_nNotifyingCount--; +} + +/** updates edges that are connected to the edges of this object + as if the connected objects sent a repaint broadcast +*/ +void SdrEdgeObj::Reformat() +{ + if( nullptr != m_aCon1.m_pSdrObj ) + { + SfxHint aHint( SfxHintId::DataChanged ); + Notify( *const_cast(m_aCon1.m_pSdrObj->GetBroadcaster()), aHint ); + } + + if( nullptr != m_aCon2.m_pSdrObj ) + { + SfxHint aHint( SfxHintId::DataChanged ); + Notify( *const_cast(m_aCon2.m_pSdrObj->GetBroadcaster()), aHint ); + } +} + +rtl::Reference SdrEdgeObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrEdgeObj(rTargetModel, *this); +} + +OUString SdrEdgeObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulEDGE)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + return sName; +} + +OUString SdrEdgeObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralEDGE); +} + +basegfx::B2DPolyPolygon SdrEdgeObj::TakeXorPoly() const +{ + basegfx::B2DPolyPolygon aPolyPolygon; + + if (m_bEdgeTrackDirty) + { + const_cast(this)->ImpRecalcEdgeTrack(); + } + + if(m_pEdgeTrack) + { + aPolyPolygon.append(m_pEdgeTrack->getB2DPolygon()); + } + + return aPolyPolygon; +} + +void SdrEdgeObj::SetEdgeTrackPath( const basegfx::B2DPolyPolygon& rPoly ) +{ + if ( !rPoly.count() ) + { + m_bEdgeTrackDirty = true; + m_bEdgeTrackUserDefined = false; + } + else + { + *m_pEdgeTrack = XPolygon( rPoly.getB2DPolygon( 0 ) ); + m_bEdgeTrackDirty = false; + m_bEdgeTrackUserDefined = true; + + // #i110629# also set aRect and maSnapeRect depending on pEdgeTrack + const tools::Rectangle aPolygonBounds(m_pEdgeTrack->GetBoundRect()); + setRectangle(aPolygonBounds); + maSnapRect = aPolygonBounds; + } +} + +basegfx::B2DPolyPolygon SdrEdgeObj::GetEdgeTrackPath() const +{ + basegfx::B2DPolyPolygon aPolyPolygon; + + if (m_bEdgeTrackDirty) + const_cast(this)->ImpRecalcEdgeTrack(); + + aPolyPolygon.append( m_pEdgeTrack->getB2DPolygon() ); + + return aPolyPolygon; +} + +sal_uInt32 SdrEdgeObj::GetHdlCount() const +{ + SdrEdgeKind eKind=GetObjectItem(SDRATTR_EDGEKIND).GetValue(); + sal_uInt32 nHdlCnt(0); + sal_uInt32 nPointCount(m_pEdgeTrack->GetPointCount()); + + if(nPointCount) + { + nHdlCnt = 2; + if ((eKind==SdrEdgeKind::OrthoLines || eKind==SdrEdgeKind::Bezier) && nPointCount >= 4) + { + sal_uInt32 nO1(m_aEdgeInfo.m_nObj1Lines > 0 ? m_aEdgeInfo.m_nObj1Lines - 1 : 0); + sal_uInt32 nO2(m_aEdgeInfo.m_nObj2Lines > 0 ? m_aEdgeInfo.m_nObj2Lines - 1 : 0); + sal_uInt32 nM(m_aEdgeInfo.m_nMiddleLine != 0xFFFF ? 1 : 0); + nHdlCnt += nO1 + nO2 + nM; + } + else if (eKind==SdrEdgeKind::ThreeLines && nPointCount == 4) + { + if(GetConnectedNode(true)) + nHdlCnt++; + + if(GetConnectedNode(false)) + nHdlCnt++; + } + } + + return nHdlCnt; +} + +void SdrEdgeObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + sal_uInt32 nPointCount(m_pEdgeTrack->GetPointCount()); + if (nPointCount==0) + return; + + { + std::unique_ptr pHdl(new ImpEdgeHdl((*m_pEdgeTrack)[0],SdrHdlKind::Poly)); + if (m_aCon1.m_pSdrObj!=nullptr && m_aCon1.m_bBestVertex) pHdl->Set1PixMore(); + pHdl->SetPointNum(0); + rHdlList.AddHdl(std::move(pHdl)); + } + { + std::unique_ptr pHdl(new ImpEdgeHdl((*m_pEdgeTrack)[sal_uInt16(nPointCount-1)],SdrHdlKind::Poly)); + if (m_aCon2.m_pSdrObj!=nullptr && m_aCon2.m_bBestVertex) pHdl->Set1PixMore(); + pHdl->SetPointNum(1); + rHdlList.AddHdl(std::move(pHdl)); + } + { + SdrEdgeKind eKind=GetObjectItem(SDRATTR_EDGEKIND).GetValue(); + if ((eKind==SdrEdgeKind::OrthoLines || eKind==SdrEdgeKind::Bezier) && nPointCount >= 4) + { + sal_uInt32 nO1(m_aEdgeInfo.m_nObj1Lines > 0 ? m_aEdgeInfo.m_nObj1Lines - 1 : 0); + sal_uInt32 nO2(m_aEdgeInfo.m_nObj2Lines > 0 ? m_aEdgeInfo.m_nObj2Lines - 1 : 0); + sal_uInt32 nM(m_aEdgeInfo.m_nMiddleLine != 0xFFFF ? 1 : 0); + bool bOOXMLCurve = m_aEdgeInfo.m_bUseOOXMLCurve && eKind == SdrEdgeKind::Bezier; + for(sal_uInt32 i = 0; i < (nO1 + nO2 + nM); ++i) + { + sal_Int32 nPt(0); + sal_uInt32 nNum = i; + std::unique_ptr pHdl(new ImpEdgeHdl(Point(),SdrHdlKind::Poly)); + if (nNumSetLineCode(SdrEdgeLineCode::Obj1Line2); + if (nNum==1) pHdl->SetLineCode(SdrEdgeLineCode::Obj1Line3); + } else { + nNum=nNum-nO1; + if (nNumSetLineCode(SdrEdgeLineCode::Obj2Line2); + if (nNum==1) pHdl->SetLineCode(SdrEdgeLineCode::Obj2Line3); + } else { + nNum=nNum-nO2; + if (nNumSetLineCode(SdrEdgeLineCode::MiddleLine); + } + } + } + if (nPt>0) + { + if (bOOXMLCurve) + { + Point aPos((*m_pEdgeTrack)[static_cast(nPt)]); + pHdl->SetPos(aPos); + } + else + { + Point aPos((*m_pEdgeTrack)[static_cast(nPt)]); + aPos+=(*m_pEdgeTrack)[static_cast(nPt)+1]; + aPos.setX( aPos.X() / 2 ); + aPos.setY( aPos.Y() / 2 ); + pHdl->SetPos(aPos); + } + pHdl->SetPointNum(i + 2); + rHdlList.AddHdl(std::move(pHdl)); + } + } + } + else if (eKind==SdrEdgeKind::ThreeLines && nPointCount == 4) + { + if(GetConnectedNode(true)) + { + Point aPos((*m_pEdgeTrack)[1]); + std::unique_ptr pHdl(new ImpEdgeHdl(aPos,SdrHdlKind::Poly)); + pHdl->SetLineCode(SdrEdgeLineCode::Obj1Line2); + pHdl->SetPointNum(2); + rHdlList.AddHdl(std::move(pHdl)); + } + if(GetConnectedNode(false)) + { + Point aPos((*m_pEdgeTrack)[2]); + std::unique_ptr pHdl(new ImpEdgeHdl(aPos,SdrHdlKind::Poly)); + pHdl->SetLineCode(SdrEdgeLineCode::Obj2Line2); + pHdl->SetPointNum(3); + rHdlList.AddHdl(std::move(pHdl)); + } + } + } +} + +bool SdrEdgeObj::hasSpecialDrag() const +{ + return true; +} + +rtl::Reference SdrEdgeObj::getFullDragClone() const +{ + // use Clone operator + rtl::Reference pRetval = SdrObject::Clone(*this, getSdrModelFromSdrObject()); + + // copy connections for clone, SdrEdgeObj::operator= does not do this + pRetval->ConnectToNode(true, GetConnectedNode(true)); + pRetval->ConnectToNode(false, GetConnectedNode(false)); + + return pRetval; +} + +bool SdrEdgeObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + if(!rDrag.GetHdl()) + return false; + + rDrag.SetEndDragChangesAttributes(true); + + if(rDrag.GetHdl()->GetPointNum() < 2) + { + rDrag.SetNoSnap(); + } + + return true; +} + +bool SdrEdgeObj::applySpecialDrag(SdrDragStat& rDragStat) +{ + SdrEdgeObj* pOriginalEdge = dynamic_cast< SdrEdgeObj* >(rDragStat.GetHdl()->GetObj()); + const bool bOriginalEdgeModified(pOriginalEdge == this); + + if(!bOriginalEdgeModified && pOriginalEdge) + { + // copy connections when clone is modified. This is needed because + // as preparation to this modification the data from the original object + // was copied to the clone using the operator=. As can be seen there, + // that operator does not copy the connections (for good reason) + ConnectToNode(true, pOriginalEdge->GetConnection(true).GetSdrObject()); + ConnectToNode(false, pOriginalEdge->GetConnection(false).GetSdrObject()); + } + + if(rDragStat.GetHdl()->GetPointNum() < 2) + { + // start or end point connector drag + const bool bDragA(0 == rDragStat.GetHdl()->GetPointNum()); + const Point aPointNow(rDragStat.GetNow()); + + rDragStat.SetEndDragChangesGeoAndAttributes(true); + + if(rDragStat.GetPageView()) + { + SdrObjConnection* pDraggedOne(bDragA ? &m_aCon1 : &m_aCon2); + + // clear connection + DisconnectFromNode(bDragA); + + // look for new connection + ImpFindConnector(aPointNow, *rDragStat.GetPageView(), *pDraggedOne, pOriginalEdge, nullptr, &rDragStat); + + if(pDraggedOne->m_pSdrObj) + { + // if found, officially connect to it; ImpFindConnector only + // sets pObj hard + SdrObject* pNewConnection = pDraggedOne->m_pSdrObj; + pDraggedOne->m_pSdrObj = nullptr; + ConnectToNode(bDragA, pNewConnection); + } + + if(rDragStat.GetView() && !bOriginalEdgeModified) + { + // show IA helper, but only do this during IA, so not when the original + // Edge gets modified in the last call + rDragStat.GetView()->SetConnectMarker(*pDraggedOne); + } + } + + if(m_pEdgeTrack) + { + // change pEdgeTrack to modified position + if(bDragA) + { + (*m_pEdgeTrack)[0] = aPointNow; + } + else + { + (*m_pEdgeTrack)[sal_uInt16(m_pEdgeTrack->GetPointCount()-1)] = aPointNow; + } + } + + // reset edge info's offsets, this is an end point drag + m_aEdgeInfo.m_aObj1Line2 = Point(); + m_aEdgeInfo.m_aObj1Line3 = Point(); + m_aEdgeInfo.m_aObj2Line2 = Point(); + m_aEdgeInfo.m_aObj2Line3 = Point(); + m_aEdgeInfo.m_aMiddleLine = Point(); + } + else + { + // control point connector drag + const ImpEdgeHdl* pEdgeHdl = static_cast(rDragStat.GetHdl()); + const SdrEdgeLineCode eLineCode = pEdgeHdl->GetLineCode(); + const Point aDist(rDragStat.GetNow() - rDragStat.GetStart()); + sal_Int32 nDist(pEdgeHdl->IsHorzDrag() ? aDist.X() : aDist.Y()); + + nDist += m_aEdgeInfo.ImpGetLineOffset(eLineCode, *m_pEdgeTrack); + m_aEdgeInfo.ImpSetLineOffset(eLineCode, *m_pEdgeTrack, nDist); + } + + // force recalculation of EdgeTrack + *m_pEdgeTrack = ImpCalcEdgeTrack(*m_pEdgeTrack, m_aCon1, m_aCon2, &m_aEdgeInfo); + m_bEdgeTrackDirty=false; + + // save EdgeInfos and mark object as user modified + ImpSetEdgeInfoToAttr(); + m_bEdgeTrackUserDefined = false; + + SetBoundAndSnapRectsDirty(); + + if(bOriginalEdgeModified && rDragStat.GetView()) + { + // hide connect marker helper again when original gets changed. + // This happens at the end of the interaction + rDragStat.GetView()->HideConnectMarker(); + } + + return true; +} + +OUString SdrEdgeObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment) + { + return OUString(); + } + else + { + return ImpGetDescriptionStr(STR_DragEdgeTail); + } +} + + +basegfx::B2DPolygon SdrEdgeObj::ImplAddConnectorOverlay(const SdrDragMethod& rDragMethod, bool bTail1, bool bTail2, bool bDetail) const +{ + basegfx::B2DPolygon aResult; + + if(bDetail) + { + SdrObjConnection aMyCon1(m_aCon1); + SdrObjConnection aMyCon2(m_aCon2); + + if (bTail1) + { + const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon1.m_aObjOfs.X(), aMyCon1.m_aObjOfs.Y())); + aMyCon1.m_aObjOfs.setX( basegfx::fround(aTemp.getX()) ); + aMyCon1.m_aObjOfs.setY( basegfx::fround(aTemp.getY()) ); + } + + if (bTail2) + { + const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aMyCon2.m_aObjOfs.X(), aMyCon2.m_aObjOfs.Y())); + aMyCon2.m_aObjOfs.setX( basegfx::fround(aTemp.getX()) ); + aMyCon2.m_aObjOfs.setY( basegfx::fround(aTemp.getY()) ); + } + + SdrEdgeInfoRec aInfo(m_aEdgeInfo); + XPolygon aXP(ImpCalcEdgeTrack(*m_pEdgeTrack, aMyCon1, aMyCon2, &aInfo)); + + if(aXP.GetPointCount()) + { + aResult = aXP.getB2DPolygon(); + } + } + else + { + Point aPt1((*m_pEdgeTrack)[0]); + Point aPt2((*m_pEdgeTrack)[sal_uInt16(m_pEdgeTrack->GetPointCount() - 1)]); + + if (m_aCon1.m_pSdrObj && (m_aCon1.m_bBestConn || m_aCon1.m_bBestVertex)) + aPt1 = m_aCon1.m_pSdrObj->GetSnapRect().Center(); + + if (m_aCon2.m_pSdrObj && (m_aCon2.m_bBestConn || m_aCon2.m_bBestVertex)) + aPt2 = m_aCon2.m_pSdrObj->GetSnapRect().Center(); + + if (bTail1) + { + const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt1.X(), aPt1.Y())); + aPt1.setX( basegfx::fround(aTemp.getX()) ); + aPt1.setY( basegfx::fround(aTemp.getY()) ); + } + + if (bTail2) + { + const basegfx::B2DPoint aTemp(rDragMethod.getCurrentTransformation() * basegfx::B2DPoint(aPt2.X(), aPt2.Y())); + aPt2.setX( basegfx::fround(aTemp.getX()) ); + aPt2.setY( basegfx::fround(aTemp.getY()) ); + } + + aResult.append(basegfx::B2DPoint(aPt1.X(), aPt1.Y())); + aResult.append(basegfx::B2DPoint(aPt2.X(), aPt2.Y())); + } + + return aResult; +} + +bool SdrEdgeObj::BegCreate(SdrDragStat& rDragStat) +{ + rDragStat.SetNoSnap(); + m_pEdgeTrack->SetPointCount(2); + (*m_pEdgeTrack)[0]=rDragStat.GetStart(); + (*m_pEdgeTrack)[1]=rDragStat.GetNow(); + if (rDragStat.GetPageView()!=nullptr) { + ImpFindConnector(rDragStat.GetStart(),*rDragStat.GetPageView(),m_aCon1,this); + ConnectToNode(true,m_aCon1.m_pSdrObj); + } + *m_pEdgeTrack=ImpCalcEdgeTrack(*m_pEdgeTrack,m_aCon1,m_aCon2,&m_aEdgeInfo); + return true; +} + +bool SdrEdgeObj::MovCreate(SdrDragStat& rDragStat) +{ + sal_uInt16 nMax=m_pEdgeTrack->GetPointCount(); + (*m_pEdgeTrack)[nMax-1]=rDragStat.GetNow(); + if (rDragStat.GetPageView()!=nullptr) { + ImpFindConnector(rDragStat.GetNow(),*rDragStat.GetPageView(),m_aCon2,this); + rDragStat.GetView()->SetConnectMarker(m_aCon2); + } + SetBoundRectDirty(); + m_bSnapRectDirty=true; + ConnectToNode(false,m_aCon2.m_pSdrObj); + *m_pEdgeTrack=ImpCalcEdgeTrack(*m_pEdgeTrack,m_aCon1,m_aCon2,&m_aEdgeInfo); + m_bEdgeTrackDirty=false; + return true; +} + +bool SdrEdgeObj::EndCreate(SdrDragStat& rDragStat, SdrCreateCmd eCmd) +{ + bool bOk=(eCmd==SdrCreateCmd::ForceEnd || rDragStat.GetPointCount()>=2); + if (bOk) { + ConnectToNode(true,m_aCon1.m_pSdrObj); + ConnectToNode(false,m_aCon2.m_pSdrObj); + if (rDragStat.GetView()!=nullptr) { + rDragStat.GetView()->HideConnectMarker(); + } + ImpSetEdgeInfoToAttr(); // copy values from aEdgeInfo into the pool + } + SetBoundAndSnapRectsDirty(); + return bOk; +} + +bool SdrEdgeObj::BckCreate(SdrDragStat& rDragStat) +{ + if (rDragStat.GetView()!=nullptr) { + rDragStat.GetView()->HideConnectMarker(); + } + return false; +} + +void SdrEdgeObj::BrkCreate(SdrDragStat& rDragStat) +{ + if (rDragStat.GetView()!=nullptr) { + rDragStat.GetView()->HideConnectMarker(); + } +} + +basegfx::B2DPolyPolygon SdrEdgeObj::TakeCreatePoly(const SdrDragStat& /*rStatDrag*/) const +{ + basegfx::B2DPolyPolygon aRetval; + aRetval.append(m_pEdgeTrack->getB2DPolygon()); + return aRetval; +} + +PointerStyle SdrEdgeObj::GetCreatePointer() const +{ + return PointerStyle::DrawConnect; +} + +bool SdrEdgeObj::ImpFindConnector(const Point& rPt, const SdrPageView& rPV, SdrObjConnection& rCon, const SdrEdgeObj* pThis, OutputDevice* pOut, SdrDragStat* pDragStat) +{ + rCon.ResetVars(); + if (pOut==nullptr) pOut=rPV.GetView().GetFirstOutputDevice(); + if (pOut==nullptr) return false; + SdrObjList* pOL=rPV.GetObjList(); + const SdrLayerIDSet& rVisLayer=rPV.GetVisibleLayers(); + // sensitive area of connectors is twice as large as the one of the handles + sal_uInt16 nMarkHdSiz=rPV.GetView().GetMarkHdlSizePixel(); + Size aHalfConSiz(nMarkHdSiz,nMarkHdSiz); + if (comphelper::LibreOfficeKit::isActive() && pOut->GetMapMode().GetMapUnit() == MapUnit::Map100thMM) + aHalfConSiz=pOut->PixelToLogic(aHalfConSiz, MapMode(MapUnit::Map100thMM)); + else + aHalfConSiz=pOut->PixelToLogic(aHalfConSiz); + tools::Rectangle aMouseRect(rPt,rPt); + aMouseRect.AdjustLeft( -(aHalfConSiz.Width()) ); + aMouseRect.AdjustTop( -(aHalfConSiz.Height()) ); + aMouseRect.AdjustRight(aHalfConSiz.Width() ); + aMouseRect.AdjustBottom(aHalfConSiz.Height() ); + double fBoundHitTol=static_cast(aHalfConSiz.Width())/2; if (fBoundHitTol==0.0) fBoundHitTol=1.0; + size_t no=pOL->GetObjCount(); + bool bFnd = false; + SdrObjConnection aTestCon; + bool bTiledRendering = comphelper::LibreOfficeKit::isActive(); + bool bHasRequestedOrdNum = false; + sal_Int32 requestedOrdNum = -1; + + if (bTiledRendering && pDragStat) + { + auto& glueOptions = pDragStat->GetGlueOptions(); + if (glueOptions.objectOrdNum != -1) + { + requestedOrdNum = glueOptions.objectOrdNum; + bHasRequestedOrdNum = true; + } + } + + while (no>0 && !bFnd) { + // issue: group objects on different layers return LayerID=0! + no--; + SdrObject* pObj=pOL->GetObj(no); + if (bHasRequestedOrdNum) + { + if (pObj->GetOrdNumDirect() != static_cast(requestedOrdNum)) + continue; + } + if (rVisLayer.IsSet(pObj->GetLayer()) && pObj->IsVisible() && // only visible objects + (pThis==nullptr || pObj!=static_cast(pThis))) // don't connect it to itself + { + tools::Rectangle aObjBound(pObj->GetCurrentBoundRect()); + if (aObjBound.Overlaps(aMouseRect)) { + aTestCon.ResetVars(); + bool bEdge=dynamic_cast(pObj) != nullptr; // no BestCon for Edge + // User-defined connectors have absolute priority. + // After those come Vertex, Corner and center (Best), all prioritized equally. + // Finally, a HitTest for the object. + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + sal_uInt16 nGluePointCnt=pGPL==nullptr ? 0 : pGPL->GetCount(); + sal_uInt16 nGesAnz=nGluePointCnt+9; + bool bUserFnd = false; + sal_uIntPtr nBestDist=0xFFFFFFFF; + for (sal_uInt16 i=0; i=nGluePointCnt+0 && i=nGluePointCnt+4 && iGetVertexGluePoint(nConNum)); + aConPos=aPt.GetAbsolutePos(*pObj); + bOk = true; + } else if (bCorner && !bUserFnd) { + nConNum-=nGluePointCnt+4; + i+=3; + } + else if (bCenter && !bUserFnd && !bEdge) + { + // Suppress default connect at object center + if(!pThis || !pThis->GetSuppressDefaultConnect()) + { + // not the edges! + nConNum=0; + aConPos=aObjBound.Center(); + bOk = true; + } + } + if (bOk && aMouseRect.Contains(aConPos)) { + if (bUser) bUserFnd = true; + bFnd = true; + sal_uIntPtr nDist=static_cast(std::abs(aConPos.X()-rPt.X()))+static_cast(std::abs(aConPos.Y()-rPt.Y())); + if (nDistGetSuppressDefaultConnect()) + { + bFnd = true; + aTestCon.m_pSdrObj=pObj; + aTestCon.m_bBestConn=true; + } + } + if (bFnd) { + aMouseRect.AdjustLeft( -fBoundHitTol ); + aMouseRect.AdjustTop( -fBoundHitTol ); + aMouseRect.AdjustRight(fBoundHitTol ); + aMouseRect.AdjustBottom(fBoundHitTol ); + } + + } + } + } + rCon=aTestCon; + return bFnd; +} + +void SdrEdgeObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + const tools::Rectangle aOld(GetSnapRect()); + + if(aOld == rRect) + return; + + if (getRectangle().IsEmpty() && 0 == m_pEdgeTrack->GetPointCount()) + { + // #i110629# When initializing, do not scale on empty Rectangle; this + // will mirror the underlying text object (!) + setRectangle(rRect); + maSnapRect = rRect; + } + else + { + tools::Long nMulX = rRect.Right() - rRect.Left(); + tools::Long nDivX = aOld.Right() - aOld.Left(); + tools::Long nMulY = rRect.Bottom() - rRect.Top(); + tools::Long nDivY = aOld.Bottom() - aOld.Top(); + if ( nDivX == 0 ) { nMulX = 1; nDivX = 1; } + if ( nDivY == 0 ) { nMulY = 1; nDivY = 1; } + Fraction aX(nMulX, nDivX); + Fraction aY(nMulY, nDivY); + NbcResize(aOld.TopLeft(), aX, aY); + NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top())); + } +} + +void SdrEdgeObj::NbcMove(const Size& rSiz) +{ + SdrTextObj::NbcMove(rSiz); + MoveXPoly(*m_pEdgeTrack,rSiz); +} + +void SdrEdgeObj::NbcResize(const Point& rRefPnt, const Fraction& aXFact, const Fraction& aYFact) +{ + SdrTextObj::NbcResize(rRefPnt,aXFact,aXFact); + ResizeXPoly(*m_pEdgeTrack,rRefPnt,aXFact,aYFact); + + // if resize is not from paste, forget user distances + if (!getSdrModelFromSdrObject().IsPasteResize()) + { + m_aEdgeInfo.m_aObj1Line2 = Point(); + m_aEdgeInfo.m_aObj1Line3 = Point(); + m_aEdgeInfo.m_aObj2Line2 = Point(); + m_aEdgeInfo.m_aObj2Line3 = Point(); + m_aEdgeInfo.m_aMiddleLine = Point(); + } +} + +// #i54102# added rotation support +void SdrEdgeObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + if(m_bEdgeTrackUserDefined) + { + // #i120437# special handling when track is imported, apply + // transformation directly to imported track. + SdrTextObj::NbcRotate(rRef, nAngle, sn, cs); + RotateXPoly(*m_pEdgeTrack, rRef, sn, cs); + } + else + { + // handle start and end point if not connected + const bool bCon1(nullptr != m_aCon1.m_pSdrObj && m_aCon1.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + const bool bCon2(nullptr != m_aCon2.m_pSdrObj && m_aCon2.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + + if(!bCon1 && m_pEdgeTrack) + { + RotatePoint((*m_pEdgeTrack)[0],rRef,sn,cs); + ImpDirtyEdgeTrack(); + } + + if(!bCon2 && m_pEdgeTrack) + { + sal_uInt16 nPointCount = m_pEdgeTrack->GetPointCount(); + RotatePoint((*m_pEdgeTrack)[sal_uInt16(nPointCount-1)],rRef,sn,cs); + ImpDirtyEdgeTrack(); + } + } +} + +// #i54102# added mirror support +void SdrEdgeObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + if(m_bEdgeTrackUserDefined) + { + // #i120437# special handling when track is imported, apply + // transformation directly to imported track. + SdrTextObj::NbcMirror(rRef1, rRef2); + MirrorXPoly(*m_pEdgeTrack, rRef1, rRef2); + } + else + { + // handle start and end point if not connected + const bool bCon1(nullptr != m_aCon1.m_pSdrObj && m_aCon1.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + const bool bCon2(nullptr != m_aCon2.m_pSdrObj && m_aCon2.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + + if(!bCon1 && m_pEdgeTrack) + { + MirrorPoint((*m_pEdgeTrack)[0],rRef1,rRef2); + ImpDirtyEdgeTrack(); + } + + if(!bCon2 && m_pEdgeTrack) + { + sal_uInt16 nPointCount = m_pEdgeTrack->GetPointCount(); + MirrorPoint((*m_pEdgeTrack)[sal_uInt16(nPointCount-1)],rRef1,rRef2); + ImpDirtyEdgeTrack(); + } + } +} + +// #i54102# added shear support +void SdrEdgeObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + if(m_bEdgeTrackUserDefined) + { + // #i120437# special handling when track is imported, apply + // transformation directly to imported track. + SdrTextObj::NbcShear(rRef, nAngle, tn, bVShear); + ShearXPoly(*m_pEdgeTrack, rRef, tn, bVShear); + } + else + { + // handle start and end point if not connected + const bool bCon1(nullptr != m_aCon1.m_pSdrObj && m_aCon1.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + const bool bCon2(nullptr != m_aCon2.m_pSdrObj && m_aCon2.m_pSdrObj->getSdrPageFromSdrObject() == getSdrPageFromSdrObject()); + + if(!bCon1 && m_pEdgeTrack) + { + ShearPoint((*m_pEdgeTrack)[0],rRef,tn,bVShear); + ImpDirtyEdgeTrack(); + } + + if(!bCon2 && m_pEdgeTrack) + { + sal_uInt16 nPointCount = m_pEdgeTrack->GetPointCount(); + ShearPoint((*m_pEdgeTrack)[sal_uInt16(nPointCount-1)],rRef,tn,bVShear); + ImpDirtyEdgeTrack(); + } + } +} + +rtl::Reference SdrEdgeObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + basegfx::B2DPolyPolygon aPolyPolygon; + aPolyPolygon.append(m_pEdgeTrack->getB2DPolygon()); + rtl::Reference pRet = ImpConvertMakeObj(aPolyPolygon, false, bBezier); + + if(bAddText) + { + pRet = ImpConvertAddText(std::move(pRet), bBezier); + } + + return pRet; +} + +sal_uInt32 SdrEdgeObj::GetSnapPointCount() const +{ + return 2; +} + +Point SdrEdgeObj::GetSnapPoint(sal_uInt32 i) const +{ + const_cast(this)->ImpUndirtyEdgeTrack(); + sal_uInt16 nCount=m_pEdgeTrack->GetPointCount(); + if (i==0) return (*m_pEdgeTrack)[0]; + else return (*m_pEdgeTrack)[nCount-1]; +} + +bool SdrEdgeObj::IsPolyObj() const +{ + return false; +} + +sal_uInt32 SdrEdgeObj::GetPointCount() const +{ + return 0; +} + +Point SdrEdgeObj::GetPoint(sal_uInt32 i) const +{ + const_cast(this)->ImpUndirtyEdgeTrack(); + sal_uInt16 nCount=m_pEdgeTrack->GetPointCount(); + if (0 == i) + return (*m_pEdgeTrack)[0]; + else + return (*m_pEdgeTrack)[nCount-1]; +} + +void SdrEdgeObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i) +{ + // TODO: Need an implementation to connect differently. + ImpUndirtyEdgeTrack(); + sal_uInt16 nCount=m_pEdgeTrack->GetPointCount(); + if (0 == i) + (*m_pEdgeTrack)[0]=rPnt; + if (1 == i) + (*m_pEdgeTrack)[nCount-1]=rPnt; + SetEdgeTrackDirty(); + SetBoundAndSnapRectsDirty(); +} + +SdrEdgeObjGeoData::SdrEdgeObjGeoData() + : m_pEdgeTrack(std::in_place) + , m_bEdgeTrackDirty(false) + , m_bEdgeTrackUserDefined(false) +{ +} + +SdrEdgeObjGeoData::~SdrEdgeObjGeoData() +{ +} + +std::unique_ptr SdrEdgeObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrEdgeObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrTextObj::SaveGeoData(rGeo); + SdrEdgeObjGeoData& rEGeo=static_cast(rGeo); + rEGeo.m_aCon1 =m_aCon1; + rEGeo.m_aCon2 =m_aCon2; + *rEGeo.m_pEdgeTrack =*m_pEdgeTrack; + rEGeo.m_bEdgeTrackDirty=m_bEdgeTrackDirty; + rEGeo.m_bEdgeTrackUserDefined=m_bEdgeTrackUserDefined; + rEGeo.m_aEdgeInfo =m_aEdgeInfo; +} + +void SdrEdgeObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrTextObj::RestoreGeoData(rGeo); + const SdrEdgeObjGeoData& rEGeo=static_cast(rGeo); + if (m_aCon1.m_pSdrObj!=rEGeo.m_aCon1.m_pSdrObj) { + if (m_aCon1.m_pSdrObj!=nullptr) m_aCon1.m_pSdrObj->RemoveListener(*this); + m_aCon1=rEGeo.m_aCon1; + if (m_aCon1.m_pSdrObj!=nullptr) m_aCon1.m_pSdrObj->AddListener(*this); + } + else + m_aCon1=rEGeo.m_aCon1; + + if (m_aCon2.m_pSdrObj!=rEGeo.m_aCon2.m_pSdrObj) { + if (m_aCon2.m_pSdrObj!=nullptr) m_aCon2.m_pSdrObj->RemoveListener(*this); + m_aCon2=rEGeo.m_aCon2; + if (m_aCon2.m_pSdrObj!=nullptr) m_aCon2.m_pSdrObj->AddListener(*this); + } + else + m_aCon2=rEGeo.m_aCon2; + + *m_pEdgeTrack =*rEGeo.m_pEdgeTrack; + m_bEdgeTrackDirty=rEGeo.m_bEdgeTrackDirty; + m_bEdgeTrackUserDefined=rEGeo.m_bEdgeTrackUserDefined; + m_aEdgeInfo =rEGeo.m_aEdgeInfo; +} + +Point SdrEdgeObj::GetTailPoint( bool bTail ) const +{ + if( m_pEdgeTrack && m_pEdgeTrack->GetPointCount()!=0) + { + const XPolygon& rTrack0 = *m_pEdgeTrack; + if(bTail) + { + return rTrack0[0]; + } + else + { + const sal_uInt16 nSiz = rTrack0.GetPointCount() - 1; + return rTrack0[nSiz]; + } + } + else + { + if(bTail) + return getOutRectangle().TopLeft(); + else + return getOutRectangle().BottomRight(); + } + +} + +void SdrEdgeObj::SetTailPoint( bool bTail, const Point& rPt ) +{ + ImpSetTailPoint( bTail, rPt ); + SetChanged(); +} + +/** this method is used by the api to set a gluepoint for a connection + nId == -1 : The best default point is automatically chosen + 0 <= nId <= 3 : One of the default points is chosen + nId >= 4 : A user defined gluepoint is chosen +*/ +void SdrEdgeObj::setGluePointIndex( bool bTail, sal_Int32 nIndex /* = -1 */ ) +{ + SdrObjConnection& rConn1 = GetConnection( bTail ); + + rConn1.SetAutoVertex( nIndex >= 0 && nIndex <= 3 ); + rConn1.SetBestConnection( nIndex < 0 ); + rConn1.SetBestVertex( nIndex < 0 ); + + if( nIndex > 3 ) + { + nIndex -= 3; // the start api index is 0, whereas the implementation in svx starts from 1 + + // for user defined gluepoints we have + // to get the id for this index first + const SdrGluePointList* pList = rConn1.GetSdrObject() ? rConn1.GetSdrObject()->GetGluePointList() : nullptr; + if( pList == nullptr || SDRGLUEPOINT_NOTFOUND == pList->FindGluePoint(static_cast(nIndex)) ) + return; + } + else if( nIndex < 0 ) + { + nIndex = 0; + } + + rConn1.SetConnectorId( static_cast(nIndex) ); + + SetChanged(); + SetBoundAndSnapRectsDirty(); + ImpRecalcEdgeTrack(); +} + +/** this method is used by the api to return a gluepoint id for a connection. + See setGluePointId for possible return values */ +sal_Int32 SdrEdgeObj::getGluePointIndex( bool bTail ) +{ + SdrObjConnection& rConn1 = GetConnection( bTail ); + sal_Int32 nId = -1; + if( !rConn1.IsBestConnection() ) + { + nId = rConn1.GetConnectorId(); + if( !rConn1.IsAutoVertex() ) + nId += 3; // the start api index is 0, whereas the implementation in svx starts from 1 + } + return nId; +} + +// Implementation was missing; edge track needs to be invalidated additionally. +void SdrEdgeObj::NbcSetAnchorPos(const Point& rPnt) +{ + // call parent functionality + SdrTextObj::NbcSetAnchorPos(rPnt); + + // Additionally, invalidate edge track + ImpDirtyEdgeTrack(); +} + +bool SdrEdgeObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const +{ + // use base method from SdrObject, it's not rotatable and + // a call to GetSnapRect() is used. That's what we need for Connector. + return SdrObject::TRGetBaseGeometry(rMatrix, rPolyPolygon); +} + +void SdrEdgeObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + // where appropriate take care for existing connections. For now, just use the + // implementation from SdrObject. + SdrObject::TRSetBaseGeometry(rMatrix, rPolyPolygon); +} + +// for geometry access +::basegfx::B2DPolygon SdrEdgeObj::getEdgeTrack() const +{ + if(m_bEdgeTrackDirty) + { + const_cast< SdrEdgeObj* >(this)->ImpRecalcEdgeTrack(); + } + + if(m_pEdgeTrack) + { + return m_pEdgeTrack->getB2DPolygon(); + } + else + { + return ::basegfx::B2DPolygon(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdograf.cxx b/svx/source/svdraw/svdograf.cxx new file mode 100644 index 0000000000..0f7151e295 --- /dev/null +++ b/svx/source/svdraw/svdograf.cxx @@ -0,0 +1,1252 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "svdfmtf.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +class SdrGraphicLink : public sfx2::SvBaseLink +{ + SdrGrafObj& rGrafObj; + +public: + explicit SdrGraphicLink(SdrGrafObj& rObj); + + virtual void Closed() override; + + virtual ::sfx2::SvBaseLink::UpdateResult DataChanged( + const OUString& rMimeType, const uno::Any & rValue ) override; + + void Connect() { GetRealObject(); } +}; + +SdrGraphicLink::SdrGraphicLink(SdrGrafObj& rObj) +: ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB ) +, rGrafObj( rObj ) +{ + SetSynchron( false ); +} + +::sfx2::SvBaseLink::UpdateResult SdrGraphicLink::DataChanged( + const OUString& rMimeType, const uno::Any & rValue ) +{ + SdrModel& rModel(rGrafObj.getSdrModelFromSdrObject()); + sfx2::LinkManager* pLinkManager(rModel.GetLinkManager()); + + if( pLinkManager && rValue.hasValue() ) + { + sfx2::LinkManager::GetDisplayNames( this, nullptr, &rGrafObj.aFileName, nullptr, &rGrafObj.aFilterName ); + + Graphic aGraphic; + if (pLinkManager->GetGraphicFromAny(rMimeType, rValue, aGraphic, nullptr)) + { + rGrafObj.ImpSetLinkedGraphic(aGraphic); + } + else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) != sfx2::LinkManager::RegisterStatusInfoId() ) + { + // broadcasting, to update slide sorter + rGrafObj.BroadcastObjectChange(); + } + } + return SUCCESS; +} + +void SdrGraphicLink::Closed() +{ + // close connection; set pLink of the object to NULL, as link instance is just about getting destructed. + rGrafObj.ForceSwapIn(); + rGrafObj.pGraphicLink=nullptr; + rGrafObj.ReleaseGraphicLink(); + SvBaseLink::Closed(); +} + +std::unique_ptr SdrGrafObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrGrafObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +// check if SVG and if try to get ObjectInfoPrimitive2D and extract info + +void SdrGrafObj::onGraphicChanged() +{ + if (!mpGraphicObject || !mpGraphicObject->GetGraphic().isAvailable()) + return; + + auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData(); + + if (!rVectorGraphicDataPtr) + return; + + // Skip for PDF as it is only a bitmap primitive in a sequence and + // doesn't contain metadata. However getting the primitive sequence + // will also trigger a premature rendering of the PDF. + if (rVectorGraphicDataPtr->getType() == VectorGraphicDataType::Pdf) + return; + + const std::deque>& rContainer(rVectorGraphicDataPtr->getPrimitive2DSequence()); + + if (rContainer.empty()) + return; + + drawinglayer::geometry::ViewInformation2D aViewInformation2D; + drawinglayer::processor2d::ObjectInfoPrimitiveExtractor2D aProcessor(aViewInformation2D); + + aProcessor.process(rContainer); + + const drawinglayer::primitive2d::ObjectInfoPrimitive2D* pResult = aProcessor.getResult(); + + if (!pResult) + return; + + OUString aName = pResult->getName(); + OUString aTitle = pResult->getTitle(); + OUString aDesc = pResult->getDesc(); + + if(!aName.isEmpty()) + { + SetName(aName); + } + + if(!aTitle.isEmpty()) + { + SetTitle(aTitle); + } + + if(!aDesc.isEmpty()) + { + SetDescription(aDesc); + } +} + +SdrGrafObj::SdrGrafObj(SdrModel& rSdrModel) +: SdrRectObj(rSdrModel) + ,mpGraphicObject(new GraphicObject) + ,pGraphicLink(nullptr) + ,bMirrored(false) + ,mbIsSignatureLine(false) + ,mbIsSignatureLineShowSignDate(true) + ,mbIsSignatureLineCanAddComment(false) + ,mbSignatureLineIsSigned(false) +{ + onGraphicChanged(); + + // #i118485# Shear allowed and possible now + mbNoShear = false; + + mbGrafAnimationAllowed = true; + + // #i25616# + mbLineIsOutsideGeometry = true; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; +} + +SdrGrafObj::SdrGrafObj(SdrModel& rSdrModel, SdrGrafObj const & rSource) +: SdrRectObj(rSdrModel, rSource) + ,mpGraphicObject(new GraphicObject) + ,pGraphicLink(nullptr) +{ + onGraphicChanged(); + + // #i118485# Shear allowed and possible now + mbNoShear = false; + + mbGrafAnimationAllowed = true; + + // #i25616# + mbLineIsOutsideGeometry = true; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; + + aFileName = rSource.aFileName; + bMirrored = rSource.bMirrored; + + mbIsSignatureLine = rSource.mbIsSignatureLine; + maSignatureLineId = rSource.maSignatureLineId; + maSignatureLineSuggestedSignerName = rSource.maSignatureLineSuggestedSignerName; + maSignatureLineSuggestedSignerTitle = rSource.maSignatureLineSuggestedSignerTitle; + maSignatureLineSuggestedSignerEmail = rSource.maSignatureLineSuggestedSignerEmail; + maSignatureLineSigningInstructions = rSource.maSignatureLineSigningInstructions; + mbIsSignatureLineShowSignDate = rSource.mbIsSignatureLineShowSignDate; + mbIsSignatureLineCanAddComment = rSource.mbIsSignatureLineCanAddComment; + mbSignatureLineIsSigned = false; + mpSignatureLineUnsignedGraphic = rSource.mpSignatureLineUnsignedGraphic; + + if(rSource.mpBarCode) + { + mpBarCode = std::make_unique(*rSource.mpBarCode); + } + else + { + mpBarCode.reset(); + } + + if (mbIsSignatureLine && rSource.mpSignatureLineUnsignedGraphic) + mpGraphicObject->SetGraphic(rSource.mpSignatureLineUnsignedGraphic); + else + mpGraphicObject->SetGraphic( rSource.GetGraphic() ); + + if( rSource.IsLinkedGraphic() ) + { + SetGraphicLink( aFileName ); + } + + ImpSetAttrToGrafInfo(); +} + +SdrGrafObj::SdrGrafObj( + SdrModel& rSdrModel, + const Graphic& rGraphic, + const tools::Rectangle& rRect) +: SdrRectObj(rSdrModel, rRect) + ,mpGraphicObject(new GraphicObject(rGraphic)) + ,pGraphicLink(nullptr) + ,bMirrored(false) + ,mbIsSignatureLine(false) + ,mbIsSignatureLineShowSignDate(true) + ,mbIsSignatureLineCanAddComment(false) + ,mbSignatureLineIsSigned(false) +{ + onGraphicChanged(); + + // #i118485# Shear allowed and possible now + mbNoShear = false; + + mbGrafAnimationAllowed = true; + + // #i25616# + mbLineIsOutsideGeometry = true; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; +} + +SdrGrafObj::SdrGrafObj( + SdrModel& rSdrModel, + const Graphic& rGraphic) +: SdrRectObj(rSdrModel) + ,mpGraphicObject(new GraphicObject(rGraphic)) + ,pGraphicLink(nullptr) + ,bMirrored(false) + ,mbIsSignatureLine(false) + ,mbIsSignatureLineShowSignDate(true) + ,mbIsSignatureLineCanAddComment(false) + ,mbSignatureLineIsSigned(false) +{ + onGraphicChanged(); + + // #i118485# Shear allowed and possible now + mbNoShear = false; + + mbGrafAnimationAllowed = true; + + // #i25616# + mbLineIsOutsideGeometry = true; + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; +} + +SdrGrafObj::~SdrGrafObj() +{ + ImpDeregisterLink(); +} + +void SdrGrafObj::SetGraphicObject(const GraphicObject& rGraphicObject) +{ + mpGraphicObject.reset(new GraphicObject(rGraphicObject)); + mpReplacementGraphicObject.reset(); + mpGraphicObject->SetUserData(); + SetChanged(); + BroadcastObjectChange(); + onGraphicChanged(); +} + +const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const +{ + if (bForceSwapIn) + ForceSwapIn(); + return *mpGraphicObject; +} + +const GraphicObject* SdrGrafObj::GetReplacementGraphicObject() const +{ + if (!mpReplacementGraphicObject && mpGraphicObject) + { + auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData(); + + if (rVectorGraphicDataPtr) + { + const_cast< SdrGrafObj* >(this)->mpReplacementGraphicObject.reset(new GraphicObject(rVectorGraphicDataPtr->getReplacement())); + } + else if (mpGraphicObject->GetGraphic().GetType() == GraphicType::GdiMetafile) + { + // Replacement graphic for PDF and metafiles is just the bitmap. + const_cast(this)->mpReplacementGraphicObject.reset(new GraphicObject(mpGraphicObject->GetGraphic().GetBitmapEx())); + } + } + + return mpReplacementGraphicObject.get(); +} + +void SdrGrafObj::NbcSetGraphic(const Graphic& rGraphic) +{ + mpGraphicObject->SetGraphic(rGraphic); + mpReplacementGraphicObject.reset(); + mpGraphicObject->SetUserData(); + onGraphicChanged(); +} + +void SdrGrafObj::SetGraphic( const Graphic& rGraphic ) +{ + if (!rGraphic.getOriginURL().isEmpty()) + { + ImpDeregisterLink(); + aFileName = rGraphic.getOriginURL(); + aFilterName = ""; + } + NbcSetGraphic(rGraphic); + if (!rGraphic.getOriginURL().isEmpty()) + { + ImpRegisterLink(); + mpGraphicObject->SetUserData(); + } + SetChanged(); + BroadcastObjectChange(); + ForceSwapIn(); +} + +const Graphic& SdrGrafObj::GetGraphic() const +{ + return mpGraphicObject->GetGraphic(); +} + +Graphic SdrGrafObj::GetTransformedGraphic( SdrGrafObjTransformsAttrs nTransformFlags ) const +{ + // Refactored most of the code to GraphicObject, where + // everybody can use e.g. the cropping functionality + MapMode aDestMap(getSdrModelFromSdrObject().GetScaleUnit()); + const Size aDestSize( GetLogicRect().GetSize() ); + GraphicAttr aActAttr = GetGraphicAttr(nTransformFlags); + + // Delegate to moved code in GraphicObject + return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr ); +} + +GraphicType SdrGrafObj::GetGraphicType() const +{ + return mpGraphicObject->GetType(); +} + +GraphicAttr SdrGrafObj::GetGraphicAttr( SdrGrafObjTransformsAttrs nTransformFlags ) const +{ + GraphicAttr aActAttr; + + GraphicType eType = GetGraphicType(); + if( SdrGrafObjTransformsAttrs::NONE != nTransformFlags && + GraphicType::NONE != eType ) + { + const bool bMirror = bool( nTransformFlags & SdrGrafObjTransformsAttrs::MIRROR ); + const bool bRotate = bool( nTransformFlags & SdrGrafObjTransformsAttrs::ROTATE ) && + (maGeo.m_nRotationAngle && maGeo.m_nRotationAngle != 18000_deg100); + + // Need cropping info earlier + const_cast(this)->ImpSetAttrToGrafInfo(); + + // Actually transform the graphic only in this case. + // Cropping always happens, though. + aActAttr = aGrafInfo; + + if( bMirror ) + { + sal_uInt16 nMirrorCase = ( maGeo.m_nRotationAngle == 18000_deg100 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 ); + bool bHMirr = nMirrorCase == 2 || nMirrorCase == 4; + bool bVMirr = nMirrorCase == 3 || nMirrorCase == 4; + + aActAttr.SetMirrorFlags( ( bHMirr ? BmpMirrorFlags::Horizontal : BmpMirrorFlags::NONE ) | ( bVMirr ? BmpMirrorFlags::Vertical : BmpMirrorFlags::NONE ) ); + } + + if( bRotate ) + aActAttr.SetRotation( to(maGeo.m_nRotationAngle ) ); + } + + return aActAttr; +} + +bool SdrGrafObj::IsAnimated() const +{ + return mpGraphicObject->IsAnimated(); +} + +bool SdrGrafObj::IsEPS() const +{ + return mpGraphicObject->IsEPS(); +} + +MapMode SdrGrafObj::GetGrafPrefMapMode() const +{ + return mpGraphicObject->GetPrefMapMode(); +} + +Size SdrGrafObj::GetGrafPrefSize() const +{ + return mpGraphicObject->GetPrefSize(); +} + +void SdrGrafObj::SetGrafStreamURL( const OUString& rGraphicStreamURL ) +{ + if( rGraphicStreamURL.isEmpty() ) + { + mpGraphicObject->SetUserData(); + } + else if(getSdrModelFromSdrObject().IsSwapGraphics() ) + { + mpGraphicObject->SetUserData( rGraphicStreamURL ); + } +} + +OUString const & SdrGrafObj::GetGrafStreamURL() const +{ + return mpGraphicObject->GetUserData(); +} + +Size SdrGrafObj::getOriginalSize() const +{ + Size aSize = GetGrafPrefSize(); + + if (GetGrafPrefMapMode().GetMapUnit() == MapUnit::MapPixel) + aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, MapMode(getSdrModelFromSdrObject().GetScaleUnit())); + else + aSize = OutputDevice::LogicToLogic(aSize, GetGrafPrefMapMode(), MapMode(getSdrModelFromSdrObject().GetScaleUnit())); + + if (aGrafInfo.IsCropped()) + { + const tools::Long aCroppedWidth(aSize.getWidth() - aGrafInfo.GetLeftCrop() + - aGrafInfo.GetRightCrop()); + const tools::Long aCroppedHeight(aSize.getHeight() - aGrafInfo.GetTopCrop() + - aGrafInfo.GetBottomCrop()); + + aSize = Size(aCroppedWidth, aCroppedHeight); + } + + return aSize; +} + +// TODO Remove +void SdrGrafObj::ForceSwapIn() const +{ + if (pGraphicLink && (mpGraphicObject->GetType() == GraphicType::NONE || + mpGraphicObject->GetType() == GraphicType::Default) ) + { + pGraphicLink->Update(); + } +} + +void SdrGrafObj::ImpRegisterLink() +{ + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + + if( pLinkManager != nullptr && pGraphicLink == nullptr ) + { + if (!aFileName.isEmpty()) + { + pGraphicLink = new SdrGraphicLink( *this ); + pLinkManager->InsertFileLink( + *pGraphicLink, sfx2::SvBaseLinkObjectType::ClientGraphic, aFileName, (aFilterName.isEmpty() ? nullptr : &aFilterName)); + pGraphicLink->Connect(); + } + } +} + +void SdrGrafObj::ImpDeregisterLink() +{ + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + + if( pLinkManager != nullptr && pGraphicLink!=nullptr) + { + // When using Remove, the *pGraphicLink is implicitly deleted + pLinkManager->Remove( pGraphicLink ); + pGraphicLink=nullptr; + } +} + +void SdrGrafObj::SetGraphicLink(const OUString& rFileName) +{ + Graphic aGraphic; + aGraphic.setOriginURL(rFileName); + SetGraphic(aGraphic); +} + +void SdrGrafObj::ReleaseGraphicLink() +{ + ImpDeregisterLink(); + aFileName.clear(); + aFilterName.clear(); + + auto aGraphic = mpGraphicObject->GetGraphic(); + aGraphic.setOriginURL(""); + SetGraphic(aGraphic); +} + +bool SdrGrafObj::IsLinkedGraphic() const +{ + return !mpGraphicObject->GetGraphic().getOriginURL().isEmpty(); +} + +void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + bool bNoPresGrf = ( mpGraphicObject->GetType() != GraphicType::NONE ) && !m_bEmptyPresObj; + + rInfo.bResizeFreeAllowed = maGeo.m_nRotationAngle.get() % 9000 == 0 || + maGeo.m_nRotationAngle.get() % 18000 == 0 || + maGeo.m_nRotationAngle.get() % 27000 == 0; + + rInfo.bResizePropAllowed = true; + rInfo.bRotateFreeAllowed = bNoPresGrf; + rInfo.bRotate90Allowed = bNoPresGrf; + rInfo.bMirrorFreeAllowed = bNoPresGrf; + rInfo.bMirror45Allowed = bNoPresGrf; + rInfo.bMirror90Allowed = !m_bEmptyPresObj; + rInfo.bTransparenceAllowed = false; + + // #i118485# Shear allowed and possible now + rInfo.bShearAllowed = true; + + rInfo.bEdgeRadiusAllowed=false; + rInfo.bCanConvToPath = !IsEPS(); + rInfo.bCanConvToPathLineToArea = false; + rInfo.bCanConvToPolyLineToArea = false; + rInfo.bCanConvToPoly = !IsEPS(); + rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrGrafObj::GetObjIdentifier() const +{ + return SdrObjKind::Graphic; +} + +void SdrGrafObj::ImpSetLinkedGraphic( const Graphic& rGraphic ) +{ + const bool bIsChanged(getSdrModelFromSdrObject().IsChanged()); + NbcSetGraphic( rGraphic ); + ActionChanged(); + BroadcastObjectChange(); + getSdrModelFromSdrObject().SetChanged(bIsChanged); +} + +OUString SdrGrafObj::TakeObjNameSingul() const +{ + if (!mpGraphicObject) + return OUString(); + + auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData(); + + OUStringBuffer sName; + + if (rVectorGraphicDataPtr) + { + switch (rVectorGraphicDataPtr->getType()) + { + case VectorGraphicDataType::Svg: + { + sName.append(SvxResId(STR_ObjNameSingulGRAFSVG)); + break; + } + case VectorGraphicDataType::Wmf: + { + sName.append(SvxResId(STR_ObjNameSingulGRAFWMF)); + break; + } + case VectorGraphicDataType::Emf: + { + sName.append(SvxResId(STR_ObjNameSingulGRAFEMF)); + break; + } + case VectorGraphicDataType::Pdf: + { + sName.append(SvxResId(STR_ObjNameSingulGRAFPDF)); + break; + } + } //no default, see tdf#137813 + } + else + { + switch( mpGraphicObject->GetType() ) + { + case GraphicType::Bitmap: + { + TranslateId pId = ( ( mpGraphicObject->IsTransparent() || GetObjectItem( SDRATTR_GRAFTRANSPARENCE ).GetValue() ) ? + ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) : + ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) ); + + sName.append(SvxResId(pId)); + } + break; + + case GraphicType::GdiMetafile: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF)); + break; + + case GraphicType::NONE: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE)); + break; + + default: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF)); + break; + } + } + + const OUString aName(GetName()); + + if (!aName.isEmpty()) + { + sName.append(" '" + aName + "\'" ); + } + + return sName.makeStringAndClear(); +} + +OUString SdrGrafObj::TakeObjNamePlural() const +{ + if (!mpGraphicObject) + return OUString(); + + auto const & rVectorGraphicDataPtr = mpGraphicObject->GetGraphic().getVectorGraphicData(); + + OUStringBuffer sName; + + if (rVectorGraphicDataPtr) + { + switch (rVectorGraphicDataPtr->getType()) + { + case VectorGraphicDataType::Svg: + { + sName.append(SvxResId(STR_ObjNamePluralGRAFSVG)); + break; + } + case VectorGraphicDataType::Wmf: + { + sName.append(SvxResId(STR_ObjNamePluralGRAFWMF)); + break; + } + case VectorGraphicDataType::Emf: + { + sName.append(SvxResId(STR_ObjNamePluralGRAFEMF)); + break; + } + case VectorGraphicDataType::Pdf: + { + sName.append(SvxResId(STR_ObjNamePluralGRAFPDF)); + break; + } + } //no default, see tdf#137813 + } + else + { + switch(mpGraphicObject->GetType()) + { + case GraphicType::Bitmap: + { + TranslateId pId = ( ( mpGraphicObject->IsTransparent() || GetObjectItem( SDRATTR_GRAFTRANSPARENCE ).GetValue() ) ? + ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) : + ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) ); + + sName.append(SvxResId(pId)); + } + break; + + case GraphicType::GdiMetafile: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF)); + break; + + case GraphicType::NONE: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE)); + break; + + default: + sName.append(SvxResId(IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF)); + break; + } + } + + const OUString aName(GetName()); + + if (!aName.isEmpty()) + { + sName.append(" '" + aName + "\'"); + } + + return sName.makeStringAndClear(); +} + +rtl::Reference SdrGrafObj::getFullDragClone() const +{ + // call parent + rtl::Reference pRetval = SdrRectObj::getFullDragClone(); + + // #i103116# the full drag clone leads to problems + // with linked graphics, so reset the link in this + // temporary interaction object and load graphic + if(pRetval && IsLinkedGraphic()) + { + static_cast< SdrGrafObj* >(pRetval.get())->ReleaseGraphicLink(); + } + + return pRetval; +} + +rtl::Reference SdrGrafObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrGrafObj(rTargetModel, *this); +} + +sal_uInt32 SdrGrafObj::GetHdlCount() const +{ + return 8; +} + +void SdrGrafObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + SdrHdlList tempList(nullptr); + SdrRectObj::AddToHdlList( tempList ); + tempList.RemoveHdl(0); + tempList.MoveTo(rHdlList); +} + +void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + SdrRectObj::NbcResize( rRef, xFact, yFact ); + + bool bMirrX = xFact.GetNumerator() < 0; + bool bMirrY = yFact.GetNumerator() < 0; + + if( bMirrX != bMirrY ) + bMirrored = !bMirrored; +} + +void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + SdrRectObj::NbcMirror(rRef1,rRef2); + bMirrored = !bMirrored; +} + +std::unique_ptr SdrGrafObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrRectObj::SaveGeoData(rGeo); + SdrGrafObjGeoData& rGGeo=static_cast(rGeo); + rGGeo.bMirrored=bMirrored; +} + +void SdrGrafObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrRectObj::RestoreGeoData(rGeo); + const SdrGrafObjGeoData& rGGeo=static_cast(rGeo); + bMirrored=rGGeo.bMirrored; +} + +void SdrGrafObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + const bool bRemove(pNewPage == nullptr && pOldPage != nullptr); + const bool bInsert(pNewPage != nullptr && pOldPage == nullptr); + + if( bRemove ) + { + // No SwapIn necessary here, because if something's not loaded, it can't be animated either. + if( mpGraphicObject->IsAnimated()) + mpGraphicObject->StopAnimation(); + + if( pGraphicLink != nullptr ) + ImpDeregisterLink(); + } + + // call parent + SdrRectObj::handlePageChange(pOldPage, pNewPage); + + if (!aFileName.isEmpty() && bInsert) + { + ImpRegisterLink(); + } +} + +void SdrGrafObj::StartAnimation() +{ + SetGrafAnimationAllowed(true); +} + +bool SdrGrafObj::HasGDIMetaFile() const +{ + return( mpGraphicObject->GetType() == GraphicType::GdiMetafile ); +} + +bool SdrGrafObj::isEmbeddedVectorGraphicData() const +{ + return GraphicType::Bitmap == GetGraphicType() && GetGraphic().getVectorGraphicData(); +} + +GDIMetaFile SdrGrafObj::getMetafileFromEmbeddedVectorGraphicData() const +{ + GDIMetaFile aRetval; + + if(isEmbeddedVectorGraphicData()) + { + ScopedVclPtrInstance< VirtualDevice > pOut; + const tools::Rectangle aBoundRect(GetCurrentBoundRect()); + const MapMode aMap(getSdrModelFromSdrObject().GetScaleUnit()); + + pOut->EnableOutput(false); + pOut->SetMapMode(aMap); + aRetval.Record(pOut); + SingleObjectPainter(*pOut); + aRetval.Stop(); + aRetval.WindStart(); + aRetval.Move(-aBoundRect.Left(), -aBoundRect.Top()); + aRetval.SetPrefMapMode(aMap); + aRetval.SetPrefSize(aBoundRect.GetSize()); + } + + return aRetval; +} + +GDIMetaFile SdrGrafObj::GetMetaFile(GraphicType &rGraphicType) const +{ + if (isEmbeddedVectorGraphicData()) + { + // Embedded Vector Graphic Data + // There is currently no helper to create SdrObjects from primitives (even if I'm thinking + // about writing one for some time). To get the roundtrip to SdrObjects it is necessary to + // use the old converter path over the MetaFile mechanism. Create Metafile from Svg + // primitives here pretty directly + rGraphicType = GraphicType::GdiMetafile; + return getMetafileFromEmbeddedVectorGraphicData(); + } + else if (GraphicType::GdiMetafile == rGraphicType) + { + return GetTransformedGraphic(SdrGrafObjTransformsAttrs::MIRROR).GetGDIMetaFile(); + } + return GDIMetaFile(); +} + +rtl::Reference SdrGrafObj::DoConvertToPolyObj(bool bBezier, bool bAddText ) const +{ + rtl::Reference pRetval; + GraphicType aGraphicType(GetGraphicType()); + GDIMetaFile aMtf(GetMetaFile(aGraphicType)); + switch(aGraphicType) + { + case GraphicType::GdiMetafile: + { + // Sort into group and return ONLY those objects that can be created from the MetaFile. + ImpSdrGDIMetaFileImport aFilter( + getSdrModelFromSdrObject(), + GetLayer(), + getRectangle()); + rtl::Reference pGrp = new SdrObjGroup(getSdrModelFromSdrObject()); + + if(aFilter.DoImport(aMtf, *pGrp->GetSubList(), 0)) + { + { + // copy transformation + GeoStat aGeoStat(GetGeoStat()); + + if(aGeoStat.m_nShearAngle) + { + aGeoStat.RecalcTan(); + pGrp->NbcShear(getRectangle().TopLeft(), aGeoStat.m_nShearAngle, aGeoStat.mfTanShearAngle, false); + } + + if(aGeoStat.m_nRotationAngle) + { + aGeoStat.RecalcSinCos(); + pGrp->NbcRotate(getRectangle().TopLeft(), aGeoStat.m_nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle); + } + } + + pRetval = pGrp; + pGrp->NbcSetLayer(GetLayer()); + + if(bAddText) + { + pRetval = ImpConvertAddText(pRetval, bBezier); + } + + // convert all children + if( pRetval ) + { + pRetval = pRetval->DoConvertToPolyObj(bBezier, bAddText); + + if( pRetval ) + { + // flatten subgroups. As we call + // DoConvertToPolyObj() on the resulting group + // objects, subgroups can exist (e.g. text is + // a group object for every line). + SdrObjList* pList = pRetval->GetSubList(); + if( pList ) + pList->FlattenGroups(); + } + } + } + else + pGrp.clear(); + + // #i118485# convert line and fill + rtl::Reference pLineFill = SdrRectObj::DoConvertToPolyObj(bBezier, false); + + if(pLineFill) + { + if(pRetval) + { + pGrp = dynamic_cast< SdrObjGroup* >(pRetval.get()); + + if(!pGrp) + { + pGrp = new SdrObjGroup(getSdrModelFromSdrObject()); + pGrp->NbcSetLayer(GetLayer()); + pGrp->GetSubList()->NbcInsertObject(pRetval.get()); + } + + pGrp->GetSubList()->NbcInsertObject(pLineFill.get(), 0); + } + else + { + pRetval = pLineFill; + } + } + + break; + } + case GraphicType::Bitmap: + { + // create basic object and add fill + pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText); + + // save bitmap as an attribute + if(pRetval) + { + // retrieve bitmap for the fill + SfxItemSet aSet(GetObjectItemSet()); + + aSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP)); + const BitmapEx aBitmapEx(GetTransformedGraphic().GetBitmapEx()); + aSet.Put(XFillBitmapItem(OUString(), Graphic(aBitmapEx))); + aSet.Put(XFillBmpTileItem(false)); + + pRetval->SetMergedItemSet(aSet); + } + break; + } + case GraphicType::NONE: + case GraphicType::Default: + { + pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText); + break; + } + } + + return pRetval; +} + +void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) +{ + SetXPolyDirty(); + SdrRectObj::Notify( rBC, rHint ); + ImpSetAttrToGrafInfo(); +} + + +void SdrGrafObj::SetMirrored( bool _bMirrored ) +{ + bMirrored = _bMirrored; +} + +void SdrGrafObj::ImpSetAttrToGrafInfo() +{ + const SfxItemSet& rSet = GetObjectItemSet(); + const sal_uInt16 nTrans = rSet.Get( SDRATTR_GRAFTRANSPARENCE ).GetValue(); + const SdrGrafCropItem& rCrop = rSet.Get( SDRATTR_GRAFCROP ); + + aGrafInfo.SetLuminance( rSet.Get( SDRATTR_GRAFLUMINANCE ).GetValue() ); + aGrafInfo.SetContrast( rSet.Get( SDRATTR_GRAFCONTRAST ).GetValue() ); + aGrafInfo.SetChannelR( rSet.Get( SDRATTR_GRAFRED ).GetValue() ); + aGrafInfo.SetChannelG( rSet.Get( SDRATTR_GRAFGREEN ).GetValue() ); + aGrafInfo.SetChannelB( rSet.Get( SDRATTR_GRAFBLUE ).GetValue() ); + aGrafInfo.SetGamma( rSet.Get( SDRATTR_GRAFGAMMA ).GetValue() * 0.01 ); + aGrafInfo.SetAlpha( 255 - static_cast(FRound( std::min( nTrans, sal_uInt16(100) ) * 2.55 )) ); + aGrafInfo.SetInvert( rSet.Get( SDRATTR_GRAFINVERT ).GetValue() ); + aGrafInfo.SetDrawMode( rSet.Get( SDRATTR_GRAFMODE ).GetValue() ); + aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() ); + + SetXPolyDirty(); + SetBoundAndSnapRectsDirty(); +} + +void SdrGrafObj::AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool bShrinkOnly ) +{ + Size aSize; + Size aMaxSize( rMaxRect.GetSize() ); + if (mpGraphicObject->GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel) + aSize = Application::GetDefaultDevice()->PixelToLogic(mpGraphicObject->GetPrefSize(), MapMode(MapUnit::Map100thMM)); + else + aSize = OutputDevice::LogicToLogic( mpGraphicObject->GetPrefSize(), + mpGraphicObject->GetPrefMapMode(), + MapMode( MapUnit::Map100thMM ) ); + + if( aSize.IsEmpty() ) + return; + + Point aPos( rMaxRect.TopLeft() ); + + // if the graphic is too large, fit it to page + if ( (!bShrinkOnly || + ( aSize.Height() > aMaxSize.Height() ) || + ( aSize.Width() > aMaxSize.Width() ) )&& + aSize.Height() && aMaxSize.Height() ) + { + float fGrfWH = static_cast(aSize.Width()) / + static_cast(aSize.Height()); + float fWinWH = static_cast(aMaxSize.Width()) / + static_cast(aMaxSize.Height()); + + // Scale graphic to page size + if ( fGrfWH < fWinWH ) + { + aSize.setWidth( static_cast(aMaxSize.Height() * fGrfWH) ); + aSize.setHeight( aMaxSize.Height() ); + } + else if ( fGrfWH > 0.F ) + { + aSize.setWidth( aMaxSize.Width() ); + aSize.setHeight( static_cast(aMaxSize.Width() / fGrfWH) ); + } + + aPos = rMaxRect.Center(); + } + + if( bShrinkOnly ) + aPos = getRectangle().TopLeft(); + + aPos.AdjustX( -(aSize.Width() / 2) ); + aPos.AdjustY( -(aSize.Height() / 2) ); + SetLogicRect( tools::Rectangle( aPos, aSize ) ); +} + +void SdrGrafObj::SetGrafAnimationAllowed(bool bNew) +{ + if(mbGrafAnimationAllowed != bNew) + { + mbGrafAnimationAllowed = bNew; + ActionChanged(); + } +} + +uno::Reference SdrGrafObj::getInputStream() const +{ + uno::Reference xStream; + + if (mpGraphicObject && GetGraphic().IsGfxLink()) + { + Graphic aGraphic( GetGraphic() ); + GfxLink aLink( aGraphic.GetGfxLink() ); + sal_uInt32 nSize = aLink.GetDataSize(); + const void* pSourceData = static_cast(aLink.GetData()); + if( nSize && pSourceData ) + { + sal_uInt8 * pBuffer = new sal_uInt8[ nSize ]; + memcpy( pBuffer, pSourceData, nSize ); + + SvMemoryStream* pStream = new SvMemoryStream( static_cast(pBuffer), static_cast(nSize), StreamMode::READ ); + pStream->ObjectOwnsMemory( true ); + xStream.set( new utl::OInputStreamWrapper( pStream, true ) ); + } + } + + if (!xStream.is() && !aFileName.isEmpty()) + { + SvFileStream* pStream = new SvFileStream( aFileName, StreamMode::READ ); + xStream.set( new utl::OInputStreamWrapper( pStream ) ); + } + + return xStream; +} + +// moved crop handle creation here; this is the object type using them +void SdrGrafObj::addCropHandles(SdrHdlList& rTarget) const +{ + basegfx::B2DHomMatrix aMatrix; + basegfx::B2DPolyPolygon aPolyPolygon; + + // get object transformation + TRGetBaseGeometry(aMatrix, aPolyPolygon); + + // part of object transformation correction, but used later, so defined outside next scope + double fShearX(0.0), fRotate(0.0); + + { // TTTT correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080 + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + + aMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + if(!basegfx::fTools::equalZero(fShearX)) + { + // shearX is used, correct it + fShearX = -fShearX; + } + + aMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, + fShearX, + fRotate, + aTranslate); + } + + // get crop values + const SdrGrafCropItem& rCrop = GetMergedItem(SDRATTR_GRAFCROP); + + if(rCrop.GetLeft() || rCrop.GetTop() || rCrop.GetRight() ||rCrop.GetBottom()) + { + // decompose object transformation to have current translate and scale + basegfx::B2DVector aScale, aTranslate; + double fLclRotate, fLclShearX; + + aMatrix.decompose(aScale, aTranslate, fLclRotate, fLclShearX); + + if(!aScale.equalZero()) + { + // get crop scale + const basegfx::B2DVector aCropScaleFactor( + GetGraphicObject().calculateCropScaling( + aScale.getX(), + aScale.getY(), + rCrop.GetLeft(), + rCrop.GetTop(), + rCrop.GetRight(), + rCrop.GetBottom())); + + // apply crop scale + const double fCropLeft(rCrop.GetLeft() * aCropScaleFactor.getX()); + const double fCropTop(rCrop.GetTop() * aCropScaleFactor.getY()); + const double fCropRight(rCrop.GetRight() * aCropScaleFactor.getX()); + const double fCropBottom(rCrop.GetBottom() * aCropScaleFactor.getY()); + basegfx::B2DHomMatrix aMatrixForCropViewHdl(aMatrix); + + if(IsMirrored()) + { + // create corrected new matrix, TTTT can be removed with aw080 + // the old mirror only can mirror horizontally; the vertical mirror + // is faked by using the horizontal and 180 degree rotation. Since + // the object can be rotated differently from 180 degree, this is + // not safe to detect. Just correct horizontal mirror (which is + // in IsMirrored()) and keep the rotation angle + // caution: Do not modify aMatrix, it is used below to calculate + // the exact handle positions + basegfx::B2DHomMatrix aPreMultiply; + + // mirrored X, apply + aPreMultiply.translate(-0.5, 0.0); + aPreMultiply.scale(-1.0, 1.0); + aPreMultiply.translate(0.5, 0.0); + + aMatrixForCropViewHdl = aMatrixForCropViewHdl * aPreMultiply; + } + + rTarget.AddHdl( + std::make_unique( + aMatrixForCropViewHdl, + GetGraphicObject().GetGraphic(), + fCropLeft, + fCropTop, + fCropRight, + fCropBottom)); + } + } + + basegfx::B2DPoint aPos; + + aPos = aMatrix * basegfx::B2DPoint(0.0, 0.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::UpperLeft, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(0.5, 0.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Upper, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(1.0, 0.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::UpperRight, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(0.0, 0.5); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Left , fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(1.0, 0.5); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Right, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(0.0, 1.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::LowerLeft, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(0.5, 1.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::Lower, fShearX, fRotate)); + aPos = aMatrix * basegfx::B2DPoint(1.0, 1.0); + rTarget.AddHdl(std::make_unique(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), SdrHdlKind::LowerRight, fShearX, fRotate)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdogrp.cxx b/svx/source/svdraw/svdogrp.cxx new file mode 100644 index 0000000000..5878c8cd99 --- /dev/null +++ b/svx/source/svdraw/svdogrp.cxx @@ -0,0 +1,794 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +const std::shared_ptr< svx::diagram::IDiagramHelper >& SdrObjGroup::getDiagramHelper() const +{ + return mp_DiagramHelper; +} + +// BaseProperties section +std::unique_ptr SdrObjGroup::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + +// DrawContact section +std::unique_ptr SdrObjGroup::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +SdrObjGroup::SdrObjGroup(SdrModel& rSdrModel) +: SdrObject(rSdrModel) +, SdrObjList() +, maRefPoint(0, 0) +, mp_DiagramHelper() +{ + m_bClosedObj=false; +} + +SdrObjGroup::SdrObjGroup(SdrModel& rSdrModel, SdrObjGroup const & rSource) +: SdrObject(rSdrModel, rSource) +, SdrObjList() +, maRefPoint(0, 0) +, mp_DiagramHelper() +{ + m_bClosedObj=false; + + // copy child SdrObjects + if(nullptr != rSource.GetSubList()) + { + // #i36404# Copy SubList, init model and page first + const SdrObjList& rSourceSubList(*rSource.GetSubList()); + + CopyObjects(rSourceSubList); + + // tdf#116979: needed here, we need bSnapRectDirty to be true + // which it is after using SdrObject::operator= (see above), + // but set to false again using CopyObjects + SetBoundAndSnapRectsDirty(); + } + + // copy local parameters + maRefPoint = rSource.maRefPoint; +} + +void SdrObjGroup::AddToHdlList(SdrHdlList& rHdlList) const +{ + // only for diagram, so do nothing for just groups + if(!isDiagram()) + return; + + svx::diagram::IDiagramHelper::AddAdditionalVisualization(*this, rHdlList); +} + +SdrObjGroup::~SdrObjGroup() +{ +} + +SdrPage* SdrObjGroup::getSdrPageFromSdrObjList() const +{ + return getSdrPageFromSdrObject(); +} + +SdrObject* SdrObjGroup::getSdrObjectFromSdrObjList() const +{ + return const_cast< SdrObjGroup* >(this); +} + +SdrObjList* SdrObjGroup::getChildrenOfSdrObject() const +{ + return const_cast< SdrObjGroup* >(this); +} + +void SdrObjGroup::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bNoContortion=false; + const size_t nObjCount(GetObjCount()); + for (const rtl::Reference& pObj : *this) { + SdrObjTransformInfoRec aInfo; + pObj->TakeObjInfo(aInfo); + if (!aInfo.bMoveAllowed ) rInfo.bMoveAllowed =false; + if (!aInfo.bResizeFreeAllowed ) rInfo.bResizeFreeAllowed =false; + if (!aInfo.bResizePropAllowed ) rInfo.bResizePropAllowed =false; + if (!aInfo.bRotateFreeAllowed ) rInfo.bRotateFreeAllowed =false; + if (!aInfo.bRotate90Allowed ) rInfo.bRotate90Allowed =false; + if (!aInfo.bMirrorFreeAllowed ) rInfo.bMirrorFreeAllowed =false; + if (!aInfo.bMirror45Allowed ) rInfo.bMirror45Allowed =false; + if (!aInfo.bMirror90Allowed ) rInfo.bMirror90Allowed =false; + if (!aInfo.bShearAllowed ) rInfo.bShearAllowed =false; + if (!aInfo.bEdgeRadiusAllowed ) rInfo.bEdgeRadiusAllowed =false; + if (!aInfo.bNoOrthoDesired ) rInfo.bNoOrthoDesired =false; + if (aInfo.bNoContortion ) rInfo.bNoContortion =true; + if (!aInfo.bCanConvToPath ) rInfo.bCanConvToPath =false; + + if(!aInfo.bCanConvToContour) + rInfo.bCanConvToContour = false; + + if (!aInfo.bCanConvToPoly ) rInfo.bCanConvToPoly =false; + if (!aInfo.bCanConvToPathLineToArea) rInfo.bCanConvToPathLineToArea=false; + if (!aInfo.bCanConvToPolyLineToArea) rInfo.bCanConvToPolyLineToArea=false; + } + if (nObjCount==0) { + rInfo.bRotateFreeAllowed=false; + rInfo.bRotate90Allowed =false; + rInfo.bMirrorFreeAllowed=false; + rInfo.bMirror45Allowed =false; + rInfo.bMirror90Allowed =false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =false; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bNoContortion =true; + } + if(nObjCount != 1) + { + // only allowed if single object selected + rInfo.bTransparenceAllowed = false; + } +} + +void SdrObjGroup::SetBoundRectDirty() +{ + // avoid resetting aOutRect which in case of this object is model data, + // not re-creatable view data +} + +SdrObjKind SdrObjGroup::GetObjIdentifier() const +{ + return SdrObjKind::Group; +} + +SdrLayerID SdrObjGroup::GetLayer() const +{ + SdrLayerID nLay = SdrObject::GetLayer(); + bool b1st = true; + for (const rtl::Reference& pObject : *this) + { + SdrLayerID nLay1(pObject->GetLayer()); + if (b1st) { nLay=nLay1; b1st = false; } + else if (nLay1!=nLay) return SdrLayerID(0); + } + return nLay; +} + +void SdrObjGroup::NbcSetLayer(SdrLayerID nLayer) +{ + SdrObject::NbcSetLayer(nLayer); + for (const rtl::Reference& pObj : *this) + pObj->NbcSetLayer(nLayer); +} + +void SdrObjGroup::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + // call parent + SdrObject::handlePageChange(pOldPage, pNewPage); + + for (const rtl::Reference& pObj : *this) + pObj->handlePageChange(pOldPage, pNewPage); +} + +SdrObjList* SdrObjGroup::GetSubList() const +{ + return const_cast< SdrObjGroup* >(this); +} + +static bool containsOOXData(const css::uno::Any& rVal) +{ + const css::uno::Sequence& propList(rVal.get< css::uno::Sequence >()); + for (const auto& rProp : std::as_const(propList)) + { + if(rProp.Name.startsWith("OOX")) + { + return true; + } + } + + return false; +} + +void SdrObjGroup::SetGrabBagItem(const css::uno::Any& rVal) +{ + // detect if the intention is to disable Diagram functionality + if(isDiagram() && !containsOOXData(rVal)) + { + css::uno::Any aOld; + GetGrabBagItem(aOld); + + if(containsOOXData(aOld)) + { + mp_DiagramHelper.reset(); + } + } + + // call parent + SdrObject::SetGrabBagItem(rVal); +} + +const tools::Rectangle& SdrObjGroup::GetCurrentBoundRect() const +{ + // has to contain the bounding rectangle + if(0 != GetObjCount()) + { + setOutRectangleConst(GetAllObjBoundRect()); + } + + return getOutRectangle(); +} + +const tools::Rectangle& SdrObjGroup::GetSnapRect() const +{ + // has to contain the bounding rectangle + if(0 != GetObjCount()) + { + return GetAllObjSnapRect(); + } + else + { + return getOutRectangle(); + } +} + +rtl::Reference SdrObjGroup::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrObjGroup(rTargetModel, *this); +} + +OUString SdrObjGroup::TakeObjNameSingul() const +{ + OUString sName; + + if(0 == GetObjCount()) + { + sName = SvxResId(STR_ObjNameSingulGRUPEMPTY); + } + else + { + if(isDiagram()) + sName = SvxResId(STR_ObjNameSingulDIAGRAM); + else + sName = SvxResId(STR_ObjNameSingulGRUP); + } + + const OUString aName(GetName()); + + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + + +OUString SdrObjGroup::TakeObjNamePlural() const +{ + if(0 == GetObjCount()) + return SvxResId(STR_ObjNamePluralGRUPEMPTY); + if(isDiagram()) + return SvxResId(RID_GALLERYSTR_THEME_DIAGRAMS); + return SvxResId(STR_ObjNamePluralGRUP); +} + + +void SdrObjGroup::RecalcSnapRect() +{ + // TODO: unnecessary, because we use the Rects from the SubList +} + +basegfx::B2DPolyPolygon SdrObjGroup::TakeXorPoly() const +{ + basegfx::B2DPolyPolygon aRetval; + + for (const rtl::Reference& pObj : *this) + aRetval.append(pObj->TakeXorPoly()); + + if(!aRetval.count()) + { + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(getOutRectangle()); + aRetval.append(basegfx::utils::createPolygonFromRect(aRange)); + } + + return aRetval; +} + +bool SdrObjGroup::beginSpecialDrag(SdrDragStat& /*rDrag*/) const +{ + return false; +} + + +bool SdrObjGroup::BegCreate(SdrDragStat& /*rStat*/) +{ + return false; +} + + +Degree100 SdrObjGroup::GetRotateAngle() const +{ + Degree100 nRetval(0); + + if(0 != GetObjCount()) + { + SdrObject* pObj(GetObj(0)); + + nRetval = pObj->GetRotateAngle(); + } + + return nRetval; +} + + +Degree100 SdrObjGroup::GetShearAngle(bool /*bVertical*/) const +{ + Degree100 nRetval(0); + + if(0 != GetObjCount()) + { + SdrObject* pObj(GetObj(0)); + + nRetval = pObj->GetShearAngle(); + } + + return nRetval; +} + + +void SdrObjGroup::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aOld(GetSnapRect()); + tools::Long nMulX=rRect.Right()-rRect.Left(); + tools::Long nDivX=aOld.Right()-aOld.Left(); + tools::Long nMulY=rRect.Bottom()-rRect.Top(); + tools::Long nDivY=aOld.Bottom()-aOld.Top(); + if (nDivX==0) { nMulX=1; nDivX=1; } + if (nDivY==0) { nMulY=1; nDivY=1; } + if (nMulX!=nDivX || nMulY!=nDivY) { + Fraction aX(nMulX,nDivX); + Fraction aY(nMulY,nDivY); + NbcResize(aOld.TopLeft(),aX,aY); + } + if (rRect.Left()!=aOld.Left() || rRect.Top()!=aOld.Top()) { + NbcMove(Size(rRect.Left()-aOld.Left(),rRect.Top()-aOld.Top())); + } +} + + +void SdrObjGroup::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + NbcSetSnapRect(rRect); +} + + +void SdrObjGroup::NbcMove(const Size& rSize) +{ + maRefPoint.Move(rSize); + const size_t nObjCount(GetObjCount()); + + if(0 != nObjCount) + { + for (const rtl::Reference& pObj : *this) + pObj->NbcMove(rSize); + } + else + { + moveOutRectangle(rSize.Width(), rSize.Height()); + SetBoundAndSnapRectsDirty(); + } +} + + +void SdrObjGroup::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0); + bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0); + if (bXMirr || bYMirr) { + Point aRef1(GetSnapRect().Center()); + if (bXMirr) { + Point aRef2(aRef1); + aRef2.AdjustY( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + if (bYMirr) { + Point aRef2(aRef1); + aRef2.AdjustX( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + } + + ResizePoint(maRefPoint, rRef, xFact, yFact); + + const size_t nObjCount(GetObjCount()); + if(0 != nObjCount) + { + for (const rtl::Reference& pObj : *this) + pObj->NbcResize(rRef,xFact,yFact); + } + else + { + auto aRectangle = getOutRectangle(); + ResizeRect(aRectangle, rRef, xFact, yFact); + setOutRectangle(aRectangle); + + SetBoundAndSnapRectsDirty(); + } +} + + +void SdrObjGroup::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + SetGlueReallyAbsolute(true); + RotatePoint(maRefPoint, rRef, sn, cs); + + for (const rtl::Reference& pObj : *this) + pObj->NbcRotate(rRef,nAngle,sn,cs); + + NbcRotateGluePoints(rRef,nAngle,sn,cs); + SetGlueReallyAbsolute(false); +} + + +void SdrObjGroup::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + SetGlueReallyAbsolute(true); + MirrorPoint(maRefPoint, rRef1, rRef2); // implementation missing in SvdEtc! + + for (const rtl::Reference& pObj : *this) + pObj->NbcMirror(rRef1,rRef2); + + NbcMirrorGluePoints(rRef1,rRef2); + SetGlueReallyAbsolute(false); +} + + +void SdrObjGroup::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + SetGlueReallyAbsolute(true); + ShearPoint(maRefPoint, rRef, tn); + + for (const rtl::Reference& pObj : *this) + { + pObj->NbcShear(rRef,nAngle,tn,bVShear); + } + + NbcShearGluePoints(rRef,tn,bVShear); + SetGlueReallyAbsolute(false); +} + + +void SdrObjGroup::NbcSetAnchorPos(const Point& rPnt) +{ + m_aAnchor=rPnt; + Size aSiz(rPnt.X()-m_aAnchor.X(),rPnt.Y()-m_aAnchor.Y()); + maRefPoint.Move(aSiz); + + for (const rtl::Reference& pObj : *this) + pObj->NbcSetAnchorPos(rPnt); +} + + +void SdrObjGroup::SetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + tools::Rectangle aOld(GetSnapRect()); + if (aOld.IsEmpty()) + { + Fraction aX(1,1); + Fraction aY(1,1); + Resize(aOld.TopLeft(),aX,aY); + } + else + { + tools::Long nMulX=rRect.Right()-rRect.Left(); + tools::Long nDivX=aOld.Right()-aOld.Left(); + tools::Long nMulY=rRect.Bottom()-rRect.Top(); + tools::Long nDivY=aOld.Bottom()-aOld.Top(); + if (nDivX==0) { nMulX=1; nDivX=1; } + if (nDivY==0) { nMulY=1; nDivY=1; } + if (nMulX!=nDivX || nMulY!=nDivY) { + Fraction aX(nMulX,nDivX); + Fraction aY(nMulY,nDivY); + Resize(aOld.TopLeft(),aX,aY); + } + } + if (rRect.Left()!=aOld.Left() || rRect.Top()!=aOld.Top()) { + Move(Size(rRect.Left()-aOld.Left(),rRect.Top()-aOld.Top())); + } + + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +void SdrObjGroup::SetLogicRect(const tools::Rectangle& rRect) +{ + SetSnapRect(rRect); +} + + +void SdrObjGroup::Move(const Size& rSiz) +{ + if (rSiz.Width()==0 && rSiz.Height()==0) + return; + + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + maRefPoint.Move(rSiz); + const size_t nObjCount(GetObjCount()); + + if(0 != nObjCount) + { + // first move the connectors, then everything else + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->Move(rSiz); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->Move(rSiz); + } + } + else + { + moveOutRectangle(rSiz.Width(), rSiz.Height()); + SetBoundAndSnapRectsDirty(); + } + + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); +} + + +void SdrObjGroup::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative) +{ + if (xFact.GetNumerator()==xFact.GetDenominator() && yFact.GetNumerator()==yFact.GetDenominator()) + return; + + bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0); + bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0); + if (bXMirr || bYMirr) { + Point aRef1(GetSnapRect().Center()); + if (bXMirr) { + Point aRef2(aRef1); + aRef2.AdjustY( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + if (bYMirr) { + Point aRef2(aRef1); + aRef2.AdjustX( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + } + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + ResizePoint(maRefPoint, rRef, xFact, yFact); + const size_t nObjCount(GetObjCount()); + + if(0 != nObjCount) + { + // move the connectors first, everything else afterwards + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->Resize(rRef,xFact,yFact,bUnsetRelative); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->Resize(rRef,xFact,yFact,bUnsetRelative); + } + } + else + { + auto aRectangle = getOutRectangle(); + ResizeRect(aRectangle, rRef, xFact, yFact); + setOutRectangle(aRectangle); + + SetBoundAndSnapRectsDirty(); + } + + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +void SdrObjGroup::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + if (nAngle==0_deg100) + return; + + SetGlueReallyAbsolute(true); + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + RotatePoint(maRefPoint, rRef, sn, cs); + // move the connectors first, everything else afterwards + + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->Rotate(rRef,nAngle,sn,cs); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->Rotate(rRef,nAngle,sn,cs); + } + + NbcRotateGluePoints(rRef,nAngle,sn,cs); + SetGlueReallyAbsolute(false); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +void SdrObjGroup::Mirror(const Point& rRef1, const Point& rRef2) +{ + SetGlueReallyAbsolute(true); + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + MirrorPoint(maRefPoint, rRef1, rRef2); // implementation missing in SvdEtc! + // move the connectors first, everything else afterwards + + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->Mirror(rRef1,rRef2); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->Mirror(rRef1,rRef2); + } + + NbcMirrorGluePoints(rRef1,rRef2); + SetGlueReallyAbsolute(false); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +void SdrObjGroup::Shear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + if (nAngle==0_deg100) + return; + + SetGlueReallyAbsolute(true); + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + ShearPoint(maRefPoint, rRef, tn); + // move the connectors first, everything else afterwards + + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->Shear(rRef,nAngle,tn,bVShear); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->Shear(rRef,nAngle,tn,bVShear); + } + + NbcShearGluePoints(rRef,tn,bVShear); + SetGlueReallyAbsolute(false); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + +} + + +void SdrObjGroup::SetAnchorPos(const Point& rPnt) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + bool bChg=m_aAnchor!=rPnt; + m_aAnchor=rPnt; + Size aSiz(rPnt.X()-m_aAnchor.X(),rPnt.Y()-m_aAnchor.Y()); + maRefPoint.Move(aSiz); + // move the connectors first, everything else afterwards + + for (const rtl::Reference& pObj : *this) + { + if (pObj->IsEdgeObj()) + pObj->SetAnchorPos(rPnt); + } + + for (const rtl::Reference& pObj : *this) + { + if (!pObj->IsEdgeObj()) + pObj->SetAnchorPos(rPnt); + } + + if (bChg) + { + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} + + +void SdrObjGroup::NbcSetRelativePos(const Point& rPnt) +{ + Point aRelPos0(GetSnapRect().TopLeft()-m_aAnchor); + Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y()); + NbcMove(aSiz); // this also calls SetRectsDirty() +} + +void SdrObjGroup::SetRelativePos(const Point& rPnt) +{ + Point aRelPos0(GetSnapRect().TopLeft()-m_aAnchor); + Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y()); + if (aSiz.Width()!=0 || aSiz.Height()!=0) Move(aSiz); // this also calls SetRectsDirty() and Broadcast, ... +} + +void SdrObjGroup::NbcReformatText() +{ + NbcReformatAllTextObjects(); +} + +rtl::Reference SdrObjGroup::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + rtl::Reference pGroup( new SdrObjGroup(getSdrModelFromSdrObject()) ); + + for (const rtl::Reference& pIterObj : *this) + { + rtl::Reference pResult(pIterObj->DoConvertToPolyObj(bBezier, bAddText)); + + // pResult can be NULL e.g. for empty objects + if( pResult ) + pGroup->GetSubList()->NbcInsertObject(pResult.get()); + } + + return pGroup; +} + +void SdrObjGroup::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjGroup")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + + SdrObject::dumpAsXml(pWriter); + SdrObjList::dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdomeas.cxx b/svx/source/svdraw/svdomeas.cxx new file mode 100644 index 0000000000..9831cf9124 --- /dev/null +++ b/svx/source/svdraw/svdomeas.cxx @@ -0,0 +1,1429 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +SdrMeasureObjGeoData::SdrMeasureObjGeoData() {} +SdrMeasureObjGeoData::~SdrMeasureObjGeoData() {} + +OUString SdrMeasureObj::TakeRepresentation(SdrMeasureFieldKind eMeasureFieldKind) const +{ + OUString aStr; + Fraction aMeasureScale(1, 1); + bool bTextRota90(false); + bool bShowUnit(false); + FieldUnit eMeasureUnit(FieldUnit::NONE); + FieldUnit eModUIUnit(FieldUnit::NONE); + + const SfxItemSet& rSet = GetMergedItemSet(); + bTextRota90 = rSet.Get(SDRATTR_MEASURETEXTROTA90).GetValue(); + eMeasureUnit = rSet.Get(SDRATTR_MEASUREUNIT).GetValue(); + aMeasureScale = rSet.Get(SDRATTR_MEASURESCALE).GetValue(); + bShowUnit = rSet.Get(SDRATTR_MEASURESHOWUNIT).GetValue(); + sal_Int16 nNumDigits = rSet.Get(SDRATTR_MEASUREDECIMALPLACES).GetValue(); + + switch(eMeasureFieldKind) + { + case SdrMeasureFieldKind::Value: + { + eModUIUnit = getSdrModelFromSdrObject().GetUIUnit(); + + if(eMeasureUnit == FieldUnit::NONE) + eMeasureUnit = eModUIUnit; + + sal_Int32 nLen(GetLen(aPt2 - aPt1)); + Fraction aFact(1,1); + + if(eMeasureUnit != eModUIUnit) + { + // for the unit conversion + aFact *= GetMapFactor(eModUIUnit, eMeasureUnit).X(); + } + + if(aMeasureScale.GetNumerator() != aMeasureScale.GetDenominator()) + { + aFact *= aMeasureScale; + } + + if(aFact.GetNumerator() != aFact.GetDenominator()) + { + // scale via BigInt, to avoid overruns + nLen = BigMulDiv(nLen, aFact.GetNumerator(), aFact.GetDenominator()); + } + + if(!aFact.IsValid()) + { + aStr = "?"; + } + else + { + aStr = getSdrModelFromSdrObject().GetMetricString(nLen, true, nNumDigits); + } + + SvtSysLocale aSysLocale; + const LocaleDataWrapper& rLocaleDataWrapper = aSysLocale.GetLocaleData(); + sal_Unicode cDec(rLocaleDataWrapper.getNumDecimalSep()[0]); + sal_Unicode cDecAlt(rLocaleDataWrapper.getNumDecimalSepAlt().toChar()); + + if(aStr.indexOf(cDec) != -1 || (cDecAlt && aStr.indexOf(cDecAlt) != -1)) + { + sal_Int32 nLen2(aStr.getLength() - 1); + + while(aStr[nLen2] == '0') + { + aStr = aStr.copy(0, nLen2); + nLen2--; + } + + if(aStr[nLen2] == cDec || (cDecAlt && aStr[nLen2] == cDecAlt)) + { + aStr = aStr.copy(0, nLen2); + nLen2--; + } + + if(aStr.isEmpty()) + aStr += "0"; + } + + break; + } + case SdrMeasureFieldKind::Unit: + { + if(bShowUnit) + { + eModUIUnit = getSdrModelFromSdrObject().GetUIUnit(); + + if(eMeasureUnit == FieldUnit::NONE) + eMeasureUnit = eModUIUnit; + + aStr = SdrModel::GetUnitString(eMeasureUnit); + } + + break; + } + case SdrMeasureFieldKind::Rotate90Blanks: + { + if(bTextRota90) + { + aStr = " "; + } + + break; + } + } + return aStr; +} + + +// BaseProperties section + +std::unique_ptr SdrMeasureObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrMeasureObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +SdrMeasureObj::SdrMeasureObj(SdrModel& rSdrModel) +: SdrTextObj(rSdrModel), + bTextDirty(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; +} + +SdrMeasureObj::SdrMeasureObj(SdrModel& rSdrModel, SdrMeasureObj const & rSource) +: SdrTextObj(rSdrModel, rSource), + bTextDirty(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; + + aPt1 = rSource.aPt1; + aPt2 = rSource.aPt2; + bTextDirty = rSource.bTextDirty; +} + +SdrMeasureObj::SdrMeasureObj( + SdrModel& rSdrModel, + const Point& rPt1, + const Point& rPt2) +: SdrTextObj(rSdrModel), + aPt1(rPt1), + aPt2(rPt2), + bTextDirty(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = false; +} + +SdrMeasureObj::~SdrMeasureObj() +{ +} + +void SdrMeasureObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bMoveAllowed =true; + rInfo.bResizeFreeAllowed=true; + rInfo.bResizePropAllowed=true; + rInfo.bRotateFreeAllowed=true; + rInfo.bRotate90Allowed =true; + rInfo.bMirrorFreeAllowed=true; + rInfo.bMirror45Allowed =true; + rInfo.bMirror90Allowed =true; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =true; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bNoOrthoDesired =true; + rInfo.bNoContortion =false; + rInfo.bCanConvToPath =false; + rInfo.bCanConvToPoly =true; + rInfo.bCanConvToPathLineToArea=false; + rInfo.bCanConvToPolyLineToArea=false; + rInfo.bCanConvToContour = LineGeometryUsageIsNecessary(); +} + +SdrObjKind SdrMeasureObj::GetObjIdentifier() const +{ + return SdrObjKind::Measure; +} + +struct ImpMeasureRec : public SdrDragStatUserData +{ + Point aPt1; + Point aPt2; + css::drawing::MeasureTextHorzPos eWantTextHPos; + css::drawing::MeasureTextVertPos eWantTextVPos; + tools::Long nLineDist; + tools::Long nHelplineOverhang; + tools::Long nHelplineDist; + tools::Long nHelpline1Len; + tools::Long nHelpline2Len; + bool bBelowRefEdge; + bool bTextRota90; + bool bTextUpsideDown; + bool bTextAutoAngle; + Degree100 nTextAutoAngleView; +}; + +namespace { + +struct ImpLineRec +{ + Point aP1; + Point aP2; +}; + +} + +struct ImpMeasurePoly +{ + ImpLineRec aMainline1; // those with the 1st arrowhead + ImpLineRec aMainline2; // those with the 2nd arrowhead + ImpLineRec aMainline3; // those in between + ImpLineRec aHelpline1; + ImpLineRec aHelpline2; + Size aTextSize; + tools::Long nLineLen; + Degree100 nLineAngle; + Degree100 nTextAngle; + Degree100 nHlpAngle; + double nLineSin; + double nLineCos; + sal_uInt16 nMainlineCnt; + css::drawing::MeasureTextHorzPos eUsedTextHPos; + css::drawing::MeasureTextVertPos eUsedTextVPos; + tools::Long nLineWdt2; // half the line width + tools::Long nArrow1Len; // length of 1st arrowhead; for Center, use only half + tools::Long nArrow2Len; // length of 2nd arrowhead; for Center, use only half + tools::Long nArrow1Wdt; // width of 1st arrow + tools::Long nArrow2Wdt; // width of 2nd arrow + tools::Long nShortLineLen; // line length, if PfeileAussen (arrowheads on the outside) + bool bAutoUpsideDown; // UpsideDown via automation + bool bBreakedLine; +}; + +void SdrMeasureObj::ImpTakeAttr(ImpMeasureRec& rRec) const +{ + rRec.aPt1 = aPt1; + rRec.aPt2 = aPt2; + + const SfxItemSet& rSet = GetObjectItemSet(); + rRec.eWantTextHPos =rSet.Get(SDRATTR_MEASURETEXTHPOS ).GetValue(); + rRec.eWantTextVPos =rSet.Get(SDRATTR_MEASURETEXTVPOS ).GetValue(); + rRec.nLineDist =rSet.Get(SDRATTR_MEASURELINEDIST ).GetValue(); + rRec.nHelplineOverhang =rSet.Get(SDRATTR_MEASUREHELPLINEOVERHANG).GetValue(); + rRec.nHelplineDist =rSet.Get(SDRATTR_MEASUREHELPLINEDIST ).GetValue(); + rRec.nHelpline1Len =rSet.Get(SDRATTR_MEASUREHELPLINE1LEN ).GetValue(); + rRec.nHelpline2Len =rSet.Get(SDRATTR_MEASUREHELPLINE2LEN ).GetValue(); + rRec.bBelowRefEdge =rSet.Get(SDRATTR_MEASUREBELOWREFEDGE ).GetValue(); + rRec.bTextRota90 =rSet.Get(SDRATTR_MEASURETEXTROTA90 ).GetValue(); + rRec.bTextUpsideDown =static_cast(rSet.Get(SDRATTR_MEASURETEXTUPSIDEDOWN )).GetValue(); + rRec.bTextAutoAngle =rSet.Get(SDRATTR_MEASURETEXTAUTOANGLE ).GetValue(); + rRec.nTextAutoAngleView=static_cast(rSet.Get(SDRATTR_MEASURETEXTAUTOANGLEVIEW)).GetValue(); +} + +static tools::Long impGetLineStartEndDistance(const basegfx::B2DPolyPolygon& rPolyPolygon, tools::Long nNewWidth, bool bCenter) +{ + const basegfx::B2DRange aPolygonRange(rPolyPolygon.getB2DRange()); + const double fOldWidth(std::max(aPolygonRange.getWidth(), 1.0)); + const double fScale(static_cast(nNewWidth) / fOldWidth); + tools::Long nHeight(basegfx::fround(aPolygonRange.getHeight() * fScale)); + + if(bCenter) + { + nHeight /= 2; + } + + return nHeight; +} + +void SdrMeasureObj::ImpCalcGeometrics(const ImpMeasureRec& rRec, ImpMeasurePoly& rPol) const +{ + Point aP1(rRec.aPt1); + Point aP2(rRec.aPt2); + Point aDelt(aP2); aDelt-=aP1; + + rPol.aTextSize=GetTextSize(); + rPol.nLineLen=GetLen(aDelt); + + rPol.nLineWdt2=0; + tools::Long nArrow1Len=0; bool bArrow1Center=false; + tools::Long nArrow2Len=0; bool bArrow2Center=false; + tools::Long nArrow1Wdt=0; + tools::Long nArrow2Wdt=0; + rPol.nArrow1Wdt=0; + rPol.nArrow2Wdt=0; + tools::Long nArrowNeed=0; + tools::Long nShortLen=0; + bool bPfeileAussen = false; + + const SfxItemSet& rSet = GetObjectItemSet(); + sal_Int32 nLineWdt = rSet.Get(XATTR_LINEWIDTH).GetValue(); // line width + rPol.nLineWdt2 = (nLineWdt + 1) / 2; + + nArrow1Wdt = rSet.Get(XATTR_LINESTARTWIDTH).GetValue(); + if(nArrow1Wdt < 0) + nArrow1Wdt = -nLineWdt * nArrow1Wdt / 100; // <0 = relative + + nArrow2Wdt = rSet.Get(XATTR_LINEENDWIDTH).GetValue(); + if(nArrow2Wdt < 0) + nArrow2Wdt = -nLineWdt * nArrow2Wdt / 100; // <0 = relative + + basegfx::B2DPolyPolygon aPol1(rSet.Get(XATTR_LINESTART).GetLineStartValue()); + basegfx::B2DPolyPolygon aPol2(rSet.Get(XATTR_LINEEND).GetLineEndValue()); + bArrow1Center = rSet.Get(XATTR_LINESTARTCENTER).GetValue(); + bArrow2Center = rSet.Get(XATTR_LINEENDCENTER).GetValue(); + nArrow1Len = impGetLineStartEndDistance(aPol1, nArrow1Wdt, bArrow1Center) - 1; + nArrow2Len = impGetLineStartEndDistance(aPol2, nArrow2Wdt, bArrow2Center) - 1; + + // nArrowLen is already halved at bCenter. + // In the case of 2 arrowheads each 4mm long, we can't go below 10mm. + nArrowNeed=nArrow1Len+nArrow2Len+(nArrow1Wdt+nArrow2Wdt)/2; + if (rPol.nLineLenGetTextObject().GetParagraphCount()==1) + { + bBrkLine=true; // dashed line if there's only on paragraph. + } + } + rPol.bBreakedLine=bBrkLine; + if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_AUTO) { // if text is too wide, push it outside + bool bOutside = false; + tools::Long nNeedSiz=!rRec.bTextRota90 ? rPol.aTextSize.Width() : rPol.aTextSize.Height(); + if (nNeedSiz>rPol.nLineLen) bOutside = true; // text doesn't fit in between + if (bBrkLine) { + if (nNeedSiz+nArrowNeed>rPol.nLineLen) bPfeileAussen = true; // text fits in between, if arrowheads are on the outside + } else { + tools::Long nSmallNeed=nArrow1Len+nArrow2Len+(nArrow1Wdt+nArrow2Wdt)/2/4; + if (nNeedSiz+nSmallNeed>rPol.nLineLen) bPfeileAussen = true; // text fits in between, if arrowheads are on the outside + } + rPol.eUsedTextHPos=bOutside ? css::drawing::MeasureTextHorzPos_LEFTOUTSIDE : css::drawing::MeasureTextHorzPos_INSIDE; + } + if (rPol.eUsedTextHPos != css::drawing::MeasureTextHorzPos_INSIDE) bPfeileAussen = true; + rPol.nArrow1Wdt=nArrow1Wdt; + rPol.nArrow2Wdt=nArrow2Wdt; + rPol.nShortLineLen=nShortLen; + rPol.nArrow1Len=nArrow1Len; + rPol.nArrow2Len=nArrow2Len; + + rPol.nLineAngle=GetAngle(aDelt); + double a = toRadians(rPol.nLineAngle); + double nLineSin=sin(a); + double nLineCos=cos(a); + rPol.nLineSin=nLineSin; + rPol.nLineCos=nLineCos; + + rPol.nTextAngle=rPol.nLineAngle; + if (rRec.bTextRota90) rPol.nTextAngle+=9000_deg100; + + rPol.bAutoUpsideDown=false; + if (rRec.bTextAutoAngle) { + Degree100 nTmpAngle=NormAngle36000(rPol.nTextAngle-rRec.nTextAutoAngleView); + if (nTmpAngle>=18000_deg100) { + rPol.nTextAngle+=18000_deg100; + rPol.bAutoUpsideDown=true; + } + } + + if (rRec.bTextUpsideDown) rPol.nTextAngle+=18000_deg100; + rPol.nTextAngle=NormAngle36000(rPol.nTextAngle); + rPol.nHlpAngle=rPol.nLineAngle+9000_deg100; + if (rRec.bBelowRefEdge) rPol.nHlpAngle+=18000_deg100; + rPol.nHlpAngle=NormAngle36000(rPol.nHlpAngle); + double nHlpSin=nLineCos; + double nHlpCos=-nLineSin; + if (rRec.bBelowRefEdge) { + nHlpSin=-nHlpSin; + nHlpCos=-nHlpCos; + } + + tools::Long nLineDist=rRec.nLineDist; + tools::Long nOverhang=rRec.nHelplineOverhang; + tools::Long nHelplineDist=rRec.nHelplineDist; + + tools::Long dx= FRound(nLineDist*nHlpCos); + tools::Long dy=-FRound(nLineDist*nHlpSin); + tools::Long dxh1a= FRound((nHelplineDist-rRec.nHelpline1Len)*nHlpCos); + tools::Long dyh1a=-FRound((nHelplineDist-rRec.nHelpline1Len)*nHlpSin); + tools::Long dxh1b= FRound((nHelplineDist-rRec.nHelpline2Len)*nHlpCos); + tools::Long dyh1b=-FRound((nHelplineDist-rRec.nHelpline2Len)*nHlpSin); + tools::Long dxh2= FRound((nLineDist+nOverhang)*nHlpCos); + tools::Long dyh2=-FRound((nLineDist+nOverhang)*nHlpSin); + + // extension line 1 + rPol.aHelpline1.aP1=Point(aP1.X()+dxh1a,aP1.Y()+dyh1a); + rPol.aHelpline1.aP2=Point(aP1.X()+dxh2,aP1.Y()+dyh2); + + // extension line 2 + rPol.aHelpline2.aP1=Point(aP2.X()+dxh1b,aP2.Y()+dyh1b); + rPol.aHelpline2.aP2=Point(aP2.X()+dxh2,aP2.Y()+dyh2); + + // dimension line + Point aMainlinePt1(aP1.X()+dx,aP1.Y()+dy); + Point aMainlinePt2(aP2.X()+dx,aP2.Y()+dy); + if (!bPfeileAussen) { + rPol.aMainline1.aP1=aMainlinePt1; + rPol.aMainline1.aP2=aMainlinePt2; + rPol.aMainline2=rPol.aMainline1; + rPol.aMainline3=rPol.aMainline1; + rPol.nMainlineCnt=1; + if (bBrkLine) { + tools::Long nNeedSiz=!rRec.bTextRota90 ? rPol.aTextSize.Width() : rPol.aTextSize.Height(); + tools::Long nHalfLen=(rPol.nLineLen-nNeedSiz-nArrow1Wdt/4-nArrow2Wdt/4) /2; + rPol.nMainlineCnt=2; + rPol.aMainline1.aP2=aMainlinePt1; + rPol.aMainline1.aP2.AdjustX(nHalfLen ); + RotatePoint(rPol.aMainline1.aP2,rPol.aMainline1.aP1,nLineSin,nLineCos); + rPol.aMainline2.aP1=aMainlinePt2; + rPol.aMainline2.aP1.AdjustX( -nHalfLen ); + RotatePoint(rPol.aMainline2.aP1,rPol.aMainline2.aP2,nLineSin,nLineCos); + } + } else { + tools::Long nLen1=nShortLen; // arrowhead's width as line length outside of the arrowhead + tools::Long nLen2=nShortLen; + tools::Long nTextWdt=rRec.bTextRota90 ? rPol.aTextSize.Height() : rPol.aTextSize.Width(); + if (!bBrkLine) { + if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_LEFTOUTSIDE) nLen1=nArrow1Len+nTextWdt; + if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE) nLen2=nArrow2Len+nTextWdt; + } + rPol.aMainline1.aP1=aMainlinePt1; + rPol.aMainline1.aP2=aMainlinePt1; rPol.aMainline1.aP2.AdjustX( -nLen1 ); RotatePoint(rPol.aMainline1.aP2,aMainlinePt1,nLineSin,nLineCos); + rPol.aMainline2.aP1=aMainlinePt2; rPol.aMainline2.aP1.AdjustX(nLen2 ); RotatePoint(rPol.aMainline2.aP1,aMainlinePt2,nLineSin,nLineCos); + rPol.aMainline2.aP2=aMainlinePt2; + rPol.aMainline3.aP1=aMainlinePt1; + rPol.aMainline3.aP2=aMainlinePt2; + rPol.nMainlineCnt=3; + if (bBrkLine && rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_INSIDE) rPol.nMainlineCnt=2; + } +} + +basegfx::B2DPolyPolygon SdrMeasureObj::ImpCalcXPoly(const ImpMeasurePoly& rPol) +{ + basegfx::B2DPolyPolygon aRetval; + basegfx::B2DPolygon aPartPolyA; + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline1.aP1.X(), rPol.aMainline1.aP1.Y())); + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline1.aP2.X(), rPol.aMainline1.aP2.Y())); + aRetval.append(aPartPolyA); + + if(rPol.nMainlineCnt > 1) + { + aPartPolyA.clear(); + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline2.aP1.X(), rPol.aMainline2.aP1.Y())); + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline2.aP2.X(), rPol.aMainline2.aP2.Y())); + aRetval.append(aPartPolyA); + } + + if(rPol.nMainlineCnt > 2) + { + aPartPolyA.clear(); + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline3.aP1.X(), rPol.aMainline3.aP1.Y())); + aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline3.aP2.X(), rPol.aMainline3.aP2.Y())); + aRetval.append(aPartPolyA); + } + + aPartPolyA.clear(); + aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline1.aP1.X(), rPol.aHelpline1.aP1.Y())); + aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline1.aP2.X(), rPol.aHelpline1.aP2.Y())); + aRetval.append(aPartPolyA); + + aPartPolyA.clear(); + aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline2.aP1.X(), rPol.aHelpline2.aP1.Y())); + aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline2.aP2.X(), rPol.aHelpline2.aP2.Y())); + aRetval.append(aPartPolyA); + + return aRetval; +} + +bool SdrMeasureObj::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_uInt16 nPos, + bool bEdit, + std::optional& rpTxtColor, std::optional& rpFldColor, std::optional& rpFldLineStyle, OUString& rRet) const +{ + const SvxFieldData* pField=rField.GetField(); + const SdrMeasureField* pMeasureField=dynamic_cast( pField ); + if (pMeasureField!=nullptr) { + rRet = TakeRepresentation(pMeasureField->GetMeasureFieldKind()); + if (rpFldColor && !bEdit) + { + rpFldColor.reset(); + } + return true; + } else { + return SdrTextObj::CalcFieldValue(rField,nPara,nPos,bEdit,rpTxtColor,rpFldColor,rpFldLineStyle,rRet); + } +} + +void SdrMeasureObj::UndirtyText() const +{ + if (!bTextDirty) + return; + + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + OutlinerParaObject* pOutlinerParaObject = SdrTextObj::GetOutlinerParaObject(); + if(pOutlinerParaObject==nullptr) + { + rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Rotate90Blanks), EE_FEATURE_FIELD), ESelection(0,0)); + rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Value), EE_FEATURE_FIELD),ESelection(0,1)); + rOutliner.QuickInsertText(" ", ESelection(0,2)); + rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Unit), EE_FEATURE_FIELD),ESelection(0,3)); + rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Rotate90Blanks), EE_FEATURE_FIELD),ESelection(0,4)); + + if(GetStyleSheet()) + rOutliner.SetStyleSheet(0, GetStyleSheet()); + + rOutliner.SetParaAttribs(0, GetObjectItemSet()); + + // cast to nonconst + const_cast(this)->NbcSetOutlinerParaObject( rOutliner.CreateParaObject() ); + } + else + { + rOutliner.SetText(*pOutlinerParaObject); + } + + rOutliner.SetUpdateLayout(true); + rOutliner.UpdateFields(); + Size aSiz(rOutliner.CalcTextSize()); + rOutliner.Clear(); + // cast to nonconst three times + const_cast(this)->maTextSize = aSiz; + const_cast(this)->mbTextSizeDirty = false; + const_cast(this)->bTextDirty = false; +} + +void SdrMeasureObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + if (bTextDirty) UndirtyText(); + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + ImpTakeAttr(aRec); + ImpCalcGeometrics(aRec,aMPol); + + // determine TextSize including text frame margins + Size aTextSize2(aMPol.aTextSize); + if (aTextSize2.Width()<1) aTextSize2.setWidth(1 ); + if (aTextSize2.Height()<1) aTextSize2.setHeight(1 ); + aTextSize2.AdjustWidth(GetTextLeftDistance()+GetTextRightDistance() ); + aTextSize2.AdjustHeight(GetTextUpperDistance()+GetTextLowerDistance() ); + + Point aPt1b(aMPol.aMainline1.aP1); + tools::Long nLen=aMPol.nLineLen; + tools::Long nLWdt=aMPol.nLineWdt2; + tools::Long nArr1Len=aMPol.nArrow1Len; + tools::Long nArr2Len=aMPol.nArrow2Len; + if (aMPol.bBreakedLine) { + // In the case of a dashed line and Outside, the text should be + // placed next to the line at the arrowhead instead of directly + // at the arrowhead. + nArr1Len=aMPol.nShortLineLen+aMPol.nArrow1Wdt/4; + nArr2Len=aMPol.nShortLineLen+aMPol.nArrow2Wdt/4; + } + + Point aTextPos; + bool bRota90=aRec.bTextRota90; + bool bUpsideDown=aRec.bTextUpsideDown!=aMPol.bAutoUpsideDown; + bool bBelowRefEdge=aRec.bBelowRefEdge; + css::drawing::MeasureTextHorzPos eMH=aMPol.eUsedTextHPos; + css::drawing::MeasureTextVertPos eMV=aMPol.eUsedTextVPos; + if (!bRota90) { + switch (eMH) { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: aTextPos.setX(aPt1b.X()-aTextSize2.Width()-nArr1Len-nLWdt ); break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: aTextPos.setX(aPt1b.X()+nLen+nArr2Len+nLWdt ); break; + default: aTextPos.setX(aPt1b.X() ); aTextSize2.setWidth(nLen ); + } + switch (eMV) { + case css::drawing::MeasureTextVertPos_CENTERED: + aTextPos.setY(aPt1b.Y()-aTextSize2.Height()/2 ); break; + case css::drawing::MeasureTextVertPos_WEST: { + if (!bUpsideDown) aTextPos.setY(aPt1b.Y()+nLWdt ); + else aTextPos.setY(aPt1b.Y()-aTextSize2.Height()-nLWdt ); + } break; + default: { + if (!bUpsideDown) aTextPos.setY(aPt1b.Y()-aTextSize2.Height()-nLWdt ); + else aTextPos.setY(aPt1b.Y()+nLWdt ); + } + } + if (bUpsideDown) { + aTextPos.AdjustX(aTextSize2.Width() ); + aTextPos.AdjustY(aTextSize2.Height() ); + } + } else { // also if bTextRota90==TRUE + switch (eMH) { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: aTextPos.setX(aPt1b.X()-aTextSize2.Height()-nArr1Len ); break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: aTextPos.setX(aPt1b.X()+nLen+nArr2Len ); break; + default: aTextPos.setX(aPt1b.X() ); aTextSize2.setHeight(nLen ); + } + switch (eMV) { + case css::drawing::MeasureTextVertPos_CENTERED: + aTextPos.setY(aPt1b.Y()+aTextSize2.Width()/2 ); break; + case css::drawing::MeasureTextVertPos_WEST: { + if (!bBelowRefEdge) aTextPos.setY(aPt1b.Y()+aTextSize2.Width()+nLWdt ); + else aTextPos.setY(aPt1b.Y()-nLWdt ); + } break; + default: { + if (!bBelowRefEdge) aTextPos.setY(aPt1b.Y()-nLWdt ); + else aTextPos.setY(aPt1b.Y()+aTextSize2.Width()+nLWdt ); + } + } + if (bUpsideDown) { + aTextPos.AdjustX(aTextSize2.Height() ); + aTextPos.AdjustY( -(aTextSize2.Width()) ); + } + } + if (aMPol.nTextAngle != maGeo.m_nRotationAngle) { + const_cast(this)->maGeo.m_nRotationAngle=aMPol.nTextAngle; + const_cast(this)->maGeo.RecalcSinCos(); + } + RotatePoint(aTextPos,aPt1b,aMPol.nLineSin,aMPol.nLineCos); + aTextSize2.AdjustWidth( 1 ); aTextSize2.AdjustHeight( 1 ); // because of the Rect-Ctor's odd behavior + rRect=tools::Rectangle(aTextPos,aTextSize2); + rRect.Normalize(); + const_cast(this)->setRectangle(rRect); + + if (aMPol.nTextAngle != maGeo.m_nRotationAngle) { + const_cast(this)->maGeo.m_nRotationAngle=aMPol.nTextAngle; + const_cast(this)->maGeo.RecalcSinCos(); + } +} + +rtl::Reference SdrMeasureObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrMeasureObj(rTargetModel, *this); +} + +OUString SdrMeasureObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulMEASURE)); + + OUString aName( GetName() ); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrMeasureObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralMEASURE); +} + +basegfx::B2DPolyPolygon SdrMeasureObj::TakeXorPoly() const +{ + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + ImpTakeAttr(aRec); + ImpCalcGeometrics(aRec,aMPol); + return ImpCalcXPoly(aMPol); +} + +sal_uInt32 SdrMeasureObj::GetHdlCount() const +{ + return 6; +} + +void SdrMeasureObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + ImpTakeAttr(aRec); + aRec.nHelplineDist=0; + ImpCalcGeometrics(aRec,aMPol); + + for (sal_uInt32 nHdlNum=0; nHdlNum<6; ++nHdlNum) + { + Point aPt; + switch (nHdlNum) { + case 0: aPt=aMPol.aHelpline1.aP1; break; + case 1: aPt=aMPol.aHelpline2.aP1; break; + case 2: aPt=aPt1; break; + case 3: aPt=aPt2; break; + case 4: aPt=aMPol.aHelpline1.aP2; break; + case 5: aPt=aMPol.aHelpline2.aP2; break; + } // switch + std::unique_ptr pHdl(new ImpMeasureHdl(aPt,SdrHdlKind::User)); + pHdl->SetObjHdlNum(nHdlNum); + pHdl->SetRotationAngle(aMPol.nLineAngle); + rHdlList.AddHdl(std::move(pHdl)); + } +} + + +bool SdrMeasureObj::hasSpecialDrag() const +{ + return true; +} + +bool SdrMeasureObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const SdrHdl* pHdl = rDrag.GetHdl(); + + if(pHdl) + { + const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum()); + + if(nHdlNum != 2 && nHdlNum != 3) + { + rDrag.SetEndDragChangesAttributes(true); + } + + return true; + } + + return false; +} + +bool SdrMeasureObj::applySpecialDrag(SdrDragStat& rDrag) +{ + ImpMeasureRec aMeasureRec; + const SdrHdl* pHdl = rDrag.GetHdl(); + const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum()); + + ImpTakeAttr(aMeasureRec); + ImpEvalDrag(aMeasureRec, rDrag); + + switch (nHdlNum) + { + case 2: + { + aPt1 = aMeasureRec.aPt1; + SetTextDirty(); + break; + } + case 3: + { + aPt2 = aMeasureRec.aPt2; + SetTextDirty(); + break; + } + default: + { + switch(nHdlNum) + { + case 0: + case 1: + { + ImpMeasureRec aOrigMeasureRec; + ImpTakeAttr(aOrigMeasureRec); + + if(aMeasureRec.nHelpline1Len != aOrigMeasureRec.nHelpline1Len) + { + SetObjectItem(makeSdrMeasureHelpline1LenItem(aMeasureRec.nHelpline1Len)); + } + + if(aMeasureRec.nHelpline2Len != aOrigMeasureRec.nHelpline2Len) + { + SetObjectItem(makeSdrMeasureHelpline2LenItem(aMeasureRec.nHelpline2Len)); + } + + break; + } + + case 4: + case 5: + { + ImpMeasureRec aOrigMeasureRec; + ImpTakeAttr(aOrigMeasureRec); + + if(aMeasureRec.nLineDist != aOrigMeasureRec.nLineDist) + { + SetObjectItem(makeSdrMeasureLineDistItem(aMeasureRec.nLineDist)); + } + + if(aMeasureRec.bBelowRefEdge != aOrigMeasureRec.bBelowRefEdge) + { + SetObjectItem(SdrMeasureBelowRefEdgeItem(aMeasureRec.bBelowRefEdge)); + } + } + } + } + } // switch + + SetBoundAndSnapRectsDirty(); + SetChanged(); + + return true; +} + +OUString SdrMeasureObj::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const +{ + return OUString(); +} + +void SdrMeasureObj::ImpEvalDrag(ImpMeasureRec& rRec, const SdrDragStat& rDrag) const +{ + Degree100 nLineAngle=GetAngle(rRec.aPt2-rRec.aPt1); + double a = toRadians(nLineAngle); + double nSin=sin(a); + double nCos=cos(a); + + const SdrHdl* pHdl=rDrag.GetHdl(); + sal_uInt32 nHdlNum(pHdl->GetObjHdlNum()); + bool bOrtho=rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho(); + bool bBigOrtho=bOrtho && rDrag.GetView()->IsBigOrtho(); + bool bBelow=rRec.bBelowRefEdge; + Point aPt(rDrag.GetNow()); + + switch (nHdlNum) { + case 0: { + RotatePoint(aPt,aPt1,nSin,-nCos); + rRec.nHelpline1Len=aPt1.Y()-aPt.Y(); + if (bBelow) rRec.nHelpline1Len=-rRec.nHelpline1Len; + if (bOrtho) rRec.nHelpline2Len=rRec.nHelpline1Len; + } break; + case 1: { + RotatePoint(aPt,aPt2,nSin,-nCos); + rRec.nHelpline2Len=aPt2.Y()-aPt.Y(); + if (bBelow) rRec.nHelpline2Len=-rRec.nHelpline2Len; + if (bOrtho) rRec.nHelpline1Len=rRec.nHelpline2Len; + } break; + case 2: case 3: { + bool bAnf=nHdlNum==2; + Point& rMov=bAnf ? rRec.aPt1 : rRec.aPt2; + Point aMov(rMov); + Point aFix(bAnf ? rRec.aPt2 : rRec.aPt1); + if (bOrtho) { + tools::Long ndx0=aMov.X()-aFix.X(); + tools::Long ndy0=aMov.Y()-aFix.Y(); + bool bHLin=ndy0==0; + bool bVLin=ndx0==0; + if (!bHLin || !bVLin) { // else aPt1==aPt2 + tools::Long ndx=aPt.X()-aFix.X(); + tools::Long ndy=aPt.Y()-aFix.Y(); + double nXFact=0; if (!bVLin) nXFact=static_cast(ndx)/static_cast(ndx0); + double nYFact=0; if (!bHLin) nYFact=static_cast(ndy)/static_cast(ndy0); + bool bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho); + bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho); + if (bHor) ndy=tools::Long(ndy0*nXFact); + if (bVer) ndx=tools::Long(ndx0*nYFact); + aPt=aFix; + aPt.AdjustX(ndx ); + aPt.AdjustY(ndy ); + } // else Ortho8 + } + rMov=aPt; + } break; + case 4: case 5: { + tools::Long nVal0=rRec.nLineDist; + RotatePoint(aPt,(nHdlNum==4 ? aPt1 : aPt2),nSin,-nCos); + rRec.nLineDist=aPt.Y()- (nHdlNum==4 ? aPt1.Y() : aPt2.Y()); + if (bBelow) rRec.nLineDist=-rRec.nLineDist; + if (rRec.nLineDist<0) { + rRec.nLineDist=-rRec.nLineDist; + rRec.bBelowRefEdge=!bBelow; + } + rRec.nLineDist-=rRec.nHelplineOverhang; + if (bOrtho) rRec.nLineDist=nVal0; + } break; + } // switch +} + + +bool SdrMeasureObj::BegCreate(SdrDragStat& rStat) +{ + rStat.SetOrtho8Possible(); + aPt1=rStat.GetStart(); + aPt2=rStat.GetNow(); + SetTextDirty(); + return true; +} + +bool SdrMeasureObj::MovCreate(SdrDragStat& rStat) +{ + SdrView* pView=rStat.GetView(); + aPt1=rStat.GetStart(); + aPt2=rStat.GetNow(); + if (pView!=nullptr && pView->IsCreate1stPointAsCenter()) { + aPt1+=aPt1; + aPt1-=rStat.GetNow(); + } + SetTextDirty(); + SetBoundRectDirty(); + m_bSnapRectDirty=true; + return true; +} + +bool SdrMeasureObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + SetTextDirty(); + SetBoundAndSnapRectsDirty(); + return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2); +} + +bool SdrMeasureObj::BckCreate(SdrDragStat& /*rStat*/) +{ + return false; +} + +void SdrMeasureObj::BrkCreate(SdrDragStat& /*rStat*/) +{ +} + +basegfx::B2DPolyPolygon SdrMeasureObj::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const +{ + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + + ImpTakeAttr(aRec); + ImpCalcGeometrics(aRec, aMPol); + + return ImpCalcXPoly(aMPol); +} + +PointerStyle SdrMeasureObj::GetCreatePointer() const +{ + return PointerStyle::Cross; +} + +void SdrMeasureObj::NbcMove(const Size& rSiz) +{ + SdrTextObj::NbcMove(rSiz); + aPt1.Move(rSiz); + aPt2.Move(rSiz); +} + +void SdrMeasureObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + SdrTextObj::NbcResize(rRef,xFact,yFact); + ResizePoint(aPt1,rRef,xFact,yFact); + ResizePoint(aPt2,rRef,xFact,yFact); + SetTextDirty(); +} + +void SdrMeasureObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + SdrTextObj::NbcRotate(rRef,nAngle,sn,cs); + tools::Long nLen0=GetLen(aPt2-aPt1); + RotatePoint(aPt1,rRef,sn,cs); + RotatePoint(aPt2,rRef,sn,cs); + tools::Long nLen1=GetLen(aPt2-aPt1); + if (nLen1!=nLen0) { // rounding error! + tools::Long dx=aPt2.X()-aPt1.X(); + tools::Long dy=aPt2.Y()-aPt1.Y(); + dx=BigMulDiv(dx,nLen0,nLen1); + dy=BigMulDiv(dy,nLen0,nLen1); + if (rRef==aPt2) { + aPt1.setX(aPt2.X()-dx ); + aPt1.setY(aPt2.Y()-dy ); + } else { + aPt2.setX(aPt1.X()+dx ); + aPt2.setY(aPt1.Y()+dy ); + } + } + SetBoundAndSnapRectsDirty(); +} + +void SdrMeasureObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + SdrTextObj::NbcMirror(rRef1,rRef2); + MirrorPoint(aPt1,rRef1,rRef2); + MirrorPoint(aPt2,rRef1,rRef2); + SetBoundAndSnapRectsDirty(); +} + +void SdrMeasureObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + SdrTextObj::NbcShear(rRef,nAngle,tn,bVShear); + ShearPoint(aPt1,rRef,tn,bVShear); + ShearPoint(aPt2,rRef,tn,bVShear); + SetBoundAndSnapRectsDirty(); + SetTextDirty(); +} + +Degree100 SdrMeasureObj::GetRotateAngle() const +{ + return GetAngle(aPt2-aPt1); +} + +void SdrMeasureObj::RecalcSnapRect() +{ + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + XPolyPolygon aXPP; + + ImpTakeAttr(aRec); + ImpCalcGeometrics(aRec, aMPol); + aXPP = XPolyPolygon(ImpCalcXPoly(aMPol)); + maSnapRect = aXPP.GetBoundRect(); +} + +sal_uInt32 SdrMeasureObj::GetSnapPointCount() const +{ + return 2; +} + +Point SdrMeasureObj::GetSnapPoint(sal_uInt32 i) const +{ + if (i==0) return aPt1; + else return aPt2; +} + +bool SdrMeasureObj::IsPolyObj() const +{ + return true; +} + +sal_uInt32 SdrMeasureObj::GetPointCount() const +{ + return 2; +} + +Point SdrMeasureObj::GetPoint(sal_uInt32 i) const +{ + return (0 == i) ? aPt1 : aPt2; +} + +void SdrMeasureObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i) +{ + if (0 == i) + aPt1=rPnt; + if (1 == i) + aPt2=rPnt; + SetBoundAndSnapRectsDirty(); + SetTextDirty(); +} + +std::unique_ptr SdrMeasureObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrMeasureObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrTextObj::SaveGeoData(rGeo); + SdrMeasureObjGeoData& rMGeo=static_cast(rGeo); + rMGeo.aPt1=aPt1; + rMGeo.aPt2=aPt2; +} + +void SdrMeasureObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrTextObj::RestoreGeoData(rGeo); + const SdrMeasureObjGeoData& rMGeo=static_cast(rGeo); + aPt1=rMGeo.aPt1; + aPt2=rMGeo.aPt2; + SetTextDirty(); +} + +rtl::Reference SdrMeasureObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + // get XOR Poly as base + XPolyPolygon aTmpPolyPolygon(TakeXorPoly()); + + // get local ItemSet and StyleSheet + SfxItemSet aSet(GetObjectItemSet()); + SfxStyleSheet* pStyleSheet = GetStyleSheet(); + + // prepare group + rtl::Reference pGroup(new SdrObjGroup(getSdrModelFromSdrObject())); + + // prepare parameters + basegfx::B2DPolyPolygon aPolyPoly; + rtl::Reference pPath; + sal_uInt16 nCount(aTmpPolyPolygon.Count()); + sal_uInt16 nLoopStart(0); + + if(nCount == 3) + { + // three lines, first one is the middle one + aPolyPoly.clear(); + aPolyPoly.append(aTmpPolyPolygon[0].getB2DPolygon()); + + pPath = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + aPolyPoly); + + pPath->SetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + aSet.Put(XLineStartWidthItem(0)); + aSet.Put(XLineEndWidthItem(0)); + nLoopStart = 1; + } + else if(nCount == 4) + { + // four lines, middle line with gap, so there are two lines used + // which have one arrow each + sal_Int32 nEndWidth = aSet.Get(XATTR_LINEENDWIDTH).GetValue(); + aSet.Put(XLineEndWidthItem(0)); + + aPolyPoly.clear(); + aPolyPoly.append(aTmpPolyPolygon[0].getB2DPolygon()); + pPath = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + aPolyPoly); + + pPath->SetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + + aSet.Put(XLineEndWidthItem(nEndWidth)); + aSet.Put(XLineStartWidthItem(0)); + + aPolyPoly.clear(); + aPolyPoly.append(aTmpPolyPolygon[1].getB2DPolygon()); + pPath = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + aPolyPoly); + + pPath->SetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + + aSet.Put(XLineEndWidthItem(0)); + nLoopStart = 2; + } + else if(nCount == 5) + { + // five lines, first two are the outer ones + sal_Int32 nEndWidth = aSet.Get(XATTR_LINEENDWIDTH).GetValue(); + + aSet.Put(XLineEndWidthItem(0)); + + aPolyPoly.clear(); + aPolyPoly.append(aTmpPolyPolygon[0].getB2DPolygon()); + pPath = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + aPolyPoly); + + pPath->SetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + + aSet.Put(XLineEndWidthItem(nEndWidth)); + aSet.Put(XLineStartWidthItem(0)); + + aPolyPoly.clear(); + aPolyPoly.append(aTmpPolyPolygon[1].getB2DPolygon()); + pPath = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + aPolyPoly); + + pPath->SetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + + aSet.Put(XLineEndWidthItem(0)); + nLoopStart = 2; + } + + for(;nLoopStartSetMergedItemSet(aSet); + pPath->SetStyleSheet(pStyleSheet, true); + + pGroup->GetSubList()->NbcInsertObject(pPath.get()); + } + + if(bAddText) + { + return ImpConvertAddText(std::move(pGroup), bBezier); + } + else + { + return pGroup; + } +} + +bool SdrMeasureObj::BegTextEdit(SdrOutliner& rOutl) +{ + UndirtyText(); + return SdrTextObj::BegTextEdit(rOutl); +} + +const Size& SdrMeasureObj::GetTextSize() const +{ + if (bTextDirty) UndirtyText(); + return SdrTextObj::GetTextSize(); +} + +OutlinerParaObject* SdrMeasureObj::GetOutlinerParaObject() const +{ + if(bTextDirty) + UndirtyText(); + return SdrTextObj::GetOutlinerParaObject(); +} + +void SdrMeasureObj::NbcSetOutlinerParaObject(std::optional pTextObject) +{ + SdrTextObj::NbcSetOutlinerParaObject(std::move(pTextObject)); + if(SdrTextObj::GetOutlinerParaObject()) + SetTextDirty(); // recalculate text +} + +void SdrMeasureObj::TakeTextRect( SdrOutliner& rOutliner, tools::Rectangle& rTextRect, bool bNoEditText, + tools::Rectangle* pAnchorRect, bool bLineWidth ) const +{ + if (bTextDirty) UndirtyText(); + SdrTextObj::TakeTextRect( rOutliner, rTextRect, bNoEditText, pAnchorRect, bLineWidth ); +} + +void SdrMeasureObj::TakeTextAnchorRect(tools::Rectangle& rAnchorRect) const +{ + if (bTextDirty) UndirtyText(); + SdrTextObj::TakeTextAnchorRect(rAnchorRect); +} + +void SdrMeasureObj::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, tools::Rectangle* pViewInit, tools::Rectangle* pViewMin) const +{ + if (bTextDirty) UndirtyText(); + SdrTextObj::TakeTextEditArea(pPaperMin,pPaperMax,pViewInit,pViewMin); +} + +EEAnchorMode SdrMeasureObj::GetOutlinerViewAnchorMode() const +{ + if (bTextDirty) UndirtyText(); + ImpMeasureRec aRec; + ImpMeasurePoly aMPol; + ImpTakeAttr(aRec); + ImpCalcGeometrics(aRec,aMPol); + + SdrTextHorzAdjust eTH=GetTextHorizontalAdjust(); + SdrTextVertAdjust eTV=GetTextVerticalAdjust(); + css::drawing::MeasureTextHorzPos eMH = aMPol.eUsedTextHPos; + css::drawing::MeasureTextVertPos eMV = aMPol.eUsedTextVPos; + bool bTextRota90=aRec.bTextRota90; + bool bBelowRefEdge=aRec.bBelowRefEdge; + + // TODO: bTextUpsideDown should be interpreted here! + if (!bTextRota90) { + if (eMH==css::drawing::MeasureTextHorzPos_LEFTOUTSIDE) eTH=SDRTEXTHORZADJUST_RIGHT; + if (eMH==css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE) eTH=SDRTEXTHORZADJUST_LEFT; + // at eMH==css::drawing::MeasureTextHorzPos_INSIDE we can anchor horizontally + if (eMV==css::drawing::MeasureTextVertPos_EAST) eTV=SDRTEXTVERTADJUST_BOTTOM; + if (eMV==css::drawing::MeasureTextVertPos_WEST) eTV=SDRTEXTVERTADJUST_TOP; + if (eMV==css::drawing::MeasureTextVertPos_CENTERED) eTV=SDRTEXTVERTADJUST_CENTER; + } else { + if (eMH==css::drawing::MeasureTextHorzPos_LEFTOUTSIDE) eTV=SDRTEXTVERTADJUST_BOTTOM; + if (eMH==css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE) eTV=SDRTEXTVERTADJUST_TOP; + // at eMH==css::drawing::MeasureTextHorzPos_INSIDE we can anchor vertically + if (!bBelowRefEdge) { + if (eMV==css::drawing::MeasureTextVertPos_EAST) eTH=SDRTEXTHORZADJUST_LEFT; + if (eMV==css::drawing::MeasureTextVertPos_WEST) eTH=SDRTEXTHORZADJUST_RIGHT; + } else { + if (eMV==css::drawing::MeasureTextVertPos_EAST) eTH=SDRTEXTHORZADJUST_RIGHT; + if (eMV==css::drawing::MeasureTextVertPos_WEST) eTH=SDRTEXTHORZADJUST_LEFT; + } + if (eMV==css::drawing::MeasureTextVertPos_CENTERED) eTH=SDRTEXTHORZADJUST_CENTER; + } + + EEAnchorMode eRet=EEAnchorMode::BottomHCenter; + if (eTH==SDRTEXTHORZADJUST_LEFT) { + if (eTV==SDRTEXTVERTADJUST_TOP) eRet=EEAnchorMode::TopLeft; + else if (eTV==SDRTEXTVERTADJUST_BOTTOM) eRet=EEAnchorMode::BottomLeft; + else eRet=EEAnchorMode::VCenterLeft; + } else if (eTH==SDRTEXTHORZADJUST_RIGHT) { + if (eTV==SDRTEXTVERTADJUST_TOP) eRet=EEAnchorMode::TopRight; + else if (eTV==SDRTEXTVERTADJUST_BOTTOM) eRet=EEAnchorMode::BottomRight; + else eRet=EEAnchorMode::VCenterRight; + } else { + if (eTV==SDRTEXTVERTADJUST_TOP) eRet=EEAnchorMode::TopHCenter; + else if (eTV==SDRTEXTVERTADJUST_BOTTOM) eRet=EEAnchorMode::BottomHCenter; + else eRet=EEAnchorMode::VCenterHCenter; + } + return eRet; +} + + +// #i97878# +// TRGetBaseGeometry/TRSetBaseGeometry needs to be based on two positions, +// same as line geometry in SdrPathObj. Thus needs to be overridden and +// implemented since currently it is derived from SdrTextObj which uses +// a functionality based on SnapRect which is not useful here + +bool SdrMeasureObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const +{ + // handle the same as a simple line since the definition is based on two points + const basegfx::B2DRange aRange(aPt1.X(), aPt1.Y(), aPt2.X(), aPt2.Y()); + basegfx::B2DTuple aScale(aRange.getRange()); + basegfx::B2DTuple aTranslate(aRange.getMinimum()); + + // position maybe relative to anchor position, convert + if( getSdrModelFromSdrObject().IsWriter() ) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build return value matrix + rMatrix = basegfx::utils::createScaleTranslateB2DHomMatrix(aScale, aTranslate); + + return true; +} + +void SdrMeasureObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/) +{ + // use given transformation to derive the two defining points from unit line + basegfx::B2DPoint aPosA(rMatrix * basegfx::B2DPoint(0.0, 0.0)); + basegfx::B2DPoint aPosB(rMatrix * basegfx::B2DPoint(1.0, 0.0)); + + if( getSdrModelFromSdrObject().IsWriter() ) + { + // if anchor is used, make position relative to it + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + const basegfx::B2DVector aAnchorOffset(GetAnchorPos().X(), GetAnchorPos().Y()); + + aPosA += aAnchorOffset; + aPosB += aAnchorOffset; + } + } + + // derive new model data + const Point aNewPt1(basegfx::fround(aPosA.getX()), basegfx::fround(aPosA.getY())); + const Point aNewPt2(basegfx::fround(aPosB.getX()), basegfx::fround(aPosB.getY())); + + if(aNewPt1 == aPt1 && aNewPt2 == aPt2) + return; + + // set model values and broadcast + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + + aPt1 = aNewPt1; + aPt2 = aNewPt2; + + SetTextDirty(); + ActionChanged(); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdomedia.cxx b/svx/source/svdraw/svdomedia.cxx new file mode 100644 index 0000000000..125b69312c --- /dev/null +++ b/svx/source/svdraw/svdomedia.cxx @@ -0,0 +1,472 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column:100 -*- */ +/* + * 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 + +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + + +struct SdrMediaObj::Impl +{ + ::avmedia::MediaItem m_MediaProperties; +#if HAVE_FEATURE_AVMEDIA + // Note: the temp file is read only, until it is deleted! + // It may be shared between multiple documents in case of copy/paste, + // hence the shared_ptr. + std::shared_ptr< ::avmedia::MediaTempFile > m_pTempFile; +#endif + uno::Reference< graphic::XGraphic > m_xCachedSnapshot; + rtl::Reference m_xPlayerListener; + OUString m_LastFailedPkgURL; +}; + +SdrMediaObj::SdrMediaObj(SdrModel& rSdrModel) +: SdrRectObj(rSdrModel) + ,m_xImpl( new Impl ) +{ +} + +SdrMediaObj::SdrMediaObj(SdrModel& rSdrModel, SdrMediaObj const & rSource) +: SdrRectObj(rSdrModel, rSource) + ,m_xImpl( new Impl ) +{ +#if HAVE_FEATURE_AVMEDIA + m_xImpl->m_pTempFile = rSource.m_xImpl->m_pTempFile; // before props +#endif + setMediaProperties( rSource.getMediaProperties() ); + m_xImpl->m_xCachedSnapshot = rSource.m_xImpl->m_xCachedSnapshot; +} + +SdrMediaObj::SdrMediaObj( + SdrModel& rSdrModel, + const tools::Rectangle& rRect) +: SdrRectObj(rSdrModel, rRect) + ,m_xImpl( new Impl ) +{ + osl_atomic_increment(&m_refCount); + + const bool bUndo(rSdrModel.IsUndoEnabled()); + rSdrModel.EnableUndo(false); + MakeNameUnique(); + rSdrModel.EnableUndo(bUndo); + + osl_atomic_decrement(&m_refCount); +} + +SdrMediaObj::~SdrMediaObj() +{ +} + +bool SdrMediaObj::HasTextEdit() const +{ + return false; +} + +std::unique_ptr SdrMediaObj::CreateObjectSpecificViewContact() +{ + return std::make_unique( *this ); +} + +void SdrMediaObj::TakeObjInfo( SdrObjTransformInfoRec& rInfo ) const +{ + rInfo.bMoveAllowed = true; + rInfo.bResizeFreeAllowed = true; + rInfo.bResizePropAllowed = true; + rInfo.bRotateFreeAllowed = false; + rInfo.bRotate90Allowed = false; + rInfo.bMirrorFreeAllowed = false; + rInfo.bMirror45Allowed = false; + rInfo.bMirror90Allowed = false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed = false; + rInfo.bEdgeRadiusAllowed = false; + rInfo.bNoOrthoDesired = false; + rInfo.bNoContortion = false; + rInfo.bCanConvToPath = false; + rInfo.bCanConvToPoly = false; + rInfo.bCanConvToContour = false; + rInfo.bCanConvToPathLineToArea = false; + rInfo.bCanConvToPolyLineToArea = false; +} + +SdrObjKind SdrMediaObj::GetObjIdentifier() const +{ + return SdrObjKind::Media; +} + +OUString SdrMediaObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulMEDIA)); + + OUString aName(GetName()); + + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrMediaObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralMEDIA); +} + +rtl::Reference SdrMediaObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrMediaObj(rTargetModel, *this); +} + +uno::Reference< graphic::XGraphic > const & SdrMediaObj::getSnapshot() const +{ +#if HAVE_FEATURE_AVMEDIA + if( !m_xImpl->m_xCachedSnapshot.is() ) + { + Graphic aGraphic = m_xImpl->m_MediaProperties.getGraphic(); + if (!aGraphic.IsNone()) + { + Size aPref = aGraphic.GetPrefSize(); + Size aPixel = aGraphic.GetSizePixel(); + const text::GraphicCrop& rCrop = m_xImpl->m_MediaProperties.getCrop(); + if (rCrop.Bottom > 0 || rCrop.Left > 0 || rCrop.Right > 0 || rCrop.Top > 0) + { + tools::Long nLeft = aPixel.getWidth() * rCrop.Left / aPref.getWidth(); + tools::Long nTop = aPixel.getHeight() * rCrop.Top / aPref.getHeight(); + tools::Long nRight = aPixel.getWidth() * rCrop.Right / aPref.getWidth(); + tools::Long nBottom = aPixel.getHeight() * rCrop.Bottom / aPref.getHeight(); + BitmapEx aBitmapEx = aGraphic.GetBitmapEx(); + aBitmapEx.Crop({nLeft, nTop, aPixel.getWidth() - nRight, aPixel.getHeight() - nBottom}); + aGraphic = aBitmapEx; + } + + // We have an explicit graphic for this media object, then go with that instead of + // generating our own one. + m_xImpl->m_xCachedSnapshot = aGraphic.GetXGraphic(); + return m_xImpl->m_xCachedSnapshot; + } + + OUString aRealURL = m_xImpl->m_MediaProperties.getTempURL(); + if( aRealURL.isEmpty() ) + aRealURL = m_xImpl->m_MediaProperties.getURL(); + OUString sReferer = m_xImpl->m_MediaProperties.getReferer(); + OUString sMimeType = m_xImpl->m_MediaProperties.getMimeType(); + uno::Reference xCachedSnapshot = m_xImpl->m_xCachedSnapshot; + + m_xImpl->m_xPlayerListener.set(new avmedia::PlayerListener( + [this, xCachedSnapshot, aRealURL, sReferer, sMimeType](const css::uno::Reference& rPlayer){ + SolarMutexGuard g; + uno::Reference xGraphic + = m_xImpl->m_MediaProperties.getGraphic().GetXGraphic(); + m_xImpl->m_xCachedSnapshot = avmedia::MediaWindow::grabFrame(rPlayer, xGraphic); + ActionChanged(); + })); + + avmedia::MediaWindow::grabFrame(aRealURL, sReferer, sMimeType, m_xImpl->m_xPlayerListener); + } +#endif + return m_xImpl->m_xCachedSnapshot; +} + +void SdrMediaObj::AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool bShrinkOnly /* = false */ ) +{ + Size aSize( Application::GetDefaultDevice()->PixelToLogic( + static_cast< sdr::contact::ViewContactOfSdrMediaObj& >( GetViewContact() ).getPreferredSize(), + MapMode(MapUnit::Map100thMM)) ); + Size aMaxSize( rMaxRect.GetSize() ); + + if( aSize.IsEmpty() ) + return; + + Point aPos( rMaxRect.TopLeft() ); + + // if graphic is too large, fit it to the page + if ( (!bShrinkOnly || + ( aSize.Height() > aMaxSize.Height() ) || + ( aSize.Width() > aMaxSize.Width() ) )&& + aSize.Height() && aMaxSize.Height() ) + { + float fGrfWH = static_cast(aSize.Width()) / + static_cast(aSize.Height()); + float fWinWH = static_cast(aMaxSize.Width()) / + static_cast(aMaxSize.Height()); + + // scale graphic to page size + if ( fGrfWH < fWinWH ) + { + aSize.setWidth( static_cast(aMaxSize.Height() * fGrfWH) ); + aSize.setHeight( aMaxSize.Height() ); + } + else if ( fGrfWH > 0.F ) + { + aSize.setWidth( aMaxSize.Width() ); + aSize.setHeight( static_cast(aMaxSize.Width() / fGrfWH) ); + } + + aPos = rMaxRect.Center(); + } + + if( bShrinkOnly ) + aPos = getRectangle().TopLeft(); + + aPos.AdjustX( -(aSize.Width() / 2) ); + aPos.AdjustY( -(aSize.Height() / 2) ); + SetLogicRect( tools::Rectangle( aPos, aSize ) ); +} + +void SdrMediaObj::setURL(const OUString& rURL, const OUString& rReferer) +{ + ::avmedia::MediaItem aURLItem; +#if HAVE_FEATURE_AVMEDIA + aURLItem.setURL( rURL, "", rReferer ); +#else + (void) rURL; + (void) rReferer; +#endif + setMediaProperties( aURLItem ); +} + +const OUString& SdrMediaObj::getURL() const +{ +#if HAVE_FEATURE_AVMEDIA + return m_xImpl->m_MediaProperties.getURL(); +#else + static OUString ret; + return ret; +#endif +} + +const OUString& SdrMediaObj::getTempURL() const +{ +#if HAVE_FEATURE_AVMEDIA + return m_xImpl->m_MediaProperties.getTempURL(); +#else +static OUString ret; + return ret; +#endif +} + +void SdrMediaObj::setMediaProperties( const ::avmedia::MediaItem& rState ) +{ + mediaPropertiesChanged( rState ); + static_cast< sdr::contact::ViewContactOfSdrMediaObj& >( GetViewContact() ).executeMediaItem( getMediaProperties() ); +} + +const ::avmedia::MediaItem& SdrMediaObj::getMediaProperties() const +{ + return m_xImpl->m_MediaProperties; +} + +uno::Reference SdrMediaObj::GetInputStream() const +{ +#if HAVE_FEATURE_AVMEDIA + if (!m_xImpl->m_pTempFile) + { + SAL_WARN("svx", "this is only intended for embedded media"); + return nullptr; + } + ucbhelper::Content tempFile(m_xImpl->m_pTempFile->m_TempFileURL, + uno::Reference(), + comphelper::getProcessComponentContext()); + return tempFile.openStream(); +#else + return nullptr; +#endif +} + +void SdrMediaObj::SetInputStream(uno::Reference const& xStream) +{ +#if !HAVE_FEATURE_AVMEDIA + (void) xStream; +#else + if (m_xImpl->m_pTempFile || m_xImpl->m_LastFailedPkgURL.isEmpty()) + { + SAL_WARN("svx", "this is only intended for embedded media"); + return; + } + + OUString tempFileURL; + const bool bSuccess( + ::avmedia::CreateMediaTempFile( + xStream, + tempFileURL, + u"")); + + if (bSuccess) + { + m_xImpl->m_pTempFile = std::make_shared<::avmedia::MediaTempFile>(tempFileURL); + m_xImpl->m_MediaProperties.setURL( + m_xImpl->m_LastFailedPkgURL, tempFileURL, ""); + } + m_xImpl->m_LastFailedPkgURL.clear(); // once only +#endif +} + +/// copy a stream from XStorage to temp file +#if HAVE_FEATURE_AVMEDIA +static bool lcl_HandlePackageURL( + OUString const & rURL, + const SdrModel& rModel, + OUString & o_rTempFileURL) +{ + ::comphelper::LifecycleProxy sourceProxy; + uno::Reference xInStream; + try { + xInStream = rModel.GetDocumentStream(rURL, sourceProxy); + } + catch (container::NoSuchElementException const&) + { + SAL_INFO("svx", "not found: '" << rURL << "'"); + return false; + } + catch (uno::Exception const&) + { + TOOLS_WARN_EXCEPTION("svx", ""); + return false; + } + if (!xInStream.is()) + { + SAL_WARN("svx", "no stream?"); + return false; + } + // Make sure the temporary copy has the same file name extension as the original media file + // (like .mp4). That seems to be important for some AVFoundation APIs. For random extension-less + // file names, they don't seem to even bother looking inside the file. + sal_Int32 nLastDot = rURL.lastIndexOf('.'); + sal_Int32 nLastSlash = rURL.lastIndexOf('/'); + OUString sDesiredExtension; + if (nLastDot > nLastSlash && nLastDot+1 < rURL.getLength()) + sDesiredExtension = rURL.copy(nLastDot); + return ::avmedia::CreateMediaTempFile(xInStream, o_rTempFileURL, sDesiredExtension); +} +#endif + +void SdrMediaObj::mediaPropertiesChanged( const ::avmedia::MediaItem& rNewProperties ) +{ + bool bBroadcastChanged = false; +#if HAVE_FEATURE_AVMEDIA + const AVMediaSetMask nMaskSet = rNewProperties.getMaskSet(); + + // use only a subset of MediaItem properties for own properties + if( AVMediaSetMask::MIME_TYPE & nMaskSet ) + m_xImpl->m_MediaProperties.setMimeType( rNewProperties.getMimeType() ); + + if (nMaskSet & AVMediaSetMask::GRAPHIC) + { + m_xImpl->m_MediaProperties.setGraphic(rNewProperties.getGraphic()); + } + + if (nMaskSet & AVMediaSetMask::CROP) + { + m_xImpl->m_MediaProperties.setCrop(rNewProperties.getCrop()); + } + + if( ( AVMediaSetMask::URL & nMaskSet ) && + ( rNewProperties.getURL() != getURL() )) + { + m_xImpl->m_xCachedSnapshot.clear(); + m_xImpl->m_xPlayerListener.clear(); + OUString const& url(rNewProperties.getURL()); + if (url.startsWithIgnoreAsciiCase("vnd.sun.star.Package:")) + { + if ( !m_xImpl->m_pTempFile + || (m_xImpl->m_pTempFile->m_TempFileURL != + rNewProperties.getTempURL())) + { + OUString tempFileURL; + const bool bSuccess( + lcl_HandlePackageURL( + url, + getSdrModelFromSdrObject(), + tempFileURL)); + + if (bSuccess) + { + m_xImpl->m_pTempFile = + std::make_shared<::avmedia::MediaTempFile>(tempFileURL); + m_xImpl->m_MediaProperties.setURL(url, tempFileURL, ""); + } + else // this case is for Clone via operator= + { + m_xImpl->m_pTempFile.reset(); + m_xImpl->m_MediaProperties.setURL("", "", ""); + // UGLY: oox import also gets here, because unlike ODF + // getDocumentStorage() is not the imported file... + m_xImpl->m_LastFailedPkgURL = url; + } + } + else + { + m_xImpl->m_MediaProperties.setURL(url, + rNewProperties.getTempURL(), ""); + } + } + else + { + m_xImpl->m_pTempFile.reset(); + m_xImpl->m_MediaProperties.setURL(url, "", rNewProperties.getReferer()); + } + bBroadcastChanged = true; + } + + if( AVMediaSetMask::LOOP & nMaskSet ) + m_xImpl->m_MediaProperties.setLoop( rNewProperties.isLoop() ); + + if( AVMediaSetMask::MUTE & nMaskSet ) + m_xImpl->m_MediaProperties.setMute( rNewProperties.isMute() ); + + if( AVMediaSetMask::VOLUMEDB & nMaskSet ) + m_xImpl->m_MediaProperties.setVolumeDB( rNewProperties.getVolumeDB() ); + + if( AVMediaSetMask::ZOOM & nMaskSet ) + m_xImpl->m_MediaProperties.setZoom( rNewProperties.getZoom() ); +#else + (void) rNewProperties; +#endif + + if( bBroadcastChanged ) + { + SetChanged(); + BroadcastObjectChange(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoole2.cxx b/svx/source/svdraw/svdoole2.cxx new file mode 100644 index 0000000000..bd7db1a62c --- /dev/null +++ b/svx/source/svdraw/svdoole2.cxx @@ -0,0 +1,1996 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +static uno::Reference < beans::XPropertySet > lcl_getFrame_throw(const SdrOle2Obj* _pObject) +{ + uno::Reference < beans::XPropertySet > xFrame; + if ( _pObject ) + { + uno::Reference< frame::XController> xController = _pObject->GetParentXModel()->getCurrentController(); + if ( xController.is() ) + { + xFrame.set( xController->getFrame(),uno::UNO_QUERY_THROW); + } + } // if ( _pObject ) + return xFrame; +} + +namespace { + +class SdrLightEmbeddedClient_Impl : public ::cppu::WeakImplHelper + < embed::XStateChangeListener + , document::XEventListener + , embed::XInplaceClient + , embed::XEmbeddedClient + , embed::XWindowSupplier + > +{ + uno::Reference< awt::XWindow > m_xWindow; + SdrOle2Obj* mpObj; + + Fraction m_aScaleWidth; + Fraction m_aScaleHeight; + + +public: + explicit SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj ); + virtual ~SdrLightEmbeddedClient_Impl() override; + + void SetSizeScale( const Fraction& aScaleWidth, const Fraction& aScaleHeight ) + { + m_aScaleWidth = aScaleWidth; + m_aScaleHeight = aScaleHeight; + } + + const Fraction& GetScaleWidth() const { return m_aScaleWidth; } + const Fraction& GetScaleHeight() const { return m_aScaleHeight; } + + void setWindow(const uno::Reference< awt::XWindow >& _xWindow); + + void disconnect(); +private: + + tools::Rectangle impl_getScaledRect_nothrow() const; + // XStateChangeListener + virtual void SAL_CALL changingState( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override; + virtual void SAL_CALL stateChanged( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override; + virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override; + + // document::XEventListener + virtual void SAL_CALL notifyEvent( const document::EventObject& aEvent ) override; + + // XEmbeddedClient + virtual void SAL_CALL saveObject() override; + virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) override; + + // XComponentSupplier + virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() override; + + // XInplaceClient + virtual sal_Bool SAL_CALL canInplaceActivate() override; + virtual void SAL_CALL activatingInplace() override; + virtual void SAL_CALL activatingUI() override; + virtual void SAL_CALL deactivatedInplace() override; + virtual void SAL_CALL deactivatedUI() override; + virtual uno::Reference< css::frame::XLayoutManager > SAL_CALL getLayoutManager() override; + virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() override; + virtual awt::Rectangle SAL_CALL getPlacement() override; + virtual awt::Rectangle SAL_CALL getClipRectangle() override; + virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) override; + virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) override; + virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) override; + + // XWindowSupplier + virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() override; +}; + +} + +SdrLightEmbeddedClient_Impl::SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj ) +: mpObj( pObj ) +{ +} +SdrLightEmbeddedClient_Impl::~SdrLightEmbeddedClient_Impl() +{ + assert(!mpObj); +} +tools::Rectangle SdrLightEmbeddedClient_Impl::impl_getScaledRect_nothrow() const +{ + tools::Rectangle aLogicRect( mpObj->GetLogicRect() ); + // apply scaling to object area and convert to pixels + aLogicRect.SetSize( Size( tools::Long( aLogicRect.GetWidth() * m_aScaleWidth), + tools::Long( aLogicRect.GetHeight() * m_aScaleHeight) ) ); + return aLogicRect; +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::changingState( const css::lang::EventObject& /*aEvent*/, ::sal_Int32 /*nOldState*/, ::sal_Int32 /*nNewState*/ ) +{ +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::stateChanged( const css::lang::EventObject& /*aEvent*/, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) +{ + SolarMutexGuard aGuard; + + if ( mpObj && nOldState == embed::EmbedStates::LOADED && nNewState == embed::EmbedStates::RUNNING ) + { + mpObj->ObjectLoaded(); + GetSdrGlobalData().GetOLEObjCache().InsertObj(mpObj); + } + else if ( mpObj && nNewState == embed::EmbedStates::LOADED && nOldState == embed::EmbedStates::RUNNING ) + { + GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj); + } +} + +void SdrLightEmbeddedClient_Impl::disconnect() +{ + SolarMutexGuard aGuard; + if (!mpObj) + return; + GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj); + mpObj = nullptr; +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::disposing( const css::lang::EventObject& /*aEvent*/ ) +{ + disconnect(); +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::notifyEvent( const document::EventObject& aEvent ) +{ + // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl + + SolarMutexGuard aGuard; + + // the code currently makes sense only in case there is no other client + if ( !(mpObj && mpObj->GetAspect() != embed::Aspects::MSOLE_ICON && aEvent.EventName == "OnVisAreaChanged" + && mpObj->GetObjRef().is() && mpObj->GetObjRef()->getClientSite() == uno::Reference< embed::XEmbeddedClient >( this )) ) + return; + + try + { + MapUnit aContainerMapUnit( MapUnit::Map100thMM ); + uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY ); + if ( xParentVis.is() ) + aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) ); + + MapUnit aObjMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpObj->GetObjRef()->getMapUnit( mpObj->GetAspect() ) ); + + tools::Rectangle aVisArea; + awt::Size aSz; + try + { + aSz = mpObj->GetObjRef()->getVisualAreaSize( mpObj->GetAspect() ); + } + catch( embed::NoVisualAreaSizeException& ) + { + TOOLS_WARN_EXCEPTION("svx.svdraw", "No visual area size!"); + aSz.Width = 5000; + aSz.Height = 5000; + } + catch( uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.svdraw", ""); + aSz.Width = 5000; + aSz.Height = 5000; + } + + aVisArea.SetSize( Size( aSz.Width, aSz.Height ) ); + aVisArea = OutputDevice::LogicToLogic(aVisArea, MapMode(aObjMapUnit), MapMode(aContainerMapUnit)); + Size aScaledSize( static_cast< tools::Long >( m_aScaleWidth * Fraction( aVisArea.GetWidth() ) ), + static_cast< tools::Long >( m_aScaleHeight * Fraction( aVisArea.GetHeight() ) ) ); + tools::Rectangle aLogicRect( mpObj->GetLogicRect() ); + + // react to the change if the difference is bigger than one pixel + Size aPixelDiff = + Application::GetDefaultDevice()->LogicToPixel( + Size( aLogicRect.GetWidth() - aScaledSize.Width(), + aLogicRect.GetHeight() - aScaledSize.Height() ), + MapMode(aContainerMapUnit)); + if( aPixelDiff.Width() || aPixelDiff.Height() ) + { + mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aScaledSize ) ); + mpObj->BroadcastObjectChange(); + } + else + mpObj->ActionChanged(); + } + catch( uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("svx.svdraw", ""); + } +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::saveObject() +{ + // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl + uno::Reference< embed::XCommonEmbedPersist > xPersist; + uno::Reference< util::XModifiable > xModifiable; + + { + SolarMutexGuard aGuard; + + if ( !mpObj ) + throw embed::ObjectSaveVetoException(); + + // the common persistence is supported by objects and links + xPersist.set( mpObj->GetObjRef(), uno::UNO_QUERY_THROW ); + xModifiable.set( mpObj->GetParentXModel(), uno::UNO_QUERY ); + } + + xPersist->storeOwn(); + + if ( xModifiable.is() ) + xModifiable->setModified( true ); +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::visibilityChanged( sal_Bool /*bVisible*/ ) +{ + // nothing to do currently + // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl + if ( mpObj ) + { + tools::Rectangle aLogicRect( mpObj->GetLogicRect() ); + Size aLogicSize( aLogicRect.GetWidth(), aLogicRect.GetHeight() ); + + if( mpObj->IsChart() ) + { + //charts never should be stretched see #i84323# for example + mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aLogicSize ) ); + mpObj->BroadcastObjectChange(); + } // if( mpObj->IsChart() ) + } +} + +uno::Reference< util::XCloseable > SAL_CALL SdrLightEmbeddedClient_Impl::getComponent() +{ + uno::Reference< util::XCloseable > xResult; + + SolarMutexGuard aGuard; + if ( mpObj ) + xResult.set( mpObj->GetParentXModel(), uno::UNO_QUERY ); + + return xResult; +} +// XInplaceClient + +sal_Bool SAL_CALL SdrLightEmbeddedClient_Impl::canInplaceActivate() +{ + bool bRet = false; + SolarMutexGuard aGuard; + if ( mpObj ) + { + uno::Reference< embed::XEmbeddedObject > xObject = mpObj->GetObjRef(); + if ( !xObject.is() ) + throw uno::RuntimeException(); + // we don't want to switch directly from outplace to inplace mode + bRet = ( xObject->getCurrentState() != embed::EmbedStates::ACTIVE && mpObj->GetAspect() != embed::Aspects::MSOLE_ICON ); + } // if ( mpObj ) + return bRet; +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::activatingInplace() +{ +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::activatingUI() +{ + SolarMutexGuard aGuard; + + uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj)); + uno::Reference < frame::XFrame > xOwnFrame( xFrame,uno::UNO_QUERY); + uno::Reference < frame::XFramesSupplier > xParentFrame = xOwnFrame->getCreator(); + if ( xParentFrame.is() ) + xParentFrame->setActiveFrame( xOwnFrame ); + + OLEObjCache& rObjCache = GetSdrGlobalData().GetOLEObjCache(); + const size_t nCount = rObjCache.size(); + for(sal_Int32 i = nCount-1 ; i >= 0;--i) + { + SdrOle2Obj* pObj = rObjCache[i]; + if ( pObj != mpObj ) + { + // only deactivate ole objects which belongs to the same frame + if ( xFrame == lcl_getFrame_throw(pObj) ) + { + const uno::Reference< embed::XEmbeddedObject >& xObject = pObj->GetObjRef(); + try + { + if ( xObject->getStatus( pObj->GetAspect() ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE ) + xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE ); + else + { + // the links should not stay in running state for long time because of locking + uno::Reference< embed::XLinkageSupport > xLink( xObject, uno::UNO_QUERY ); + if ( xLink.is() && xLink->isLink() ) + xObject->changeState( embed::EmbedStates::LOADED ); + else + xObject->changeState( embed::EmbedStates::RUNNING ); + } + } + catch (css::uno::Exception& ) + {} + } + } + } // for(sal_Int32 i = nCount-1 ; i >= 0;--i) +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedInplace() +{ +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedUI() +{ + SolarMutexGuard aGuard; + css::uno::Reference< css::frame::XLayoutManager > xLayoutManager(getLayoutManager()); + if ( xLayoutManager.is() ) + { + static constexpr OUString aMenuBarURL = u"private:resource/menubar/menubar"_ustr; + if ( !xLayoutManager->isElementVisible( aMenuBarURL ) ) + xLayoutManager->createElement( aMenuBarURL ); + } +} + +uno::Reference< css::frame::XLayoutManager > SAL_CALL SdrLightEmbeddedClient_Impl::getLayoutManager() +{ + uno::Reference< css::frame::XLayoutManager > xMan; + SolarMutexGuard aGuard; + uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj)); + try + { + xMan.set(xFrame->getPropertyValue("LayoutManager"),uno::UNO_QUERY); + } + catch ( uno::Exception& ex ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( ex.Message, + nullptr, anyEx ); + } + + return xMan; +} + +uno::Reference< frame::XDispatchProvider > SAL_CALL SdrLightEmbeddedClient_Impl::getInplaceDispatchProvider() +{ + SolarMutexGuard aGuard; + return uno::Reference < frame::XDispatchProvider >( lcl_getFrame_throw(mpObj), uno::UNO_QUERY_THROW ); +} + +awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getPlacement() +{ + SolarMutexGuard aGuard; + if ( !mpObj ) + throw uno::RuntimeException(); + + tools::Rectangle aLogicRect = impl_getScaledRect_nothrow(); + MapUnit aContainerMapUnit( MapUnit::Map100thMM ); + uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY ); + if ( xParentVis.is() ) + aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) ); + + aLogicRect = Application::GetDefaultDevice()->LogicToPixel(aLogicRect, MapMode(aContainerMapUnit)); + return AWTRectangle( aLogicRect ); +} + +awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getClipRectangle() +{ + return getPlacement(); +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ ) +{ +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::scrollObject( const awt::Size& /*aOffset*/ ) +{ +} + +void SAL_CALL SdrLightEmbeddedClient_Impl::changedPlacement( const awt::Rectangle& aPosRect ) +{ + SolarMutexGuard aGuard; + if ( !mpObj ) + throw uno::RuntimeException(); + + uno::Reference< embed::XInplaceObject > xInplace( mpObj->GetObjRef(), uno::UNO_QUERY_THROW ); + + // check if the change is at least one pixel in size + awt::Rectangle aOldRect = getPlacement(); + tools::Rectangle aNewPixelRect = VCLRectangle( aPosRect ); + tools::Rectangle aOldPixelRect = VCLRectangle( aOldRect ); + if ( aOldPixelRect == aNewPixelRect ) + // nothing has changed + return; + + // new scaled object area + MapUnit aContainerMapUnit( MapUnit::Map100thMM ); + uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY ); + if ( xParentVis.is() ) + aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) ); + + tools::Rectangle aNewLogicRect = Application::GetDefaultDevice()->PixelToLogic(aNewPixelRect, MapMode(aContainerMapUnit)); + tools::Rectangle aLogicRect = impl_getScaledRect_nothrow(); + + if ( aNewLogicRect == aLogicRect ) + return; + + // the calculation of the object area has not changed the object size + // it should be done here then + //SfxBooleanFlagGuard aGuard( m_bResizeNoScale, true ); + + // new size of the object area without scaling + Size aNewObjSize( tools::Long( aNewLogicRect.GetWidth() / m_aScaleWidth ), + tools::Long( aNewLogicRect.GetHeight() / m_aScaleHeight ) ); + + // now remove scaling from new placement and keep this at the new object area + aNewLogicRect.SetSize( aNewObjSize ); + // react to the change if the difference is bigger than one pixel + Size aPixelDiff = + Application::GetDefaultDevice()->LogicToPixel( + Size( aLogicRect.GetWidth() - aNewObjSize.Width(), + aLogicRect.GetHeight() - aNewObjSize.Height() ), + MapMode(aContainerMapUnit)); + if( aPixelDiff.Width() || aPixelDiff.Height() ) + { + mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aNewObjSize ) ); + mpObj->BroadcastObjectChange(); + } + else + mpObj->ActionChanged(); +} +// XWindowSupplier + +uno::Reference< awt::XWindow > SAL_CALL SdrLightEmbeddedClient_Impl::getWindow() +{ + SolarMutexGuard aGuard; + uno::Reference< awt::XWindow > xCurrent = m_xWindow; + if ( !xCurrent.is() ) + { + if ( !mpObj ) + throw uno::RuntimeException(); + uno::Reference< frame::XFrame> xFrame(lcl_getFrame_throw(mpObj),uno::UNO_QUERY_THROW); + xCurrent = xFrame->getComponentWindow(); + } // if ( !xCurrent.is() ) + return xCurrent; +} +void SdrLightEmbeddedClient_Impl::setWindow(const uno::Reference< awt::XWindow >& _xWindow) +{ + m_xWindow = _xWindow; +} + +SdrEmbedObjectLink::SdrEmbedObjectLink(SdrOle2Obj* pObject): + ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB ), + pObj(pObject) +{ + SetSynchron( false ); +} + +SdrEmbedObjectLink::~SdrEmbedObjectLink() +{ +} + +::sfx2::SvBaseLink::UpdateResult SdrEmbedObjectLink::DataChanged( + const OUString& /*rMimeType*/, const css::uno::Any & /*rValue*/ ) +{ + if ( !pObj->UpdateLinkURL_Impl() ) + { + // the link URL was not changed + uno::Reference< embed::XEmbeddedObject > xObject = pObj->GetObjRef(); + OSL_ENSURE( xObject.is(), "The object must exist always!" ); + if ( xObject.is() ) + { + // let the object reload the link + // TODO/LATER: reload call could be used for this case + + try + { + sal_Int32 nState = xObject->getCurrentState(); + if ( nState != embed::EmbedStates::LOADED ) + { + // in some cases the linked file probably is not locked so it could be changed + xObject->changeState( embed::EmbedStates::LOADED ); + xObject->changeState( nState ); + } + } + catch ( uno::Exception& ) + { + } + } + } + + pObj->GetNewReplacement(); + pObj->SetChanged(); + + return SUCCESS; +} + +void SdrEmbedObjectLink::Closed() +{ + pObj->BreakFileLink_Impl(); + SvBaseLink::Closed(); +} + +SdrIFrameLink::SdrIFrameLink(SdrOle2Obj* pObject) + : ::sfx2::SvBaseLink(::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB) + , m_pObject(pObject) +{ + SetSynchron( false ); +} + +::sfx2::SvBaseLink::UpdateResult SdrIFrameLink::DataChanged( + const OUString&, const uno::Any& ) +{ + uno::Reference xObject = m_pObject->GetObjRef(); + uno::Reference xPersObj(xObject, uno::UNO_QUERY); + if (xPersObj.is()) + { + // let the IFrameObject reload the link + try + { + xPersObj->reload(uno::Sequence(), uno::Sequence()); + } + catch (const uno::Exception&) + { + } + + m_pObject->SetChanged(); + } + + return SUCCESS; +} + +class SdrOle2ObjImpl +{ +public: + svt::EmbeddedObjectRef mxObjRef; + + std::optional moGraphic; + OUString maProgName; + OUString aPersistName; // name of object in persist + rtl::Reference mxLightClient; // must be registered as client only using AddOwnLightClient() call + + bool mbFrame:1; // Due to compatibility at SdrTextObj for now + bool mbSuppressSetVisAreaSize:1; // #i118524# + mutable bool mbTypeAsked:1; + mutable bool mbIsChart:1; + bool mbLoadingOLEObjectFailed:1; // New local var to avoid repeated loading if load of OLE2 fails + bool mbConnected:1; + + sfx2::SvBaseLink* mpObjectLink; + OUString maLinkURL; + + rtl::Reference mxModifyListener; + + explicit SdrOle2ObjImpl( bool bFrame ) : + mbFrame(bFrame), + mbSuppressSetVisAreaSize(false), + mbTypeAsked(false), + mbIsChart(false), + mbLoadingOLEObjectFailed(false), + mbConnected(false), + mpObjectLink(nullptr) + { + mxObjRef.Lock(); + } + + SdrOle2ObjImpl( bool bFrame, const svt::EmbeddedObjectRef& rObjRef ) : + mxObjRef(rObjRef), + mbFrame(bFrame), + mbSuppressSetVisAreaSize(false), + mbTypeAsked(false), + mbIsChart(false), + mbLoadingOLEObjectFailed(false), + mbConnected(false), + mpObjectLink(nullptr) + { + mxObjRef.Lock(); + } + + ~SdrOle2ObjImpl() + { + moGraphic.reset(); + + if (mxModifyListener.is()) + { + mxModifyListener->invalidate(); + } + } +}; + +// Predicate determining whether the given OLE is an internal math +// object +static bool ImplIsMathObj( const uno::Reference < embed::XEmbeddedObject >& rObjRef ) +{ + if ( !rObjRef.is() ) + return false; + + SvGlobalName aClassName( rObjRef->getClassID() ); + return aClassName == SvGlobalName(SO3_SM_CLASSID_30) || + aClassName == SvGlobalName(SO3_SM_CLASSID_40) || + aClassName == SvGlobalName(SO3_SM_CLASSID_50) || + aClassName == SvGlobalName(SO3_SM_CLASSID_60) || + aClassName == SvGlobalName(SO3_SM_CLASSID); +} + +// BaseProperties section + +std::unique_ptr SdrOle2Obj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + +// DrawContact section + +std::unique_ptr SdrOle2Obj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +void SdrOle2Obj::Init() +{ + // Stuff that was done from old SetModel: + // #i43086# #i85304 redo the change for charts for the above bugfix, as #i43086# does not occur anymore + // so maybe the ImpSetVisAreaSize call can be removed here completely + // Nevertheless I leave it in for other objects as I am not sure about the side effects when removing now + if(!getSdrModelFromSdrObject().isLocked() && !IsChart()) + { + ImpSetVisAreaSize(); + } + + ::comphelper::IEmbeddedHelper* pDestPers(getSdrModelFromSdrObject().GetPersist()); + if(pDestPers && !IsEmptyPresObj()) + { + // object wasn't connected, now it should be + Connect_Impl(); + } + + AddListeners_Impl(); +} + +SdrOle2Obj::SdrOle2Obj( + SdrModel& rSdrModel, + bool bFrame_) +: SdrRectObj(rSdrModel), + mpImpl(new SdrOle2ObjImpl(bFrame_)) +{ + Init(); +} + +SdrOle2Obj::SdrOle2Obj(SdrModel& rSdrModel, SdrOle2Obj const & rSource) +: SdrRectObj(rSdrModel, rSource), + mpImpl(new SdrOle2ObjImpl(/*bFrame*/false)) +{ + Init(); + + // Manually copying bClosedObj attribute + SetClosedObj( rSource.IsClosedObj() ); + + mpImpl->aPersistName = rSource.mpImpl->aPersistName; + mpImpl->maProgName = rSource.mpImpl->maProgName; + mpImpl->mbFrame = rSource.mpImpl->mbFrame; + + if (rSource.mpImpl->moGraphic) + { + mpImpl->moGraphic.emplace(*rSource.mpImpl->moGraphic); + } + + if( IsEmptyPresObj() ) + return; + + ::comphelper::IEmbeddedHelper* pDestPers(getSdrModelFromSdrObject().GetPersist()); + ::comphelper::IEmbeddedHelper* pSrcPers(rSource.getSdrModelFromSdrObject().GetPersist()); + if( !(pDestPers && pSrcPers) ) + return; + + DBG_ASSERT( !mpImpl->mxObjRef.is(), "Object already existing!" ); + comphelper::EmbeddedObjectContainer& rContainer = pSrcPers->getEmbeddedObjectContainer(); + uno::Reference < embed::XEmbeddedObject > xObj = rContainer.GetEmbeddedObject( mpImpl->aPersistName ); + if ( xObj.is() ) + { + OUString aTmp; + mpImpl->mxObjRef.Assign( pDestPers->getEmbeddedObjectContainer().CopyAndGetEmbeddedObject( + rContainer, xObj, aTmp, pSrcPers->getDocumentBaseURL(), pDestPers->getDocumentBaseURL()), rSource.GetAspect()); + mpImpl->mbTypeAsked = false; + mpImpl->aPersistName = aTmp; + CheckFileLink_Impl(); + } + + Connect(); +} + +SdrOle2Obj::SdrOle2Obj( + SdrModel& rSdrModel, + const svt::EmbeddedObjectRef& rNewObjRef, + const OUString& rNewObjName, + const tools::Rectangle& rNewRect) +: SdrRectObj(rSdrModel, rNewRect), + mpImpl(new SdrOle2ObjImpl(false/*bFrame_*/, rNewObjRef)) +{ + osl_atomic_increment(&m_refCount); + + mpImpl->aPersistName = rNewObjName; + + if (mpImpl->mxObjRef.is() && (mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::EMBED_NEVERRESIZE ) ) + m_bSizProt = true; + + // For math objects, set closed state to transparent + SetClosedObj(!ImplIsMathObj( mpImpl->mxObjRef.GetObject() )); + + Init(); + + osl_atomic_decrement(&m_refCount); +} + +OUString SdrOle2Obj::GetStyleString() +{ + OUString strStyle; + if (mpImpl->mxObjRef.is() && mpImpl->mxObjRef.IsChart()) + { + strStyle = mpImpl->mxObjRef.GetChartType(); + } + return strStyle; +} + +SdrOle2Obj::~SdrOle2Obj() +{ + if ( mpImpl->mbConnected ) + Disconnect(); + + DisconnectFileLink_Impl(); + + if (mpImpl->mxLightClient) + { + mpImpl->mxLightClient->disconnect(); + mpImpl->mxLightClient.clear(); + } +} + +void SdrOle2Obj::SetAspect( sal_Int64 nAspect ) +{ + mpImpl->mxObjRef.SetViewAspect( nAspect ); +} + +const svt::EmbeddedObjectRef& SdrOle2Obj::getEmbeddedObjectRef() const +{ + return mpImpl->mxObjRef; +} + +sal_Int64 SdrOle2Obj::GetAspect() const +{ + return mpImpl->mxObjRef.GetViewAspect(); +} + +bool SdrOle2Obj::isInplaceActive() const +{ + return mpImpl->mxObjRef.is() && embed::EmbedStates::INPLACE_ACTIVE == mpImpl->mxObjRef->getCurrentState(); +} + +bool SdrOle2Obj::isUiActive() const +{ + return mpImpl->mxObjRef.is() && embed::EmbedStates::UI_ACTIVE == mpImpl->mxObjRef->getCurrentState(); +} + +void SdrOle2Obj::SetGraphic(const Graphic& rGrf) +{ + // only for setting a preview graphic + mpImpl->moGraphic.emplace(rGrf); + + SetChanged(); + BroadcastObjectChange(); +} + +void SdrOle2Obj::ClearGraphic() +{ + mpImpl->moGraphic.reset(); + + SetChanged(); + BroadcastObjectChange(); +} + +void SdrOle2Obj::SetProgName( const OUString& rName ) +{ + mpImpl->maProgName = rName; +} + +const OUString& SdrOle2Obj::GetProgName() const +{ + return mpImpl->maProgName; +} + +bool SdrOle2Obj::IsEmpty() const +{ + return !mpImpl->mxObjRef.is(); +} + +void SdrOle2Obj::Connect(SvxOle2Shape* pCreator) +{ + if( IsEmptyPresObj() ) + return; + + if( mpImpl->mbConnected ) + { + // currently there are situations where it seems to be unavoidable to have multiple connects + // changing this would need a larger code rewrite, so for now I remove the assertion + // OSL_FAIL("Connect() called on connected object!"); + return; + } + + Connect_Impl(pCreator); + AddListeners_Impl(); +} + +bool SdrOle2Obj::UpdateLinkURL_Impl() +{ + bool bResult = false; + + if ( mpImpl->mpObjectLink ) + { + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + + if ( pLinkManager ) + { + OUString aNewLinkURL; + sfx2::LinkManager::GetDisplayNames( mpImpl->mpObjectLink, nullptr, &aNewLinkURL ); + if ( !aNewLinkURL.equalsIgnoreAsciiCase( mpImpl->maLinkURL ) ) + { + GetObjRef_Impl(); + uno::Reference xPersObj( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY ); + OSL_ENSURE( xPersObj.is(), "The object must exist!" ); + if ( xPersObj.is() ) + { + try + { + sal_Int32 nCurState = mpImpl->mxObjRef->getCurrentState(); + if ( nCurState != embed::EmbedStates::LOADED ) + mpImpl->mxObjRef->changeState(embed::EmbedStates::LOADED); + + // TODO/LATER: there should be possible to get current mediadescriptor settings from the object + uno::Sequence< beans::PropertyValue > aArgs{ comphelper::makePropertyValue( + "URL", aNewLinkURL) }; + xPersObj->reload( aArgs, uno::Sequence< beans::PropertyValue >() ); + + mpImpl->maLinkURL = aNewLinkURL; + bResult = true; + + if ( nCurState != embed::EmbedStates::LOADED ) + mpImpl->mxObjRef->changeState(nCurState); + } + catch( css::uno::Exception const & ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::UpdateLinkURL_Impl()" ); + } + } + + if ( !bResult ) + { + // TODO/LATER: return the old name to the link manager, is it possible? + } + } + } + } + + return bResult; +} + +void SdrOle2Obj::BreakFileLink_Impl() +{ + uno::Reference xDoc(getSdrModelFromSdrObject().getUnoModel(), uno::UNO_QUERY); + + if ( !xDoc.is() ) + return; + + uno::Reference< embed::XStorage > xStorage = xDoc->getDocumentStorage(); + if ( !xStorage.is() ) + return; + + try + { + uno::Reference< embed::XLinkageSupport > xLinkSupport( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY_THROW ); + xLinkSupport->breakLink( xStorage, mpImpl->aPersistName ); + DisconnectFileLink_Impl(); + mpImpl->maLinkURL.clear(); + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::BreakFileLink_Impl()" ); + } +} + +void SdrOle2Obj::DisconnectFileLink_Impl() +{ + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + + if ( pLinkManager && mpImpl->mpObjectLink ) + { + pLinkManager->Remove( mpImpl->mpObjectLink ); + mpImpl->mpObjectLink = nullptr; + } +} + +void SdrOle2Obj::CheckFileLink_Impl() +{ + if (!mpImpl->mxObjRef.GetObject().is() || mpImpl->mpObjectLink) + return; + + try + { + uno::Reference xObject = mpImpl->mxObjRef.GetObject(); + if (!xObject) + return; + + bool bIFrame = false; + + OUString aLinkURL; + uno::Reference xLinkSupport(xObject, uno::UNO_QUERY); + if (xLinkSupport) + { + if (xLinkSupport->isLink()) + aLinkURL = xLinkSupport->getLinkURL(); + } + else + { + // get IFrame (Floating Frames) listed and updatable from the + // manage links dialog + SvGlobalName aClassId(xObject->getClassID()); + if (aClassId == SvGlobalName(SO3_IFRAME_CLASSID)) + { + uno::Reference xSet(xObject->getComponent(), uno::UNO_QUERY); + if (xSet.is()) + xSet->getPropertyValue("FrameURL") >>= aLinkURL; + bIFrame = true; + } + } + + if (!aLinkURL.isEmpty()) // this is a file link so the model link manager should handle it + { + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + + if ( pLinkManager ) + { + SdrEmbedObjectLink* pEmbedObjectLink = nullptr; + if (!bIFrame) + { + pEmbedObjectLink = new SdrEmbedObjectLink(this); + mpImpl->mpObjectLink = pEmbedObjectLink; + } + else + mpImpl->mpObjectLink = new SdrIFrameLink(this); + mpImpl->maLinkURL = aLinkURL; + pLinkManager->InsertFileLink( *mpImpl->mpObjectLink, sfx2::SvBaseLinkObjectType::ClientOle, aLinkURL ); + if (pEmbedObjectLink) + pEmbedObjectLink->Connect(); + } + } + } + catch (const css::uno::Exception&) + { + TOOLS_WARN_EXCEPTION("svx", "SdrOle2Obj::CheckFileLink_Impl()"); + } +} + +void SdrOle2Obj::Connect_Impl(SvxOle2Shape* pCreator) +{ + if(mpImpl->aPersistName.isEmpty() ) + return; + + try + { + ::comphelper::IEmbeddedHelper* pPers(getSdrModelFromSdrObject().GetPersist()); + + if ( pPers ) + { + comphelper::EmbeddedObjectContainer& rContainer = pPers->getEmbeddedObjectContainer(); + + if ( !rContainer.HasEmbeddedObject( mpImpl->aPersistName ) + || ( mpImpl->mxObjRef.is() && !rContainer.HasEmbeddedObject( mpImpl->mxObjRef.GetObject() ) ) ) + { + // object not known to container document + // No object -> disaster! + DBG_ASSERT( mpImpl->mxObjRef.is(), "No object in connect!"); + if ( mpImpl->mxObjRef.is() ) + { + // object came from the outside, now add it to the container + OUString aTmp; + rContainer.InsertEmbeddedObject( mpImpl->mxObjRef.GetObject(), aTmp ); + mpImpl->aPersistName = aTmp; + } + } + else if ( !mpImpl->mxObjRef.is() ) + { + mpImpl->mxObjRef.Assign( rContainer.GetEmbeddedObject( mpImpl->aPersistName ), mpImpl->mxObjRef.GetViewAspect() ); + mpImpl->mbTypeAsked = false; + } + + if ( mpImpl->mxObjRef.GetObject().is() ) + { + mpImpl->mxObjRef.AssignToContainer( &rContainer, mpImpl->aPersistName ); + mpImpl->mbConnected = true; + mpImpl->mxObjRef.Lock(); + } + } + + if (pCreator) + { + OUString sFrameURL(pCreator->GetAndClearInitialFrameURL()); + if (!sFrameURL.isEmpty() && svt::EmbeddedObjectRef::TryRunningState(mpImpl->mxObjRef.GetObject())) + { + uno::Reference xSet(mpImpl->mxObjRef->getComponent(), uno::UNO_QUERY); + if (xSet.is()) + xSet->setPropertyValue("FrameURL", uno::Any(sFrameURL)); + } + } + + if ( mpImpl->mxObjRef.is() ) + { + if ( !mpImpl->mxLightClient.is() ) + mpImpl->mxLightClient = new SdrLightEmbeddedClient_Impl( this ); + + mpImpl->mxObjRef->addStateChangeListener( mpImpl->mxLightClient ); + mpImpl->mxObjRef->addEventListener( mpImpl->mxLightClient ); + + if ( mpImpl->mxObjRef->getCurrentState() != embed::EmbedStates::LOADED ) + GetSdrGlobalData().GetOLEObjCache().InsertObj(this); + + CheckFileLink_Impl(); + + uno::Reference< container::XChild > xChild( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY ); + if( xChild.is() ) + { + uno::Reference< uno::XInterface > xParent( getSdrModelFromSdrObject().getUnoModel()); + if( xParent.is()) + xChild->setParent( getSdrModelFromSdrObject().getUnoModel() ); + } + + } + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::Connect_Impl()" ); + } +} + +void SdrOle2Obj::ObjectLoaded() +{ + AddListeners_Impl(); +} + +void SdrOle2Obj::AddListeners_Impl() +{ + if( !(mpImpl->mxObjRef.is() && mpImpl->mxObjRef->getCurrentState() != embed::EmbedStates::LOADED) ) + return; + + // register modify listener + if (!mpImpl->mxModifyListener.is()) + { + mpImpl->mxModifyListener = new SvxUnoShapeModifyListener(this); + } + + uno::Reference< util::XModifyBroadcaster > xBC( getXModel(), uno::UNO_QUERY ); + if (xBC.is()) + { + xBC->addModifyListener( mpImpl->mxModifyListener ); + } +} + +void SdrOle2Obj::Disconnect() +{ + if( IsEmptyPresObj() ) + return; + + if( !mpImpl->mbConnected ) + { + OSL_FAIL("Disconnect() called on disconnected object!"); + return; + } + + RemoveListeners_Impl(); + Disconnect_Impl(); +} + +void SdrOle2Obj::RemoveListeners_Impl() +{ + if ( !mpImpl->mxObjRef.is() || mpImpl->aPersistName.isEmpty() ) + return; + + try + { + sal_Int32 nState = mpImpl->mxObjRef->getCurrentState(); + if ( nState != embed::EmbedStates::LOADED ) + { + uno::Reference< util::XModifyBroadcaster > xBC( getXModel(), uno::UNO_QUERY ); + if (xBC.is() && mpImpl->mxModifyListener.is()) + { + xBC->removeModifyListener( mpImpl->mxModifyListener ); + } + } + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::RemoveListeners_Impl()" ); + } +} + +void SdrOle2Obj::Disconnect_Impl() +{ + try + { + if ( !mpImpl->aPersistName.isEmpty() ) + { + if( getSdrModelFromSdrObject().IsInDestruction() ) + { + // TODO/LATER: here we must assume that the destruction of the model is enough to make clear that we will not + // remove the object from the container, even if the DrawingObject itself is not destroyed (unfortunately this + // There is no real need to do the following removing of the object from the container + // in case the model has correct persistence, but in case of problems such a removing + // would make the behavior of the office more stable + + comphelper::EmbeddedObjectContainer* pContainer = mpImpl->mxObjRef.GetContainer(); + if ( pContainer ) + { + pContainer->CloseEmbeddedObject( mpImpl->mxObjRef.GetObject() ); + mpImpl->mxObjRef.AssignToContainer( nullptr, mpImpl->aPersistName ); + } + + // happens later than the destruction of the model, so we can't assert that). + //DBG_ASSERT( bInDestruction, "Model is destroyed, but not me?!" ); + //TODO/LATER: should be make sure that the ObjectShell also forgets the object, because we will close it soon? + /* + uno::Reference < util::XCloseable > xClose( xObjRef, uno::UNO_QUERY ); + if ( xClose.is() ) + { + try + { + xClose->close( true ); + } + catch ( util::CloseVetoException& ) + { + // there's still someone who needs the object! + } + } + + xObjRef = NULL;*/ + } + else if ( mpImpl->mxObjRef.is() ) + { + if ( getSdrModelFromSdrObject().getUnoModel().is() ) + { + // remove object, but don't close it (that's up to someone else) + comphelper::EmbeddedObjectContainer* pContainer = mpImpl->mxObjRef.GetContainer(); + if ( pContainer ) + { + pContainer->RemoveEmbeddedObject( mpImpl->mxObjRef.GetObject() ); + + // TODO/LATER: mpImpl->aPersistName contains outdated information, to keep it updated + // it should be returned from RemoveEmbeddedObject call. Currently it is no problem, + // since no container is adjusted, actually the empty string could be provided as a name here + mpImpl->mxObjRef.AssignToContainer( nullptr, mpImpl->aPersistName ); + } + + DisconnectFileLink_Impl(); + } + } + } + + if ( mpImpl->mxObjRef.is() && mpImpl->mxLightClient.is() ) + { + mpImpl->mxObjRef->removeStateChangeListener ( mpImpl->mxLightClient ); + mpImpl->mxObjRef->removeEventListener( mpImpl->mxLightClient ); + mpImpl->mxObjRef->setClientSite( nullptr ); + + GetSdrGlobalData().GetOLEObjCache().RemoveObj(this); + } + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::Disconnect_Impl()" ); + } + + mpImpl->mbConnected = false; +} + +rtl::Reference SdrOle2Obj::createSdrGrafObjReplacement(bool bAddText) const +{ + const Graphic* pOLEGraphic = GetGraphic(); + + if(pOLEGraphic) + { + // #i118485# allow creating a SdrGrafObj representation + rtl::Reference pClone = new SdrGrafObj( + getSdrModelFromSdrObject(), + *pOLEGraphic); + + // copy transformation + basegfx::B2DHomMatrix aMatrix; + basegfx::B2DPolyPolygon aPolyPolygon; + + TRGetBaseGeometry(aMatrix, aPolyPolygon); + pClone->TRSetBaseGeometry(aMatrix, aPolyPolygon); + + // copy all attributes to support graphic styles for OLEs + pClone->SetStyleSheet(GetStyleSheet(), false); + pClone->SetMergedItemSet(GetMergedItemSet()); + + if(bAddText) + { + // #i118485# copy text (Caution! Model needed, as guaranteed in aw080) + OutlinerParaObject* pOPO = GetOutlinerParaObject(); + + if(pOPO) + { + pClone->NbcSetOutlinerParaObject(*pOPO); + } + } + + return rtl::Reference(pClone); + } + else + { + // #i100710# pOLEGraphic may be zero (no visualisation available), + // so we need to use the OLE replacement graphic + rtl::Reference pClone = new SdrRectObj( + getSdrModelFromSdrObject(), + GetSnapRect()); + + // gray outline + pClone->SetMergedItem(XLineStyleItem(css::drawing::LineStyle_SOLID)); + const svtools::ColorConfig aColorConfig; + const svtools::ColorConfigValue aColor(aColorConfig.GetColorValue(svtools::OBJECTBOUNDARIES)); + pClone->SetMergedItem(XLineColorItem(OUString(), aColor.nColor)); + + // bitmap fill + pClone->SetMergedItem(XFillStyleItem(drawing::FillStyle_BITMAP)); + pClone->SetMergedItem(XFillBitmapItem(OUString(), GetEmptyOLEReplacementGraphic())); + pClone->SetMergedItem(XFillBmpTileItem(false)); + pClone->SetMergedItem(XFillBmpStretchItem(false)); + + return rtl::Reference(pClone); + } +} + +rtl::Reference SdrOle2Obj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + // #i118485# missing converter added + rtl::Reference pRetval = createSdrGrafObjReplacement(true); + + if(pRetval) + { + return pRetval->DoConvertToPolyObj(bBezier, bAddText); + } + + return nullptr; +} + +void SdrOle2Obj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + const bool bRemove(pNewPage == nullptr && pOldPage != nullptr); + const bool bInsert(pNewPage != nullptr && pOldPage == nullptr); + + if (bRemove && mpImpl->mbConnected ) + { + Disconnect(); + } + + // call parent + SdrRectObj::handlePageChange(pOldPage, pNewPage); + + if (bInsert && !mpImpl->mbConnected ) + { + Connect(); + } +} + +void SdrOle2Obj::SetObjRef( const css::uno::Reference < css::embed::XEmbeddedObject >& rNewObjRef ) +{ + DBG_ASSERT( !rNewObjRef.is() || !mpImpl->mxObjRef.GetObject().is(), "SetObjRef called on already initialized object!"); + if( rNewObjRef == mpImpl->mxObjRef.GetObject() ) + return; + + // the caller of the method is responsible to control the old object, it will not be closed here + // Otherwise WW8 import crashes because it transfers control to OLENode by this method + if ( mpImpl->mxObjRef.GetObject().is() ) + mpImpl->mxObjRef.Lock( false ); + + // avoid removal of object in Disconnect! It is definitely a HACK to call SetObjRef(0)! + // This call will try to close the objects; so if anybody else wants to keep it, it must be locked by a CloseListener + mpImpl->mxObjRef.Clear(); + + if ( mpImpl->mbConnected ) + Disconnect(); + + mpImpl->mxObjRef.Assign( rNewObjRef, GetAspect() ); + mpImpl->mbTypeAsked = false; + + if ( mpImpl->mxObjRef.is() ) + { + mpImpl->moGraphic.reset(); + + if ( mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::EMBED_NEVERRESIZE ) + SetResizeProtect(true); + + // For math objects, set closed state to transparent + SetClosedObj(!ImplIsMathObj( rNewObjRef )); + + Connect(); + } + + SetChanged(); + BroadcastObjectChange(); +} + +void SdrOle2Obj::SetClosedObj( bool bIsClosed ) +{ + // TODO/LATER: do we still need this hack? + // Allow changes to the closed state of OLE objects + m_bClosedObj = bIsClosed; +} + +rtl::Reference SdrOle2Obj::getFullDragClone() const +{ + // #i118485# use central replacement generator + return createSdrGrafObjReplacement(false); +} + +void SdrOle2Obj::SetPersistName( const OUString& rPersistName, SvxOle2Shape* pCreator ) +{ + DBG_ASSERT( mpImpl->aPersistName.isEmpty(), "Persist name changed!"); + + mpImpl->aPersistName = rPersistName; + mpImpl->mbLoadingOLEObjectFailed = false; + + Connect(pCreator); + SetChanged(); +} + +void SdrOle2Obj::AbandonObject() +{ + mpImpl->aPersistName.clear(); + mpImpl->mbLoadingOLEObjectFailed = false; + SetObjRef(nullptr); +} + +const OUString& SdrOle2Obj::GetPersistName() const +{ + return mpImpl->aPersistName; +} + +void SdrOle2Obj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + // #i118485# Allowing much more attributes for OLEs + rInfo.bRotateFreeAllowed = true; + rInfo.bRotate90Allowed = true; + rInfo.bMirrorFreeAllowed = true; + rInfo.bMirror45Allowed = true; + rInfo.bMirror90Allowed = true; + rInfo.bTransparenceAllowed = true; + rInfo.bShearAllowed = true; + rInfo.bEdgeRadiusAllowed = false; + rInfo.bNoOrthoDesired = false; + rInfo.bCanConvToPath = true; + rInfo.bCanConvToPoly = true; + rInfo.bCanConvToPathLineToArea = false; + rInfo.bCanConvToPolyLineToArea = false; + rInfo.bCanConvToContour = true; +} + +SdrObjKind SdrOle2Obj::GetObjIdentifier() const +{ + return mpImpl->mbFrame ? SdrObjKind::OLEPluginFrame : SdrObjKind::OLE2; +} + +OUString SdrOle2Obj::TakeObjNameSingul() const +{ + OUStringBuffer sName(SvxResId(mpImpl->mbFrame ? STR_ObjNameSingulFrame : STR_ObjNameSingulOLE2)); + + const OUString aName(GetName()); + + if (!aName.isEmpty()) + { + sName.append(" '" + aName + "\'"); + } + + return sName.makeStringAndClear(); +} + +OUString SdrOle2Obj::TakeObjNamePlural() const +{ + return SvxResId(mpImpl->mbFrame ? STR_ObjNamePluralFrame : STR_ObjNamePluralOLE2); +} + +rtl::Reference SdrOle2Obj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrOle2Obj(rTargetModel, *this); +} + +void SdrOle2Obj::ImpSetVisAreaSize() +{ + // #i118524# do not again set VisAreaSize when the call comes from OLE client (e.g. ObjectAreaChanged) + if (mpImpl->mbSuppressSetVisAreaSize) + return; + + // currently there is no need to recalculate scaling for iconified objects + // TODO/LATER: it might be needed in future when it is possible to change the icon + if ( GetAspect() == embed::Aspects::MSOLE_ICON ) + return; + + // the object area of an embedded object was changed, e.g. by user interaction an a selected object + GetObjRef(); + if (!mpImpl->mxObjRef.is()) + return; + + sal_Int64 nMiscStatus = mpImpl->mxObjRef->getStatus( GetAspect() ); + + // the client is required to get access to scaling + SfxInPlaceClient* pClient( + SfxInPlaceClient::GetClient( + dynamic_cast( + getSdrModelFromSdrObject().GetPersist()), + mpImpl->mxObjRef.GetObject())); + const bool bHasOwnClient( + mpImpl->mxLightClient.is() && + mpImpl->mxObjRef->getClientSite() == uno::Reference< embed::XEmbeddedClient >( mpImpl->mxLightClient ) ); + + if ( pClient || bHasOwnClient ) + { + // TODO: IMHO we need to do similar things when object is UIActive or OutplaceActive?! + if ( ((nMiscStatus & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE) && + svt::EmbeddedObjectRef::TryRunningState( mpImpl->mxObjRef.GetObject() )) + || mpImpl->mxObjRef->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE + ) + { + Fraction aScaleWidth; + Fraction aScaleHeight; + if ( pClient ) + { + aScaleWidth = pClient->GetScaleWidth(); + aScaleHeight = pClient->GetScaleHeight(); + } + else + { + aScaleWidth = mpImpl->mxLightClient->GetScaleWidth(); + aScaleHeight = mpImpl->mxLightClient->GetScaleHeight(); + } + + // The object wants to resize itself (f.e. Chart wants to recalculate the layout) + // or object is inplace active and so has a window that must be resized also + // In these cases the change in the object area size will be reflected in a change of the + // objects' visual area. The scaling will not change, but it might exist already and must + // be used in calculations + MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpImpl->mxObjRef->getMapUnit( GetAspect() ) ); + Size aVisSize; + if (sal_Int32(aScaleWidth) != 0 && sal_Int32(aScaleHeight) != 0) // avoid div by zero + aVisSize = Size( static_cast( Fraction( getRectangle().GetWidth() ) / aScaleWidth ), + static_cast( Fraction( getRectangle().GetHeight() ) / aScaleHeight ) ); + + aVisSize = OutputDevice::LogicToLogic( + aVisSize, + MapMode(getSdrModelFromSdrObject().GetScaleUnit()), + MapMode(aMapUnit)); + awt::Size aSz; + aSz.Width = aVisSize.Width(); + aSz.Height = aVisSize.Height(); + mpImpl->mxObjRef->setVisualAreaSize( GetAspect(), aSz ); + + try + { + aSz = mpImpl->mxObjRef->getVisualAreaSize( GetAspect() ); + } + catch( embed::NoVisualAreaSizeException& ) + {} + + tools::Rectangle aAcceptedVisArea; + aAcceptedVisArea.SetSize( Size( static_cast( Fraction( tools::Long( aSz.Width ) ) * aScaleWidth ), + static_cast( Fraction( tools::Long( aSz.Height ) ) * aScaleHeight ) ) ); + if (aVisSize != aAcceptedVisArea.GetSize()) + { + // server changed VisArea to its liking and the VisArea is different than the suggested one + // store the new value as given by the object + MapUnit aNewMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpImpl->mxObjRef->getMapUnit( GetAspect() ) ); + auto aSize = OutputDevice::LogicToLogic(aAcceptedVisArea.GetSize(), MapMode(aNewMapUnit), MapMode(getSdrModelFromSdrObject().GetScaleUnit())); + setRectangleSize(aSize.Width(), aSize.Height()); + } + + // make the new object area known to the client + // compared to the "else" branch aRect might have been changed by the object and no additional scaling was applied + // WHY this -> OSL_ASSERT( pClient ); + if( pClient ) + pClient->SetObjArea(getRectangle()); + + // we need a new replacement image as the object has resized itself + + //#i79578# don't request a new replacement image for charts to often + //a chart sends a modified call to the framework if it was changed + //thus the replacement update is already handled there + if( !IsChart() ) + mpImpl->mxObjRef.UpdateReplacement(); + } + else + { + // The object isn't active and does not want to resize itself so the changed object area size + // will be reflected in a changed object scaling + Fraction aScaleWidth; + Fraction aScaleHeight; + Size aObjAreaSize; + if ( CalculateNewScaling( aScaleWidth, aScaleHeight, aObjAreaSize ) ) + { + if ( pClient ) + { + tools::Rectangle aScaleRect(getRectangle().TopLeft(), aObjAreaSize); + pClient->SetObjAreaAndScale( aScaleRect, aScaleWidth, aScaleHeight); + } + else + { + mpImpl->mxLightClient->SetSizeScale( aScaleWidth, aScaleHeight ); + } + } + } + } + else if( (nMiscStatus & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE) && + svt::EmbeddedObjectRef::TryRunningState( mpImpl->mxObjRef.GetObject() ) ) + { + //also handle not sfx based ole objects e.g. charts + //#i83860# resizing charts in impress distorts fonts + uno::Reference< embed::XVisualObject > xVisualObject( getXModel(), uno::UNO_QUERY ); + if( xVisualObject.is() ) + { + const MapUnit aMapUnit( + VCLUnoHelper::UnoEmbed2VCLMapUnit( + mpImpl->mxObjRef->getMapUnit(GetAspect()))); + const Point aTL( getRectangle().TopLeft() ); + const Point aBR( getRectangle().BottomRight() ); + const Point aTL2( + OutputDevice::LogicToLogic( + aTL, + MapMode(getSdrModelFromSdrObject().GetScaleUnit()), + MapMode(aMapUnit))); + const Point aBR2( + OutputDevice::LogicToLogic( + aBR, + MapMode(getSdrModelFromSdrObject().GetScaleUnit()), + MapMode(aMapUnit))); + const tools::Rectangle aNewRect( + aTL2, + aBR2); + + xVisualObject->setVisualAreaSize( + GetAspect(), + awt::Size( + aNewRect.GetWidth(), + aNewRect.GetHeight())); + } + } +} + +void SdrOle2Obj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + if(!getSdrModelFromSdrObject().isLocked()) + { + GetObjRef(); + + if ( mpImpl->mxObjRef.is() && ( mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE ) ) + { + // if the object needs recompose on resize + // the client site should be created before the resize will take place + // check whether there is no client site and create it if necessary + AddOwnLightClient(); + } + } + + SdrRectObj::NbcResize(rRef,xFact,yFact); + + if( !getSdrModelFromSdrObject().isLocked() ) + ImpSetVisAreaSize(); +} + +void SdrOle2Obj::SetGeoData(const SdrObjGeoData& rGeo) +{ + SdrRectObj::SetGeoData(rGeo); + + if( !getSdrModelFromSdrObject().isLocked() ) + ImpSetVisAreaSize(); +} + +void SdrOle2Obj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + SdrRectObj::NbcSetSnapRect(rRect); + + if( !getSdrModelFromSdrObject().isLocked() ) + ImpSetVisAreaSize(); + + if ( mpImpl->mxObjRef.is() && IsChart() ) + { + //#i103460# charts do not necessarily have an own size within ODF files, + //for this case they need to use the size settings from the surrounding frame, + //which is made available with this method as there is no other way + mpImpl->mxObjRef.SetDefaultSizeForChart( Size( rRect.GetWidth(), rRect.GetHeight() ) ); + } +} + +void SdrOle2Obj::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + SdrRectObj::NbcSetLogicRect(rRect); + + if( !getSdrModelFromSdrObject().isLocked() ) + ImpSetVisAreaSize(); +} + +const Graphic* SdrOle2Obj::GetGraphic() const +{ + if ( mpImpl->mxObjRef.is() ) + return mpImpl->mxObjRef.GetGraphic(); + return mpImpl->moGraphic ? &*mpImpl->moGraphic : nullptr; +} + +void SdrOle2Obj::GetNewReplacement() +{ + if ( mpImpl->mxObjRef.is() ) + mpImpl->mxObjRef.UpdateReplacement(); +} + +Size SdrOle2Obj::GetOrigObjSize( MapMode const * pTargetMapMode ) const +{ + return mpImpl->mxObjRef.GetSize( pTargetMapMode ); +} + +void SdrOle2Obj::setSuppressSetVisAreaSize( bool bNew ) +{ + mpImpl->mbSuppressSetVisAreaSize = bNew; +} + +void SdrOle2Obj::NbcMove(const Size& rSize) +{ + SdrRectObj::NbcMove(rSize); + + if( !getSdrModelFromSdrObject().isLocked() ) + ImpSetVisAreaSize(); +} + +bool SdrOle2Obj::CanUnloadRunningObj( const uno::Reference< embed::XEmbeddedObject >& xObj, sal_Int64 nAspect ) +{ + uno::Reference xPersist(xObj, uno::UNO_QUERY); + if (xPersist.is()) + { + if (!xPersist->isStored()) + // It doesn't have persistent storage. We can't unload this. + return false; + } + + bool bResult = false; + + sal_Int32 nState = xObj->getCurrentState(); + if ( nState == embed::EmbedStates::LOADED ) + { + // the object is already unloaded + bResult = true; + } + else + { + uno::Reference < util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY ); + if ( !xModifiable.is() ) + bResult = true; + else + { + sal_Int64 nMiscStatus = xObj->getStatus( nAspect ); + + if ( embed::EmbedMisc::MS_EMBED_ALWAYSRUN != ( nMiscStatus & embed::EmbedMisc::MS_EMBED_ALWAYSRUN ) && + embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY != ( nMiscStatus & embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY ) && + !( xModifiable.is() && xModifiable->isModified() ) && + !( nState == embed::EmbedStates::INPLACE_ACTIVE || nState == embed::EmbedStates::UI_ACTIVE || nState == embed::EmbedStates::ACTIVE ) ) + { + bResult = true; + } + } + } + + return bResult; +} + +bool SdrOle2Obj::Unload( const uno::Reference< embed::XEmbeddedObject >& xObj, sal_Int64 nAspect ) +{ + bool bResult = false; + + if ( CanUnloadRunningObj( xObj, nAspect ) ) + { + try + { + xObj->changeState( embed::EmbedStates::LOADED ); + bResult = true; + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::Unload()" ); + } + } + + return bResult; +} + +bool SdrOle2Obj::Unload() +{ + if (!mpImpl->mxObjRef.is()) + // Already unloaded. + return true; + + return Unload(mpImpl->mxObjRef.GetObject(), GetAspect()); +} + +void SdrOle2Obj::GetObjRef_Impl() +{ + if ( !mpImpl->mxObjRef.is() && !mpImpl->aPersistName.isEmpty() && getSdrModelFromSdrObject().GetPersist() ) + { + // Only try loading if it did not went wrong up to now + if(!mpImpl->mbLoadingOLEObjectFailed) + { + mpImpl->mxObjRef.Assign( + getSdrModelFromSdrObject().GetPersist()->getEmbeddedObjectContainer().GetEmbeddedObject(mpImpl->aPersistName), + GetAspect()); + mpImpl->mbTypeAsked = false; + CheckFileLink_Impl(); + + // If loading of OLE object failed, remember that to not invoke an endless + // loop trying to load it again and again. + if( mpImpl->mxObjRef.is() ) + { + mpImpl->mbLoadingOLEObjectFailed = true; + } + + // For math objects, set closed state to transparent + SetClosedObj(!ImplIsMathObj( mpImpl->mxObjRef.GetObject() )); + } + + if ( mpImpl->mxObjRef.is() ) + { + if( !IsEmptyPresObj() ) + { + // remember modified status of model + const bool bWasChanged(getSdrModelFromSdrObject().IsChanged()); + + // perhaps preview not valid anymore + // This line changes the modified state of the model + ClearGraphic(); + + // if status was not set before, force it back + // to not set, so that SetGraphic(0) above does not + // set the modified state of the model. + if(!bWasChanged && getSdrModelFromSdrObject().IsChanged()) + { + getSdrModelFromSdrObject().SetChanged( false ); + } + } + } + + if ( mpImpl->mxObjRef.is() ) + Connect(); + } + + if ( mpImpl->mbConnected ) + { + // move object to first position in cache + GetSdrGlobalData().GetOLEObjCache().InsertObj(this); + } +} + +uno::Reference < embed::XEmbeddedObject > const & SdrOle2Obj::GetObjRef() const +{ + const_cast(this)->GetObjRef_Impl(); + return mpImpl->mxObjRef.GetObject(); +} + +uno::Reference < embed::XEmbeddedObject > const & SdrOle2Obj::GetObjRef_NoInit() const +{ + return mpImpl->mxObjRef.GetObject(); +} + +uno::Reference< frame::XModel > SdrOle2Obj::getXModel() const +{ + if (svt::EmbeddedObjectRef::TryRunningState(GetObjRef())) + return uno::Reference< frame::XModel >( mpImpl->mxObjRef->getComponent(), uno::UNO_QUERY ); + else + return uno::Reference< frame::XModel >(); +} + +bool SdrOle2Obj::IsChart() const +{ + if (!mpImpl->mbTypeAsked) + { + mpImpl->mbIsChart = mpImpl->mxObjRef.IsChart(); + mpImpl->mbTypeAsked = true; + } + return mpImpl->mbIsChart; +} + +void SdrOle2Obj::SetGraphicToObj( const Graphic& aGraphic ) +{ + mpImpl->mxObjRef.SetGraphic( aGraphic, OUString() ); + // if the object isn't valid, e.g. link to something that doesn't exist, set the fallback + // graphic as mxGraphic so SdrOle2Obj::GetGraphic will show the fallback + if (const Graphic* pObjGraphic = mpImpl->mxObjRef.is() ? nullptr : mpImpl->mxObjRef.GetGraphic()) + mpImpl->moGraphic.emplace(*pObjGraphic); +} + +void SdrOle2Obj::SetGraphicToObj( const uno::Reference< io::XInputStream >& xGrStream, const OUString& aMediaType ) +{ + mpImpl->mxObjRef.SetGraphicStream( xGrStream, aMediaType ); + // if the object isn't valid, e.g. link to something that doesn't exist, set the fallback + // graphic as mxGraphic so SdrOle2Obj::GetGraphic will show the fallback + if (const Graphic* pObjGraphic = mpImpl->mxObjRef.is() ? nullptr : mpImpl->mxObjRef.GetGraphic()) + mpImpl->moGraphic.emplace(*pObjGraphic); +} + +bool SdrOle2Obj::IsCalc() const +{ + if ( !mpImpl->mxObjRef.is() ) + return false; + + SvGlobalName aObjClsId( mpImpl->mxObjRef->getClassID() ); + return SvGlobalName(SO3_SC_CLASSID_30) == aObjClsId + || SvGlobalName(SO3_SC_CLASSID_40) == aObjClsId + || SvGlobalName(SO3_SC_CLASSID_50) == aObjClsId + || SvGlobalName(SO3_SC_CLASSID_60) == aObjClsId + || SvGlobalName(SO3_SC_OLE_EMBED_CLASSID_60) == aObjClsId + || SvGlobalName(SO3_SC_OLE_EMBED_CLASSID_8) == aObjClsId + || SvGlobalName(SO3_SC_CLASSID) == aObjClsId; +} + +uno::Reference< frame::XModel > SdrOle2Obj::GetParentXModel() const +{ + return getSdrModelFromSdrObject().getUnoModel(); +} + +bool SdrOle2Obj::CalculateNewScaling( Fraction& aScaleWidth, Fraction& aScaleHeight, Size& aObjAreaSize ) +{ + // TODO/LEAN: to avoid rounding errors scaling always uses the VisArea. + // If we don't cache it for own objects also we must load the object here + if (!mpImpl->mxObjRef.is()) + return false; + + MapMode aMapMode(getSdrModelFromSdrObject().GetScaleUnit()); + aObjAreaSize = mpImpl->mxObjRef.GetSize( &aMapMode ); + + Size aSize = getRectangle().GetSize(); + if (!aObjAreaSize.Width() || !aObjAreaSize.Height()) + { + // avoid invalid fractions + aScaleWidth = Fraction(1,1); + aScaleHeight = Fraction(1,1); + } + else + { + aScaleWidth = Fraction(aSize.Width(), aObjAreaSize.Width() ); + aScaleHeight = Fraction(aSize.Height(), aObjAreaSize.Height() ); + // reduce to 10 binary digits + aScaleHeight.ReduceInaccurate(10); + aScaleWidth.ReduceInaccurate(10); + } + + return true; +} + +bool SdrOle2Obj::AddOwnLightClient() +{ + // The Own Light Client must be registered in object only using this method! + if ( !SfxInPlaceClient::GetClient( dynamic_cast(getSdrModelFromSdrObject().GetPersist()), mpImpl->mxObjRef.GetObject() ) + && !( mpImpl->mxLightClient.is() && mpImpl->mxObjRef->getClientSite() == uno::Reference< embed::XEmbeddedClient >( mpImpl->mxLightClient ) ) ) + { + Connect(); + + if ( mpImpl->mxObjRef.is() && mpImpl->mxLightClient.is() ) + { + Fraction aScaleWidth; + Fraction aScaleHeight; + Size aObjAreaSize; + if ( CalculateNewScaling( aScaleWidth, aScaleHeight, aObjAreaSize ) ) + { + mpImpl->mxLightClient->SetSizeScale( aScaleWidth, aScaleHeight ); + try { + mpImpl->mxObjRef->setClientSite( mpImpl->mxLightClient ); + return true; + } catch( uno::Exception& ) + {} + } + + } + + return false; + } + + return true; +} + +Graphic SdrOle2Obj::GetEmptyOLEReplacementGraphic() +{ + return Graphic(BitmapEx(BMP_SVXOLEOBJ)); +} + +void SdrOle2Obj::SetWindow(const css::uno::Reference < css::awt::XWindow >& _xWindow) +{ + if ( mpImpl->mxObjRef.is() && mpImpl->mxLightClient.is() ) + { + mpImpl->mxLightClient->setWindow(_xWindow); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdopage.cxx b/svx/source/svdraw/svdopage.cxx new file mode 100644 index 0000000000..448758646a --- /dev/null +++ b/svx/source/svdraw/svdopage.cxx @@ -0,0 +1,180 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include + + +// BaseProperties section + +std::unique_ptr SdrPageObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrPageObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +// this method is called from the destructor of the referenced page. +// do all necessary action to forget the page. It is not necessary to call +// RemovePageUser(), that is done from the destructor. +void SdrPageObj::PageInDestruction(const SdrPage& rPage) +{ + if(mpShownPage && mpShownPage == &rPage) + { + // #i58769# Do not call ActionChanged() here, because that would + // lead to the construction of a view contact object for a page that + // is being destroyed. + + mpShownPage = nullptr; + } +} + +SdrPageObj::SdrPageObj( + SdrModel& rSdrModel, + SdrPage* pNewPage) +: SdrObject(rSdrModel), + mpShownPage(pNewPage) +{ + if(mpShownPage) + { + mpShownPage->AddPageUser(*this); + } +} + +SdrPageObj::SdrPageObj(SdrModel& rSdrModel, SdrPageObj const & rSource) +: SdrObject(rSdrModel, rSource), + mpShownPage(nullptr) +{ + SetReferencedPage( rSource.GetReferencedPage()); +} + +SdrPageObj::SdrPageObj( + SdrModel& rSdrModel, + const tools::Rectangle& rRect, + SdrPage* pNewPage) +: SdrObject(rSdrModel), + mpShownPage(pNewPage) +{ + if(mpShownPage) + { + mpShownPage->AddPageUser(*this); + } + + setOutRectangle(rRect); +} + +SdrPageObj::~SdrPageObj() +{ + if(mpShownPage) + { + mpShownPage->RemovePageUser(*this); + } +} + + +void SdrPageObj::SetReferencedPage(SdrPage* pNewPage) +{ + if(mpShownPage == pNewPage) + return; + + if(mpShownPage) + { + mpShownPage->RemovePageUser(*this); + } + + mpShownPage = pNewPage; + + if(mpShownPage) + { + mpShownPage->AddPageUser(*this); + } + + SetChanged(); + BroadcastObjectChange(); +} + +// #i96598# +void SdrPageObj::SetBoundRectDirty() +{ + // avoid resetting aOutRect which in case of this object is model data, + // not re-creatable view data +} + +SdrObjKind SdrPageObj::GetObjIdentifier() const +{ + return SdrObjKind::Page; +} + +void SdrPageObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bRotateFreeAllowed=false; + rInfo.bRotate90Allowed =false; + rInfo.bMirrorFreeAllowed=false; + rInfo.bMirror45Allowed =false; + rInfo.bMirror90Allowed =false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed =false; + rInfo.bEdgeRadiusAllowed=false; + rInfo.bNoOrthoDesired =false; + rInfo.bCanConvToPath =false; + rInfo.bCanConvToPoly =false; + rInfo.bCanConvToPathLineToArea=false; + rInfo.bCanConvToPolyLineToArea=false; +} + +rtl::Reference SdrPageObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrPageObj(rTargetModel, *this); +} + +OUString SdrPageObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulPAGE)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrPageObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralPAGE); +} + +void SdrPageObj::NbcRotate(const Point& /*rRef*/, Degree100 /*nAngle*/, double /*sinAngle*/, double /*cosAngle*/) +{ + assert(false); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdopath.cxx b/svx/source/svdraw/svdopath.cxx new file mode 100644 index 0000000000..d76faf3204 --- /dev/null +++ b/svx/source/svdraw/svdopath.cxx @@ -0,0 +1,2986 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace sdr; + +static sal_uInt16 GetPrevPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, bool bClosed) +{ + if (nPnt>0) { + nPnt--; + } else { + nPnt=nPntMax; + if (bClosed) nPnt--; + } + return nPnt; +} + +static sal_uInt16 GetNextPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, bool bClosed) +{ + nPnt++; + if (nPnt>nPntMax || (bClosed && nPnt>=nPntMax)) nPnt=0; + return nPnt; +} + +namespace { + +struct ImpSdrPathDragData : public SdrDragStatUserData +{ + XPolygon aXP; // section of the original polygon + bool bValid; // FALSE = too few points + bool bClosed; // closed object? + sal_uInt16 nPoly; // number of the polygon in the PolyPolygon + sal_uInt16 nPnt; // number of point in the above polygon + sal_uInt16 nPointCount; // number of points of the polygon + bool bBegPnt; // dragged point is first point of a Polyline + bool bEndPnt; // dragged point is finishing point of a Polyline + sal_uInt16 nPrevPnt; // index of previous point + sal_uInt16 nNextPnt; // index of next point + bool bPrevIsBegPnt; // previous point is first point of a Polyline + bool bNextIsEndPnt; // next point is first point of a Polyline + sal_uInt16 nPrevPrevPnt; // index of point before previous point + sal_uInt16 nNextNextPnt; // index of point after next point + bool bControl; // point is a control point + bool bIsNextControl; // point is a control point after a support point + bool bPrevIsControl; // if nPnt is a support point: a control point comes before + bool bNextIsControl; // if nPnt is a support point: a control point comes after + sal_uInt16 nPrevPrevPnt0; + sal_uInt16 nPrevPnt0; + sal_uInt16 nPnt0; + sal_uInt16 nNextPnt0; + sal_uInt16 nNextNextPnt0; + bool bEliminate; // delete point? (is set by MovDrag) + + bool mbMultiPointDrag; + const XPolyPolygon maOrig; + XPolyPolygon maMove; + std::vector maHandles; + +public: + ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, bool bMuPoDr, const SdrDragStat& rDrag); + void ResetPoly(const SdrPathObj& rPO); + bool IsMultiPointDrag() const { return mbMultiPointDrag; } +}; + +} + +ImpSdrPathDragData::ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, bool bMuPoDr, const SdrDragStat& rDrag) + : aXP(5) + , bValid(false) + , bClosed(false) + , nPoly(0) + , nPnt(0) + , nPointCount(0) + , bBegPnt(false) + , bEndPnt(false) + , nPrevPnt(0) + , nNextPnt(0) + , bPrevIsBegPnt(false) + , bNextIsEndPnt(false) + , nPrevPrevPnt(0) + , nNextNextPnt(0) + , bControl(false) + , bIsNextControl(false) + , bPrevIsControl(false) + , bNextIsControl(false) + , nPrevPrevPnt0(0) + , nPrevPnt0(0) + , nPnt0(0) + , nNextPnt0(0) + , nNextNextPnt0(0) + , bEliminate(false) + , mbMultiPointDrag(bMuPoDr) + , maOrig(rPO.GetPathPoly()) + , maHandles(0) +{ + if(mbMultiPointDrag) + { + const SdrMarkView& rMarkView = *rDrag.GetView(); + const SdrHdlList& rHdlList = rMarkView.GetHdlList(); + const size_t nHdlCount = rHdlList.GetHdlCount(); + const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : nullptr); + + for(size_t a = 0; a < nHdlCount; ++a) + { + SdrHdl* pTestHdl = rHdlList.GetHdl(a); + + if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject) + { + maHandles.push_back(pTestHdl); + } + } + + maMove = maOrig; + bValid = true; + } + else + { + sal_uInt16 nPntMax = 0; // maximum index + bValid=false; + bClosed=rPO.IsClosed(); // closed object? + nPoly=static_cast(rHdl.GetPolyNum()); // number of the polygon in the PolyPolygon + nPnt=static_cast(rHdl.GetPointNum()); // number of points in the above polygon + const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly)); + nPointCount=aTmpXP.GetPointCount(); // number of point of the polygon + if (nPointCount==0 || (bClosed && nPointCount==1)) return; // minimum of 1 points for Lines, minimum of 2 points for Polygon + nPntMax=nPointCount-1; // maximum index + bBegPnt=!bClosed && nPnt==0; // dragged point is first point of a Polyline + bEndPnt=!bClosed && nPnt==nPntMax; // dragged point is finishing point of a Polyline + if (bClosed && nPointCount<=3) { // if polygon is only a line + bBegPnt=(nPointCount<3) || nPnt==0; + bEndPnt=(nPointCount<3) || nPnt==nPntMax-1; + } + nPrevPnt=nPnt; // index of previous point + nNextPnt=nPnt; // index of next point + if (!bBegPnt) nPrevPnt=GetPrevPnt(nPnt,nPntMax,bClosed); + if (!bEndPnt) nNextPnt=GetNextPnt(nPnt,nPntMax,bClosed); + bPrevIsBegPnt=bBegPnt || (!bClosed && nPrevPnt==0); + bNextIsEndPnt=bEndPnt || (!bClosed && nNextPnt==nPntMax); + nPrevPrevPnt=nPnt; // index of point before previous point + nNextNextPnt=nPnt; // index of point after next point + if (!bPrevIsBegPnt) nPrevPrevPnt=GetPrevPnt(nPrevPnt,nPntMax,bClosed); + if (!bNextIsEndPnt) nNextNextPnt=GetNextPnt(nNextPnt,nPntMax,bClosed); + bControl=rHdl.IsPlusHdl(); // point is a control point + bIsNextControl=false; // point is a control point after a support point + bPrevIsControl=false; // if nPnt is a support point: a control point comes before + bNextIsControl=false; // if nPnt is a support point: a control point comes after + if (bControl) { + bIsNextControl=!aTmpXP.IsControl(nPrevPnt); + } else { + bPrevIsControl=!bBegPnt && !bPrevIsBegPnt && aTmpXP.GetFlags(nPrevPnt)==PolyFlags::Control; + bNextIsControl=!bEndPnt && !bNextIsEndPnt && aTmpXP.GetFlags(nNextPnt)==PolyFlags::Control; + } + nPrevPrevPnt0=nPrevPrevPnt; + nPrevPnt0 =nPrevPnt; + nPnt0 =nPnt; + nNextPnt0 =nNextPnt; + nNextNextPnt0=nNextNextPnt; + nPrevPrevPnt=0; + nPrevPnt=1; + nPnt=2; + nNextPnt=3; + nNextNextPnt=4; + bEliminate=false; + ResetPoly(rPO); + bValid=true; + } +} + +void ImpSdrPathDragData::ResetPoly(const SdrPathObj& rPO) +{ + const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly)); + aXP[0]=aTmpXP[nPrevPrevPnt0]; aXP.SetFlags(0,aTmpXP.GetFlags(nPrevPrevPnt0)); + aXP[1]=aTmpXP[nPrevPnt0]; aXP.SetFlags(1,aTmpXP.GetFlags(nPrevPnt0)); + aXP[2]=aTmpXP[nPnt0]; aXP.SetFlags(2,aTmpXP.GetFlags(nPnt0)); + aXP[3]=aTmpXP[nNextPnt0]; aXP.SetFlags(3,aTmpXP.GetFlags(nNextPnt0)); + aXP[4]=aTmpXP[nNextNextPnt0]; aXP.SetFlags(4,aTmpXP.GetFlags(nNextNextPnt0)); +} + +namespace { + +struct ImpPathCreateUser : public SdrDragStatUserData +{ + Point aBezControl0; + Point aBezStart; + Point aBezCtrl1; + Point aBezCtrl2; + Point aBezEnd; + Point aCircStart; + Point aCircEnd; + Point aCircCenter; + Point aLineStart; + Point aLineEnd; + Point aRectP1; + Point aRectP2; + Point aRectP3; + tools::Long nCircRadius; + Degree100 nCircStAngle; + Degree100 nCircRelAngle; + bool bBezier; + bool bBezHasCtrl0; + bool bCircle; + bool bAngleSnap; + bool bLine; + bool bLine90; + bool bRect; + bool bMixedCreate; + sal_uInt16 nBezierStartPoint; + SdrObjKind eStartKind; + SdrObjKind eCurrentKind; + +public: + ImpPathCreateUser(): nCircRadius(0),nCircStAngle(0),nCircRelAngle(0), + bBezier(false),bBezHasCtrl0(false),bCircle(false),bAngleSnap(false),bLine(false),bLine90(false),bRect(false), + bMixedCreate(false),nBezierStartPoint(0),eStartKind(SdrObjKind::NONE),eCurrentKind(SdrObjKind::NONE) { } + + void ResetFormFlags() { bBezier=false; bCircle=false; bLine=false; bRect=false; } + bool IsFormFlag() const { return bBezier || bCircle || bLine || bRect; } + XPolygon GetFormPoly() const; + void CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, bool bMouseDown); + XPolygon GetBezierPoly() const; + void CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView); + XPolygon GetCirclePoly() const; + void CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView); + static Point CalcLine(const Point& rCsr, tools::Long nDirX, tools::Long nDirY, SdrView const * pView); + XPolygon GetLinePoly() const; + void CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView); + XPolygon GetRectPoly() const; +}; + +} + +XPolygon ImpPathCreateUser::GetFormPoly() const +{ + if (bBezier) return GetBezierPoly(); + if (bCircle) return GetCirclePoly(); + if (bLine) return GetLinePoly(); + if (bRect) return GetRectPoly(); + return XPolygon(); +} + +void ImpPathCreateUser::CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, bool bMouseDown) +{ + aBezStart=rP1; + aBezCtrl1=rP1+rDir; + aBezCtrl2=rP2; + + // #i21479# + // Also copy the end point when no end point is set yet + if (!bMouseDown || (0 == aBezEnd.X() && 0 == aBezEnd.Y())) aBezEnd=rP2; + + bBezier=true; +} + +XPolygon ImpPathCreateUser::GetBezierPoly() const +{ + XPolygon aXP(4); + aXP[0]=aBezStart; aXP.SetFlags(0,PolyFlags::Smooth); + aXP[1]=aBezCtrl1; aXP.SetFlags(1,PolyFlags::Control); + aXP[2]=aBezCtrl2; aXP.SetFlags(2,PolyFlags::Control); + aXP[3]=aBezEnd; + return aXP; +} + +void ImpPathCreateUser::CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView) +{ + Degree100 nTangAngle=GetAngle(rDir); + aCircStart=rP1; + aCircEnd=rP2; + aCircCenter=rP1; + tools::Long dx=rP2.X()-rP1.X(); + tools::Long dy=rP2.Y()-rP1.Y(); + Degree100 dAngle=GetAngle(Point(dx,dy))-nTangAngle; + dAngle=NormAngle36000(dAngle); + Degree100 nTmpAngle=NormAngle36000(9000_deg100-dAngle); + bool bRet=nTmpAngle!=9000_deg100 && nTmpAngle!=27000_deg100; + tools::Long nRad=0; + if (bRet) { + double cs = cos(toRadians(nTmpAngle)); + double nR=static_cast(GetLen(Point(dx,dy)))/cs/2; + nRad=std::abs(FRound(nR)); + } + if (dAngle<18000_deg100) { + nCircStAngle=NormAngle36000(nTangAngle-9000_deg100); + nCircRelAngle=NormAngle36000(2_deg100*dAngle); + aCircCenter.AdjustX(FRound(nRad * cos(toRadians(nTangAngle + 9000_deg100)))); + aCircCenter.AdjustY(-(FRound(nRad * sin(toRadians(nTangAngle + 9000_deg100))))); + } else { + nCircStAngle=NormAngle36000(nTangAngle+9000_deg100); + nCircRelAngle=-NormAngle36000(36000_deg100-2_deg100*dAngle); + aCircCenter.AdjustX(FRound(nRad * cos(toRadians(nTangAngle - 9000_deg100)))); + aCircCenter.AdjustY(-(FRound(nRad * sin(toRadians(nTangAngle - 9000_deg100))))); + } + bAngleSnap=pView!=nullptr && pView->IsAngleSnapEnabled(); + if (bAngleSnap) { + Degree100 nSA=pView->GetSnapAngle(); + if (nSA) { // angle snapping + bool bNeg=nCircRelAngle<0_deg100; + if (bNeg) nCircRelAngle=-nCircRelAngle; + nCircRelAngle+=nSA/2_deg100; + nCircRelAngle/=nSA; + nCircRelAngle*=nSA; + nCircRelAngle=NormAngle36000(nCircRelAngle); + if (bNeg) nCircRelAngle=-nCircRelAngle; + } + } + nCircRadius=nRad; + if (nRad==0 || abs(nCircRelAngle).get()<5) bRet=false; + bCircle=bRet; +} + +XPolygon ImpPathCreateUser::GetCirclePoly() const +{ + if (nCircRelAngle>=0_deg100) { + XPolygon aXP(aCircCenter,nCircRadius,nCircRadius, + nCircStAngle, nCircStAngle+nCircRelAngle,false); + aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth); + if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd; + return aXP; + } else { + XPolygon aXP(aCircCenter,nCircRadius,nCircRadius, + NormAngle36000(nCircStAngle+nCircRelAngle), nCircStAngle,false); + sal_uInt16 nCount=aXP.GetPointCount(); + for (sal_uInt16 nNum=nCount/2; nNum>0;) { + nNum--; // reverse XPoly's order of points + sal_uInt16 n2=nCount-nNum-1; + Point aPt(aXP[nNum]); + aXP[nNum]=aXP[n2]; + aXP[n2]=aPt; + } + aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth); + if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd; + return aXP; + } +} + +Point ImpPathCreateUser::CalcLine(const Point& aCsr, tools::Long nDirX, tools::Long nDirY, SdrView const * pView) +{ + tools::Long x=aCsr.X(); + tools::Long y=aCsr.Y(); + bool bHLin=nDirY==0; + bool bVLin=nDirX==0; + if (bHLin) y=0; + else if (bVLin) x=0; + else { + tools::Long x1=BigMulDiv(y,nDirX,nDirY); + tools::Long y1=y; + tools::Long x2=x; + tools::Long y2=BigMulDiv(x,nDirY,nDirX); + tools::Long l1=std::abs(x1)+std::abs(y1); + tools::Long l2=std::abs(x2)+std::abs(y2); + if ((l1<=l2) != (pView!=nullptr && pView->IsBigOrtho())) { + x=x1; y=y1; + } else { + x=x2; y=y2; + } + } + return Point(x,y); +} + +void ImpPathCreateUser::CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView) +{ + aLineStart=rP1; + aLineEnd=rP2; + bLine90=false; + if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bLine=false; return; } + Point aTmpPt(rP2-rP1); + tools::Long nDirX=rDir.X(); + tools::Long nDirY=rDir.Y(); + Point aP1(CalcLine(aTmpPt, nDirX, nDirY,pView)); aP1-=aTmpPt; tools::Long nQ1=std::abs(aP1.X())+std::abs(aP1.Y()); + Point aP2(CalcLine(aTmpPt, nDirY,-nDirX,pView)); aP2-=aTmpPt; tools::Long nQ2=std::abs(aP2.X())+std::abs(aP2.Y()); + if (pView!=nullptr && pView->IsOrtho()) nQ1=0; // Ortho turns off at right angle + bLine90=nQ1>2*nQ2; + if (!bLine90) { // smooth transition + aLineEnd+=aP1; + } else { // rectangular transition + aLineEnd+=aP2; + } + bLine=true; +} + +XPolygon ImpPathCreateUser::GetLinePoly() const +{ + XPolygon aXP(2); + aXP[0]=aLineStart; if (!bLine90) aXP.SetFlags(0,PolyFlags::Smooth); + aXP[1]=aLineEnd; + return aXP; +} + +void ImpPathCreateUser::CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView) +{ + aRectP1=rP1; + aRectP2=rP1; + aRectP3=rP2; + if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bRect=false; return; } + Point aTmpPt(rP2-rP1); + tools::Long nDirX=rDir.X(); + tools::Long nDirY=rDir.Y(); + tools::Long x=aTmpPt.X(); + tools::Long y=aTmpPt.Y(); + bool bHLin=nDirY==0; + bool bVLin=nDirX==0; + if (bHLin) y=0; + else if (bVLin) x=0; + else { + y=BigMulDiv(x,nDirY,nDirX); + tools::Long nHypLen=aTmpPt.Y()-y; + Degree100 nTangAngle=-GetAngle(rDir); + // sin=g/h, g=h*sin + double a = toRadians(nTangAngle); + double sn=sin(a); + double cs=cos(a); + double nGKathLen=nHypLen*sn; + y+=FRound(nGKathLen*sn); + x+=FRound(nGKathLen*cs); + } + aRectP2.AdjustX(x ); + aRectP2.AdjustY(y ); + if (pView!=nullptr && pView->IsOrtho()) { + tools::Long dx1=aRectP2.X()-aRectP1.X(); tools::Long dx1a=std::abs(dx1); + tools::Long dy1=aRectP2.Y()-aRectP1.Y(); tools::Long dy1a=std::abs(dy1); + tools::Long dx2=aRectP3.X()-aRectP2.X(); tools::Long dx2a=std::abs(dx2); + tools::Long dy2=aRectP3.Y()-aRectP2.Y(); tools::Long dy2a=std::abs(dy2); + bool b1MoreThan2=dx1a+dy1a>dx2a+dy2a; + if (b1MoreThan2 != pView->IsBigOrtho()) { + tools::Long xtemp=dy2a-dx1a; if (dx1<0) xtemp=-xtemp; + tools::Long ytemp=dx2a-dy1a; if (dy1<0) ytemp=-ytemp; + aRectP2.AdjustX(xtemp ); + aRectP2.AdjustY(ytemp ); + aRectP3.AdjustX(xtemp ); + aRectP3.AdjustY(ytemp ); + } else { + tools::Long xtemp=dy1a-dx2a; if (dx2<0) xtemp=-xtemp; + tools::Long ytemp=dx1a-dy2a; if (dy2<0) ytemp=-ytemp; + aRectP3.AdjustX(xtemp ); + aRectP3.AdjustY(ytemp ); + } + } + bRect=true; +} + +XPolygon ImpPathCreateUser::GetRectPoly() const +{ + XPolygon aXP(3); + aXP[0]=aRectP1; aXP.SetFlags(0,PolyFlags::Smooth); + aXP[1]=aRectP2; + if (aRectP3!=aRectP2) aXP[2]=aRectP3; + return aXP; +} + +class ImpPathForDragAndCreate +{ + SdrPathObj& mrSdrPathObject; + XPolyPolygon aPathPolygon; + SdrObjKind meObjectKind; + std::unique_ptr + mpSdrPathDragData; + bool mbCreating; + +public: + explicit ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject); + + // drag stuff + bool beginPathDrag( SdrDragStat const & rDrag ) const; + bool movePathDrag( SdrDragStat& rDrag ) const; + bool endPathDrag( SdrDragStat const & rDrag ); + OUString getSpecialDragComment(const SdrDragStat& rDrag) const; + basegfx::B2DPolyPolygon getSpecialDragPoly(const SdrDragStat& rDrag) const; + + // create stuff + void BegCreate(SdrDragStat& rStat); + bool MovCreate(SdrDragStat& rStat); + bool EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd); + bool BckCreate(SdrDragStat const & rStat); + void BrkCreate(SdrDragStat& rStat); + PointerStyle GetCreatePointer() const; + + // helping stuff + static bool IsClosed(SdrObjKind eKind) { return eKind==SdrObjKind::Polygon || eKind==SdrObjKind::PathPoly || eKind==SdrObjKind::PathFill || eKind==SdrObjKind::FreehandFill; } + static bool IsFreeHand(SdrObjKind eKind) { return eKind==SdrObjKind::FreehandLine || eKind==SdrObjKind::FreehandFill; } + static bool IsBezier(SdrObjKind eKind) { return eKind==SdrObjKind::PathLine || eKind==SdrObjKind::PathFill; } + bool IsCreating() const { return mbCreating; } + + // get the polygon + basegfx::B2DPolyPolygon TakeObjectPolyPolygon(const SdrDragStat& rDrag) const; + static basegfx::B2DPolyPolygon TakeDragPolyPolygon(const SdrDragStat& rDrag); + basegfx::B2DPolyPolygon getModifiedPolyPolygon() const { return aPathPolygon.getB2DPolyPolygon(); } +}; + +ImpPathForDragAndCreate::ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject) +: mrSdrPathObject(rSdrPathObject), + aPathPolygon(rSdrPathObject.GetPathPoly()), + meObjectKind(mrSdrPathObject.meKind), + mbCreating(false) +{ +} + +bool ImpPathForDragAndCreate::beginPathDrag( SdrDragStat const & rDrag ) const +{ + const SdrHdl* pHdl=rDrag.GetHdl(); + if(!pHdl) + return false; + + bool bMultiPointDrag(true); + + if(aPathPolygon[static_cast(pHdl->GetPolyNum())].IsControl(static_cast(pHdl->GetPointNum()))) + bMultiPointDrag = false; + + if(bMultiPointDrag) + { + const SdrMarkView& rMarkView = *rDrag.GetView(); + const SdrHdlList& rHdlList = rMarkView.GetHdlList(); + const size_t nHdlCount = rHdlList.GetHdlCount(); + const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : nullptr); + sal_uInt32 nSelectedPoints(0); + + for(size_t a = 0; a < nHdlCount; ++a) + { + SdrHdl* pTestHdl = rHdlList.GetHdl(a); + + if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject) + { + nSelectedPoints++; + } + } + + if(nSelectedPoints <= 1) + bMultiPointDrag = false; + } + + const_cast(this)->mpSdrPathDragData.reset( new ImpSdrPathDragData(mrSdrPathObject,*pHdl,bMultiPointDrag,rDrag) ); + + if(!mpSdrPathDragData || !mpSdrPathDragData->bValid) + { + OSL_FAIL("ImpPathForDragAndCreate::BegDrag(): ImpSdrPathDragData is invalid."); + const_cast(this)->mpSdrPathDragData.reset(); + return false; + } + + return true; +} + +bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const +{ + if(!mpSdrPathDragData || !mpSdrPathDragData->bValid) + { + OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid."); + return false; + } + + if(mpSdrPathDragData->IsMultiPointDrag()) + { + Point aDelta(rDrag.GetNow() - rDrag.GetStart()); + + if(aDelta.X() || aDelta.Y()) + { + for(SdrHdl* pHandle : mpSdrPathDragData->maHandles) + { + const sal_uInt16 nPolyIndex(static_cast(pHandle->GetPolyNum())); + const sal_uInt16 nPointIndex(static_cast(pHandle->GetPointNum())); + const XPolygon& rOrig = mpSdrPathDragData->maOrig[nPolyIndex]; + XPolygon& rMove = mpSdrPathDragData->maMove[nPolyIndex]; + const sal_uInt16 nPointCount(rOrig.GetPointCount()); + bool bClosed(rOrig[0] == rOrig[nPointCount-1]); + + // move point itself + rMove[nPointIndex] = rOrig[nPointIndex] + aDelta; + + // when point is first and poly closed, move close point, too. + if(nPointCount > 0 && !nPointIndex && bClosed) + { + rMove[nPointCount - 1] = rOrig[nPointCount - 1] + aDelta; + + // when moving the last point it may be necessary to move the + // control point in front of this one, too. + if(nPointCount > 1 && rOrig.IsControl(nPointCount - 2)) + rMove[nPointCount - 2] = rOrig[nPointCount - 2] + aDelta; + } + + // is a control point before this? + if(nPointIndex > 0 && rOrig.IsControl(nPointIndex - 1)) + { + // Yes, move it, too + rMove[nPointIndex - 1] = rOrig[nPointIndex - 1] + aDelta; + } + + // is a control point after this? + if(nPointIndex + 1 < nPointCount && rOrig.IsControl(nPointIndex + 1)) + { + // Yes, move it, too + rMove[nPointIndex + 1] = rOrig[nPointIndex + 1] + aDelta; + } + } + } + } + else + { + mpSdrPathDragData->ResetPoly(mrSdrPathObject); + + // copy certain data locally to use less code and have faster access times + bool bClosed =mpSdrPathDragData->bClosed ; // closed object? + sal_uInt16 nPnt =mpSdrPathDragData->nPnt ; // number of point in the above polygon + bool bBegPnt =mpSdrPathDragData->bBegPnt ; // dragged point is first point of a Polyline + bool bEndPnt =mpSdrPathDragData->bEndPnt ; // dragged point is last point of a Polyline + sal_uInt16 nPrevPnt =mpSdrPathDragData->nPrevPnt ; // index of previous point + sal_uInt16 nNextPnt =mpSdrPathDragData->nNextPnt ; // index of next point + bool bPrevIsBegPnt =mpSdrPathDragData->bPrevIsBegPnt ; // previous point is first point of a Polyline + bool bNextIsEndPnt =mpSdrPathDragData->bNextIsEndPnt ; // next point is last point of a Polyline + sal_uInt16 nPrevPrevPnt =mpSdrPathDragData->nPrevPrevPnt ; // index of the point before the previous point + sal_uInt16 nNextNextPnt =mpSdrPathDragData->nNextNextPnt ; // index if the point after the next point + bool bControl =mpSdrPathDragData->bControl ; // point is a control point + bool bIsNextControl =mpSdrPathDragData->bIsNextControl; // point is a control point after a support point + bool bPrevIsControl =mpSdrPathDragData->bPrevIsControl; // if nPnt is a support point: there's a control point before + bool bNextIsControl =mpSdrPathDragData->bNextIsControl; // if nPnt is a support point: there's a control point after + + // Ortho for lines/polygons: keep angle + if (!bControl && rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho()) { + bool bBigOrtho=rDrag.GetView()->IsBigOrtho(); + Point aPos(rDrag.GetNow()); // current position + Point aPnt(mpSdrPathDragData->aXP[nPnt]); // the dragged point + sal_uInt16 nPnt1=0xFFFF,nPnt2=0xFFFF; // its neighboring points + Point aNewPos1,aNewPos2; // new alternative for aPos + bool bPnt1 = false, bPnt2 = false; // are these valid alternatives? + if (!bClosed && mpSdrPathDragData->nPointCount>=2) { // minimum of 2 points for lines + if (!bBegPnt) nPnt1=nPrevPnt; + if (!bEndPnt) nPnt2=nNextPnt; + } + if (bClosed && mpSdrPathDragData->nPointCount>=3) { // minimum of 3 points for polygon + nPnt1=nPrevPnt; + nPnt2=nNextPnt; + } + if (nPnt1!=0xFFFF && !bPrevIsControl) { + Point aPnt1=mpSdrPathDragData->aXP[nPnt1]; + tools::Long ndx0=aPnt.X()-aPnt1.X(); + tools::Long ndy0=aPnt.Y()-aPnt1.Y(); + bool bHLin=ndy0==0; + bool bVLin=ndx0==0; + if (!bHLin || !bVLin) { + tools::Long ndx=aPos.X()-aPnt1.X(); + tools::Long ndy=aPos.Y()-aPnt1.Y(); + bPnt1=true; + double nXFact=0; if (!bVLin) nXFact=static_cast(ndx)/static_cast(ndx0); + double nYFact=0; if (!bHLin) nYFact=static_cast(ndy)/static_cast(ndy0); + bool bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho); + bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho); + if (bHor) ndy=tools::Long(ndy0*nXFact); + if (bVer) ndx=tools::Long(ndx0*nYFact); + aNewPos1=aPnt1; + aNewPos1.AdjustX(ndx ); + aNewPos1.AdjustY(ndy ); + } + } + if (nPnt2!=0xFFFF && !bNextIsControl) { + Point aPnt2=mpSdrPathDragData->aXP[nPnt2]; + tools::Long ndx0=aPnt.X()-aPnt2.X(); + tools::Long ndy0=aPnt.Y()-aPnt2.Y(); + bool bHLin=ndy0==0; + bool bVLin=ndx0==0; + if (!bHLin || !bVLin) { + tools::Long ndx=aPos.X()-aPnt2.X(); + tools::Long ndy=aPos.Y()-aPnt2.Y(); + bPnt2=true; + double nXFact=0; if (!bVLin) nXFact=static_cast(ndx)/static_cast(ndx0); + double nYFact=0; if (!bHLin) nYFact=static_cast(ndy)/static_cast(ndy0); + bool bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho); + bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho); + if (bHor) ndy=tools::Long(ndy0*nXFact); + if (bVer) ndx=tools::Long(ndx0*nYFact); + aNewPos2=aPnt2; + aNewPos2.AdjustX(ndx ); + aNewPos2.AdjustY(ndy ); + } + } + if (bPnt1 && bPnt2) { // both alternatives exist (and compete) + BigInt nX1(aNewPos1.X()-aPos.X()); nX1*=nX1; + BigInt nY1(aNewPos1.Y()-aPos.Y()); nY1*=nY1; + BigInt nX2(aNewPos2.X()-aPos.X()); nX2*=nX2; + BigInt nY2(aNewPos2.Y()-aPos.Y()); nY2*=nY2; + nX1+=nY1; // correction distance to square + nX2+=nY2; // correction distance to square + // let the alternative that allows fewer correction win + if (nX1IsEliminatePolyPoints() && + !bBegPnt && !bEndPnt && !bPrevIsControl && !bNextIsControl) + { + Point aPt(mpSdrPathDragData->aXP[nNextPnt]); + aPt-=rDrag.GetNow(); + Degree100 nAngle1=GetAngle(aPt); + aPt=rDrag.GetNow(); + aPt-=mpSdrPathDragData->aXP[nPrevPnt]; + Degree100 nAngle2=GetAngle(aPt); + Degree100 nDiff=nAngle1-nAngle2; + nDiff=abs(nDiff); + mpSdrPathDragData->bEliminate=nDiff<=rDrag.GetView()->GetEliminatePolyPointLimitAngle(); + if (mpSdrPathDragData->bEliminate) { // adapt position, Smooth is true for the ends + aPt=mpSdrPathDragData->aXP[nNextPnt]; + aPt+=mpSdrPathDragData->aXP[nPrevPnt]; + aPt/=2; + rDrag.SetNow(aPt); + } + } + + // we dragged by this distance + Point aDiff(rDrag.GetNow()); aDiff-=mpSdrPathDragData->aXP[nPnt]; + + /* There are 8 possible cases: + X 1. A control point neither on the left nor on the right. + o--X--o 2. There are control points on the left and the right, we are dragging a support point. + o--X 3. There is a control point on the left, we are dragging a support point. + X--o 4. There is a control point on the right, we are dragging a support point. + x--O--o 5. There are control points on the left and the right, we are dragging the left one. + x--O 6. There is a control point on the left, we are dragging it. + o--O--x 7. There are control points on the left and the right, we are dragging the right one. + O--x 8. There is a control point on the right, we are dragging it. + Note: modifying a line (not a curve!) might create a curve on the other end of the line + if Smooth is set there (with control points aligned to line). + */ + + mpSdrPathDragData->aXP[nPnt]+=aDiff; + + // now check symmetric plus handles + if (bControl) { // cases 5,6,7,8 + sal_uInt16 nSt; // the associated support point + sal_uInt16 nFix; // the opposing control point + if (bIsNextControl) { // if the next one is a control point, the on before has to be a support point + nSt=nPrevPnt; + nFix=nPrevPrevPnt; + } else { + nSt=nNextPnt; + nFix=nNextNextPnt; + } + if (mpSdrPathDragData->aXP.IsSmooth(nSt)) { + mpSdrPathDragData->aXP.CalcSmoothJoin(nSt,nPnt,nFix); + } + } + + if (!bControl) { // Cases 1,2,3,4. In case 1, nothing happens; in cases 3 and 4, there is more following below. + // move both control points + if (bPrevIsControl) mpSdrPathDragData->aXP[nPrevPnt]+=aDiff; + if (bNextIsControl) mpSdrPathDragData->aXP[nNextPnt]+=aDiff; + // align control point to line, if appropriate + if (mpSdrPathDragData->aXP.IsSmooth(nPnt)) { + if (bPrevIsControl && !bNextIsControl && !bEndPnt) { // case 3 + mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nNextPnt,nPrevPnt); + } + if (bNextIsControl && !bPrevIsControl && !bBegPnt) { // case 4 + mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nPrevPnt,nNextPnt); + } + } + // Now check the other ends of the line (nPnt+-1). If there is a + // curve (IsControl(nPnt+-2)) with SmoothJoin (nPnt+-1), the + // associated control point (nPnt+-2) has to be adapted. + if (!bBegPnt && !bPrevIsControl && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsSmooth(nPrevPnt)) { + if (mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) { + mpSdrPathDragData->aXP.CalcSmoothJoin(nPrevPnt,nPnt,nPrevPrevPnt); + } + } + if (!bEndPnt && !bNextIsControl && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsSmooth(nNextPnt)) { + if (mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) { + mpSdrPathDragData->aXP.CalcSmoothJoin(nNextPnt,nPnt,nNextNextPnt); + } + } + } + } + + return true; +} + +bool ImpPathForDragAndCreate::endPathDrag(SdrDragStat const & rDrag) +{ + Point aLinePt1; + Point aLinePt2; + bool bLineGlueMirror(SdrObjKind::Line == meObjectKind); + if (bLineGlueMirror) { + XPolygon& rXP=aPathPolygon[0]; + aLinePt1=rXP[0]; + aLinePt2=rXP[1]; + } + + if(!mpSdrPathDragData || !mpSdrPathDragData->bValid) + { + OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid."); + return false; + } + + if(mpSdrPathDragData->IsMultiPointDrag()) + { + aPathPolygon = mpSdrPathDragData->maMove; + } + else + { + const SdrHdl* pHdl=rDrag.GetHdl(); + + // reference the polygon + XPolygon& rXP=aPathPolygon[static_cast(pHdl->GetPolyNum())]; + + // the 5 points that might have changed + if (!mpSdrPathDragData->bPrevIsBegPnt) rXP[mpSdrPathDragData->nPrevPrevPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPrevPnt]; + if (!mpSdrPathDragData->bNextIsEndPnt) rXP[mpSdrPathDragData->nNextNextPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nNextNextPnt]; + if (!mpSdrPathDragData->bBegPnt) rXP[mpSdrPathDragData->nPrevPnt0] =mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPnt]; + if (!mpSdrPathDragData->bEndPnt) rXP[mpSdrPathDragData->nNextPnt0] =mpSdrPathDragData->aXP[mpSdrPathDragData->nNextPnt]; + rXP[mpSdrPathDragData->nPnt0] =mpSdrPathDragData->aXP[mpSdrPathDragData->nPnt]; + + // for closed objects: last point has to be equal to first point + if (mpSdrPathDragData->bClosed) rXP[rXP.GetPointCount()-1]=rXP[0]; + + if (mpSdrPathDragData->bEliminate) + { + basegfx::B2DPolyPolygon aTempPolyPolygon(aPathPolygon.getB2DPolyPolygon()); + sal_uInt32 nPoly,nPnt; + + if(PolyPolygonEditor::GetRelativePolyPoint(aTempPolyPolygon, rDrag.GetHdl()->GetSourceHdlNum(), nPoly, nPnt)) + { + basegfx::B2DPolygon aCandidate(aTempPolyPolygon.getB2DPolygon(nPoly)); + aCandidate.remove(nPnt); + + if(aCandidate.count() < 2) + { + aTempPolyPolygon.remove(nPoly); + } + else + { + aTempPolyPolygon.setB2DPolygon(nPoly, aCandidate); + } + } + + aPathPolygon = XPolyPolygon(aTempPolyPolygon); + } + + // adapt angle for text beneath a simple line + if (bLineGlueMirror) + { + Point aLinePt1_(aPathPolygon[0][0]); + Point aLinePt2_(aPathPolygon[0][1]); + bool bXMirr=(aLinePt1_.X()>aLinePt2_.X())!=(aLinePt1.X()>aLinePt2.X()); + bool bYMirr=(aLinePt1_.Y()>aLinePt2_.Y())!=(aLinePt1.Y()>aLinePt2.Y()); + if (bXMirr || bYMirr) { + Point aRef1(mrSdrPathObject.GetSnapRect().Center()); + if (bXMirr) { + Point aRef2(aRef1); + aRef2.AdjustY( 1 ); + mrSdrPathObject.NbcMirrorGluePoints(aRef1,aRef2); + } + if (bYMirr) { + Point aRef2(aRef1); + aRef2.AdjustX( 1 ); + mrSdrPathObject.NbcMirrorGluePoints(aRef1,aRef2); + } + } + } + } + + mpSdrPathDragData.reset(); + + return true; +} + +OUString ImpPathForDragAndCreate::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + OUString aStr; + const SdrHdl* pHdl = rDrag.GetHdl(); + const bool bCreateComment(rDrag.GetView() && &mrSdrPathObject == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment && rDrag.GetUser()) + { + // #i103058# re-add old creation comment mode + const ImpPathCreateUser* pU = static_cast(rDrag.GetUser()); + const SdrObjKind eOriginalKind(meObjectKind); + mrSdrPathObject.meKind = pU->eCurrentKind; + aStr = mrSdrPathObject.ImpGetDescriptionStr(STR_ViewCreateObj); + mrSdrPathObject.meKind = eOriginalKind; + + Point aPrev(rDrag.GetPrev()); + Point aNow(rDrag.GetNow()); + + if(pU->bLine) + aNow = pU->aLineEnd; + + aNow -= aPrev; + aStr += " ("; + + if(pU->bCircle) + { + aStr += SdrModel::GetAngleString(abs(pU->nCircRelAngle)) + + " r=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(pU->nCircRadius, true); + } + + aStr += "dx=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(aNow.X(), true) + + " dy=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(aNow.Y(), true); + + if(!IsFreeHand(meObjectKind)) + { + sal_Int32 nLen(GetLen(aNow)); + Degree100 nAngle(GetAngle(aNow)); + aStr += " l=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(nLen, true) + + " " + + SdrModel::GetAngleString(nAngle); + } + + aStr += ")"; + } + else if(!pHdl) + { + // #i103058# fallback when no model and/or Handle, both needed + // for else-path + aStr = mrSdrPathObject.ImpGetDescriptionStr(STR_DragPathObj); + } + else + { + // #i103058# standard for modification; model and handle needed + ImpSdrPathDragData* pDragData = mpSdrPathDragData.get(); + + if(!pDragData) + { + // getSpecialDragComment is also used from create, so fallback to GetUser() + // when mpSdrPathDragData is not set + pDragData = static_cast(rDrag.GetUser()); + } + + if(!pDragData) + { + OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid."); + return OUString(); + } + + if(!pDragData->IsMultiPointDrag() && pDragData->bEliminate) + { + // point of ... + aStr = mrSdrPathObject.ImpGetDescriptionStr(STR_ViewMarkedPoint); + + // delete %O + OUString aStr2(SvxResId(STR_EditDelete)); + + // UNICODE: delete point of ... + aStr2 = aStr2.replaceFirst("%1", aStr); + + return aStr2; + } + + // dx=0.00 dy=0.00 -- both sides bezier + // dx=0.00 dy=0.00 l=0.00 0.00\302\260 -- one bezier/lever on one side, a start, or an ending + // dx=0.00 dy=0.00 l=0.00 0.00\302\260 / l=0.00 0.00\302\260 -- in between + Point aBeg(rDrag.GetStart()); + Point aNow(rDrag.GetNow()); + + aStr.clear(); + aStr += "dx=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(aNow.X() - aBeg.X(), true) + + " dy=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(aNow.Y() - aBeg.Y(), true); + + if(!pDragData->IsMultiPointDrag()) + { + sal_uInt16 nPntNum(static_cast(pHdl->GetPointNum())); + const XPolygon& rXPoly = aPathPolygon[static_cast(rDrag.GetHdl()->GetPolyNum())]; + sal_uInt16 nPointCount(rXPoly.GetPointCount()); + bool bClose(IsClosed(meObjectKind)); + + if(bClose) + nPointCount--; + + if(pHdl->IsPlusHdl()) + { + // lever + sal_uInt16 nRef(nPntNum); + + if(rXPoly.IsControl(nPntNum + 1)) + nRef--; + else + nRef++; + + aNow -= rXPoly[nRef]; + + sal_Int32 nLen(GetLen(aNow)); + Degree100 nAngle(GetAngle(aNow)); + aStr += " l=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(nLen, true) + + " " + + SdrModel::GetAngleString(nAngle); + } + else if(nPointCount > 1) + { + sal_uInt16 nPntMax(nPointCount - 1); + bool bIsClosed(IsClosed(meObjectKind)); + bool bPt1(nPntNum > 0); + bool bPt2(nPntNum < nPntMax); + + if(bIsClosed && nPointCount > 2) + { + bPt1 = true; + bPt2 = true; + } + + sal_uInt16 nPt1,nPt2; + + if(nPntNum > 0) + nPt1 = nPntNum - 1; + else + nPt1 = nPntMax; + + if(nPntNum < nPntMax) + nPt2 = nPntNum + 1; + else + nPt2 = 0; + + if(bPt1 && rXPoly.IsControl(nPt1)) + bPt1 = false; // don't display + + if(bPt2 && rXPoly.IsControl(nPt2)) + bPt2 = false; // of bezier data + + if(bPt1) + { + Point aPt(aNow); + aPt -= rXPoly[nPt1]; + + sal_Int32 nLen(GetLen(aPt)); + Degree100 nAngle(GetAngle(aPt)); + aStr += " l=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(nLen, true) + + " " + + SdrModel::GetAngleString(nAngle); + } + + if(bPt2) + { + if(bPt1) + aStr += " / "; + else + aStr += " "; + + Point aPt(aNow); + aPt -= rXPoly[nPt2]; + + sal_Int32 nLen(GetLen(aPt)); + Degree100 nAngle(GetAngle(aPt)); + aStr += "l=" + + mrSdrPathObject.getSdrModelFromSdrObject().GetMetricString(nLen, true) + + " " + + SdrModel::GetAngleString(nAngle); + } + } + } + } + + return aStr; +} + +basegfx::B2DPolyPolygon ImpPathForDragAndCreate::getSpecialDragPoly(const SdrDragStat& rDrag) const +{ + if(!mpSdrPathDragData || !mpSdrPathDragData->bValid) + { + OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid."); + return basegfx::B2DPolyPolygon(); + } + + XPolyPolygon aRetval; + + if(mpSdrPathDragData->IsMultiPointDrag()) + { + aRetval.Insert(mpSdrPathDragData->maMove); + } + else + { + const XPolygon& rXP=aPathPolygon[static_cast(rDrag.GetHdl()->GetPolyNum())]; + if (rXP.GetPointCount()<=2) { + XPolygon aXPoly(rXP); + aXPoly[static_cast(rDrag.GetHdl()->GetPointNum())]=rDrag.GetNow(); + aRetval.Insert(std::move(aXPoly)); + return aRetval.getB2DPolyPolygon(); + } + // copy certain data locally to use less code and have faster access times + bool bClosed =mpSdrPathDragData->bClosed ; // closed object? + sal_uInt16 nPointCount = mpSdrPathDragData->nPointCount; // number of points + sal_uInt16 nPnt =mpSdrPathDragData->nPnt ; // number of points in the polygon + bool bBegPnt =mpSdrPathDragData->bBegPnt ; // dragged point is the first point of a Polyline + bool bEndPnt =mpSdrPathDragData->bEndPnt ; // dragged point is the last point of a Polyline + sal_uInt16 nPrevPnt =mpSdrPathDragData->nPrevPnt ; // index of the previous point + sal_uInt16 nNextPnt =mpSdrPathDragData->nNextPnt ; // index of the next point + bool bPrevIsBegPnt =mpSdrPathDragData->bPrevIsBegPnt ; // previous point is first point of a Polyline + bool bNextIsEndPnt =mpSdrPathDragData->bNextIsEndPnt ; // next point is last point of a Polyline + sal_uInt16 nPrevPrevPnt =mpSdrPathDragData->nPrevPrevPnt ; // index of the point before the previous point + sal_uInt16 nNextNextPnt =mpSdrPathDragData->nNextNextPnt ; // index of the point after the last point + bool bControl =mpSdrPathDragData->bControl ; // point is a control point + bool bIsNextControl =mpSdrPathDragData->bIsNextControl; //point is a control point after a support point + bool bPrevIsControl =mpSdrPathDragData->bPrevIsControl; // if nPnt is a support point: there's a control point before + bool bNextIsControl =mpSdrPathDragData->bNextIsControl; // if nPnt is a support point: there's a control point after + XPolygon aXPoly(mpSdrPathDragData->aXP); + XPolygon aLine1(2); + XPolygon aLine2(2); + XPolygon aLine3(2); + XPolygon aLine4(2); + if (bControl) { + aLine1[1]=mpSdrPathDragData->aXP[nPnt]; + if (bIsNextControl) { // is this a control point after the support point? + aLine1[0]=mpSdrPathDragData->aXP[nPrevPnt]; + aLine2[0]=mpSdrPathDragData->aXP[nNextNextPnt]; + aLine2[1]=mpSdrPathDragData->aXP[nNextPnt]; + if (mpSdrPathDragData->aXP.IsSmooth(nPrevPnt) && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) { + aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Control); + aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],PolyFlags::Normal); + // leverage lines for the opposing curve segment + aLine3[0]=mpSdrPathDragData->aXP[nPrevPnt]; + aLine3[1]=mpSdrPathDragData->aXP[nPrevPrevPnt]; + aLine4[0]=rXP[mpSdrPathDragData->nPrevPrevPnt0-2]; + aLine4[1]=rXP[mpSdrPathDragData->nPrevPrevPnt0-1]; + } else { + aXPoly.Remove(0,1); + } + } else { // else this is a control point before a support point + aLine1[0]=mpSdrPathDragData->aXP[nNextPnt]; + aLine2[0]=mpSdrPathDragData->aXP[nPrevPrevPnt]; + aLine2[1]=mpSdrPathDragData->aXP[nPrevPnt]; + if (mpSdrPathDragData->aXP.IsSmooth(nNextPnt) && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) { + aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Control); + aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],PolyFlags::Normal); + // leverage lines for the opposing curve segment + aLine3[0]=mpSdrPathDragData->aXP[nNextPnt]; + aLine3[1]=mpSdrPathDragData->aXP[nNextNextPnt]; + aLine4[0]=rXP[mpSdrPathDragData->nNextNextPnt0+2]; + aLine4[1]=rXP[mpSdrPathDragData->nNextNextPnt0+1]; + } else { + aXPoly.Remove(aXPoly.GetPointCount()-1,1); + } + } + } else { // else is not a control point + if (mpSdrPathDragData->bEliminate) { + aXPoly.Remove(2,1); + } + if (bPrevIsControl) aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Normal); + else if (!bBegPnt && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) { + aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-1],PolyFlags::Control); + aXPoly.Insert(0,rXP[mpSdrPathDragData->nPrevPrevPnt0-2],PolyFlags::Normal); + } else { + aXPoly.Remove(0,1); + if (bBegPnt) aXPoly.Remove(0,1); + } + if (bNextIsControl) aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Normal); + else if (!bEndPnt && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) { + aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+1],PolyFlags::Control); + aXPoly.Insert(XPOLY_APPEND,rXP[mpSdrPathDragData->nNextNextPnt0+2],PolyFlags::Normal); + } else { + aXPoly.Remove(aXPoly.GetPointCount()-1,1); + if (bEndPnt) aXPoly.Remove(aXPoly.GetPointCount()-1,1); + } + if (bClosed) { // "pear problem": 2 lines, 1 curve, everything smoothed, a point between both lines is dragged + if (aXPoly.GetPointCount()>nPointCount && aXPoly.IsControl(1)) { + sal_uInt16 a=aXPoly.GetPointCount(); + aXPoly[a-2]=aXPoly[2]; aXPoly.SetFlags(a-2,aXPoly.GetFlags(2)); + aXPoly[a-1]=aXPoly[3]; aXPoly.SetFlags(a-1,aXPoly.GetFlags(3)); + aXPoly.Remove(0,3); + } + } + } + aRetval.Insert(std::move(aXPoly)); + if (aLine1.GetPointCount()>1) aRetval.Insert(std::move(aLine1)); + if (aLine2.GetPointCount()>1) aRetval.Insert(std::move(aLine2)); + if (aLine3.GetPointCount()>1) aRetval.Insert(std::move(aLine3)); + if (aLine4.GetPointCount()>1) aRetval.Insert(std::move(aLine4)); + } + + return aRetval.getB2DPolyPolygon(); +} + +void ImpPathForDragAndCreate::BegCreate(SdrDragStat& rStat) +{ + bool bFreeHand(IsFreeHand(meObjectKind)); + rStat.SetNoSnap(bFreeHand); + rStat.SetOrtho8Possible(); + aPathPolygon.Clear(); + mbCreating=true; + bool bMakeStartPoint = true; + SdrView* pView=rStat.GetView(); + if (pView!=nullptr && pView->IsUseIncompatiblePathCreateInterface() && + (meObjectKind==SdrObjKind::Polygon || meObjectKind==SdrObjKind::PolyLine || meObjectKind==SdrObjKind::PathLine || meObjectKind==SdrObjKind::PathFill)) { + bMakeStartPoint = false; + } + aPathPolygon.Insert(XPolygon()); + aPathPolygon[0][0]=rStat.GetStart(); + if (bMakeStartPoint) { + aPathPolygon[0][1]=rStat.GetNow(); + } + std::unique_ptr pU(new ImpPathCreateUser); + pU->eStartKind=meObjectKind; + pU->eCurrentKind=meObjectKind; + rStat.SetUser(std::move(pU)); +} + +bool ImpPathForDragAndCreate::MovCreate(SdrDragStat& rStat) +{ + ImpPathCreateUser* pU=static_cast(rStat.GetUser()); + SdrView* pView=rStat.GetView(); + XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1]; + if (pView!=nullptr && pView->IsCreateMode()) { + // switch to different CreateTool, if appropriate + SdrObjKind nIdent; + SdrInventor nInvent; + pView->TakeCurrentObj(nIdent,nInvent); + if (nInvent==SdrInventor::Default && pU->eCurrentKind != nIdent) { + SdrObjKind eNewKind = nIdent; + switch (eNewKind) { + case SdrObjKind::CircleArc: + case SdrObjKind::CircleOrEllipse: + case SdrObjKind::CircleCut: + case SdrObjKind::CircleSection: + eNewKind=SdrObjKind::CircleArc; + [[fallthrough]]; + case SdrObjKind::Rectangle: + case SdrObjKind::Line: + case SdrObjKind::PolyLine: + case SdrObjKind::Polygon: + case SdrObjKind::PathLine: + case SdrObjKind::PathFill: + case SdrObjKind::FreehandLine: + case SdrObjKind::FreehandFill: + { + pU->eCurrentKind=eNewKind; + pU->bMixedCreate=true; + pU->nBezierStartPoint=rXPoly.GetPointCount(); + if (pU->nBezierStartPoint>0) pU->nBezierStartPoint--; + } break; + default: break; + } // switch + } + } + sal_uInt16 nCurrentPoint=rXPoly.GetPointCount(); + if (aPathPolygon.Count()>1 && rStat.IsMouseDown() && nCurrentPoint<2) { + rXPoly[0]=rStat.GetPos0(); + rXPoly[1]=rStat.GetNow(); + nCurrentPoint=2; + } + if (nCurrentPoint==0) { + rXPoly[0]=rStat.GetPos0(); + } else nCurrentPoint--; + bool bFreeHand=IsFreeHand(pU->eCurrentKind); + rStat.SetNoSnap(bFreeHand); + rStat.SetOrtho8Possible(pU->eCurrentKind!=SdrObjKind::CircleArc && pU->eCurrentKind!=SdrObjKind::Rectangle && (!pU->bMixedCreate || pU->eCurrentKind!=SdrObjKind::Line)); + rXPoly[nCurrentPoint]=rStat.GetNow(); + if (!pU->bMixedCreate && pU->eStartKind==SdrObjKind::Line && rXPoly.GetPointCount()>=1) { + Point aPt(rStat.GetStart()); + if (pView!=nullptr && pView->IsCreate1stPointAsCenter()) { + aPt+=aPt; + aPt-=rStat.GetNow(); + } + rXPoly[0]=aPt; + } + OutputDevice* pOut=pView==nullptr ? nullptr : pView->GetFirstOutputDevice(); + if (bFreeHand) { + if (pU->nBezierStartPoint>nCurrentPoint) pU->nBezierStartPoint=nCurrentPoint; + if (rStat.IsMouseDown() && nCurrentPoint>0) { + // don't allow two consecutive points to occupy too similar positions + tools::Long nMinDist=1; + if (pView!=nullptr) nMinDist=pView->GetFreeHandMinDistPix(); + if (pOut!=nullptr) nMinDist=pOut->PixelToLogic(Size(nMinDist,0)).Width(); + if (nMinDist<1) nMinDist=1; + + Point aPt0(rXPoly[nCurrentPoint-1]); + Point aPt1(rStat.GetNow()); + tools::Long dx=aPt0.X()-aPt1.X(); if (dx<0) dx=-dx; + tools::Long dy=aPt0.Y()-aPt1.Y(); if (dy<0) dy=-dy; + if (dxnBezierStartPoint>=3 && ((nCurrentPoint-pU->nBezierStartPoint)%3)==0) { + rXPoly.PointsToBezier(nCurrentPoint-3); + rXPoly.SetFlags(nCurrentPoint-1,PolyFlags::Control); + rXPoly.SetFlags(nCurrentPoint-2,PolyFlags::Control); + + if (nCurrentPoint>=6 && rXPoly.IsControl(nCurrentPoint-4)) { + rXPoly.CalcTangent(nCurrentPoint-3,nCurrentPoint-4,nCurrentPoint-2); + rXPoly.SetFlags(nCurrentPoint-3,PolyFlags::Smooth); + } + } + rXPoly[nCurrentPoint+1]=rStat.GetNow(); + rStat.NextPoint(); + } else { + pU->nBezierStartPoint=nCurrentPoint; + } + } + + pU->ResetFormFlags(); + if (IsBezier(pU->eCurrentKind)) { + if (nCurrentPoint>=2) { + pU->CalcBezier(rXPoly[nCurrentPoint-1],rXPoly[nCurrentPoint],rXPoly[nCurrentPoint-1]-rXPoly[nCurrentPoint-2],rStat.IsMouseDown()); + } else if (pU->bBezHasCtrl0) { + pU->CalcBezier(rXPoly[nCurrentPoint-1],rXPoly[nCurrentPoint],pU->aBezControl0-rXPoly[nCurrentPoint-1],rStat.IsMouseDown()); + } + } + if (pU->eCurrentKind==SdrObjKind::CircleArc && nCurrentPoint>=2) { + pU->CalcCircle(rXPoly[nCurrentPoint-1],rXPoly[nCurrentPoint],rXPoly[nCurrentPoint-1]-rXPoly[nCurrentPoint-2],pView); + } + if (pU->eCurrentKind==SdrObjKind::Line && nCurrentPoint>=2) { + pU->CalcLine(rXPoly[nCurrentPoint-1],rXPoly[nCurrentPoint],rXPoly[nCurrentPoint-1]-rXPoly[nCurrentPoint-2],pView); + } + if (pU->eCurrentKind==SdrObjKind::Rectangle && nCurrentPoint>=2) { + pU->CalcRect(rXPoly[nCurrentPoint-1],rXPoly[nCurrentPoint],rXPoly[nCurrentPoint-1]-rXPoly[nCurrentPoint-2],pView); + } + + return true; +} + +bool ImpPathForDragAndCreate::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + ImpPathCreateUser* pU=static_cast(rStat.GetUser()); + bool bRet = false; + SdrView* pView=rStat.GetView(); + bool bIncomp=pView!=nullptr && pView->IsUseIncompatiblePathCreateInterface(); + XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1]; + sal_uInt16 nCurrentPoint=rXPoly.GetPointCount()-1; + rXPoly[nCurrentPoint]=rStat.GetNow(); + if (!pU->bMixedCreate && pU->eStartKind==SdrObjKind::Line) { + if (rStat.GetPointCount()>=2) eCmd=SdrCreateCmd::ForceEnd; + bRet = eCmd==SdrCreateCmd::ForceEnd; + if (bRet) { + mbCreating = false; + rStat.SetUser(nullptr); + } + return bRet; + } + + if (!pU->bMixedCreate && IsFreeHand(pU->eStartKind)) { + if (rStat.GetPointCount()>=2) eCmd=SdrCreateCmd::ForceEnd; + bRet=eCmd==SdrCreateCmd::ForceEnd; + if (bRet) { + mbCreating=false; + rStat.SetUser(nullptr); + } + return bRet; + } + if (eCmd==SdrCreateCmd::NextPoint || eCmd==SdrCreateCmd::NextObject) { + // don't allow two consecutive points to occupy the same position + if (nCurrentPoint==0 || rStat.GetNow()!=rXPoly[nCurrentPoint-1]) { + if (bIncomp) { + if (pU->nBezierStartPoint>nCurrentPoint) pU->nBezierStartPoint=nCurrentPoint; + if (IsBezier(pU->eCurrentKind) && nCurrentPoint-pU->nBezierStartPoint>=3 && ((nCurrentPoint-pU->nBezierStartPoint)%3)==0) { + rXPoly.PointsToBezier(nCurrentPoint-3); + rXPoly.SetFlags(nCurrentPoint-1,PolyFlags::Control); + rXPoly.SetFlags(nCurrentPoint-2,PolyFlags::Control); + + if (nCurrentPoint>=6 && rXPoly.IsControl(nCurrentPoint-4)) { + rXPoly.CalcTangent(nCurrentPoint-3,nCurrentPoint-4,nCurrentPoint-2); + rXPoly.SetFlags(nCurrentPoint-3,PolyFlags::Smooth); + } + } + } else { + if (nCurrentPoint==1 && IsBezier(pU->eCurrentKind) && !pU->bBezHasCtrl0) { + pU->aBezControl0=rStat.GetNow(); + pU->bBezHasCtrl0=true; + nCurrentPoint--; + } + if (pU->IsFormFlag()) { + sal_uInt16 nPointCount0=rXPoly.GetPointCount(); + rXPoly.Remove(nCurrentPoint-1,2); // remove last two points and replace by form + rXPoly.Insert(XPOLY_APPEND,pU->GetFormPoly()); + sal_uInt16 nPointCount1=rXPoly.GetPointCount(); + for (sal_uInt16 i=nPointCount0+1; i=2) { + pU->bBezHasCtrl0=false; + // only a singular polygon may be opened, so close this + rXPoly[nCurrentPoint]=rXPoly[0]; + XPolygon aXP; + aXP[0]=rStat.GetNow(); + aPathPolygon.Insert(std::move(aXP)); + } + } + } + + sal_uInt16 nPolyCount=aPathPolygon.Count(); + if (nPolyCount!=0) { + // delete last point, if necessary + if (eCmd==SdrCreateCmd::ForceEnd) { + XPolygon& rXP=aPathPolygon[nPolyCount-1]; + sal_uInt16 nPointCount=rXP.GetPointCount(); + if (nPointCount>=2) { + if (!rXP.IsControl(nPointCount-2)) { + if (rXP[nPointCount-1]==rXP[nPointCount-2]) { + rXP.Remove(nPointCount-1,1); + } + } else { + if (rXP[nPointCount-3]==rXP[nPointCount-2]) { + rXP.Remove(nPointCount-3,3); + } + } + } + } + for (sal_uInt16 nPolyNum=nPolyCount; nPolyNum>0;) { + nPolyNum--; + XPolygon& rXP=aPathPolygon[nPolyNum]; + sal_uInt16 nPointCount=rXP.GetPointCount(); + // delete polygons with too few points + if (nPolyNumResetFormFlags(); + bRet=eCmd==SdrCreateCmd::ForceEnd; + if (bRet) { + mbCreating=false; + rStat.SetUser(nullptr); + } + return bRet; +} + +bool ImpPathForDragAndCreate::BckCreate(SdrDragStat const & rStat) +{ + ImpPathCreateUser* pU=static_cast(rStat.GetUser()); + if (aPathPolygon.Count()>0) { + XPolygon& rXPoly=aPathPolygon[aPathPolygon.Count()-1]; + sal_uInt16 nCurrentPoint=rXPoly.GetPointCount(); + if (nCurrentPoint>0) { + nCurrentPoint--; + // make the last part of a bezier curve a line + rXPoly.Remove(nCurrentPoint,1); + if (nCurrentPoint>=3 && rXPoly.IsControl(nCurrentPoint-1)) { + // there should never be a bezier segment at the end, so this is just in case... + rXPoly.Remove(nCurrentPoint-1,1); + if (rXPoly.IsControl(nCurrentPoint-2)) rXPoly.Remove(nCurrentPoint-2,1); + } + } + nCurrentPoint=rXPoly.GetPointCount(); + if (nCurrentPoint>=4) { // no bezier segment at the end + nCurrentPoint--; + if (rXPoly.IsControl(nCurrentPoint-1)) { + rXPoly.Remove(nCurrentPoint-1,1); + if (rXPoly.IsControl(nCurrentPoint-2)) rXPoly.Remove(nCurrentPoint-2,1); + } + } + if (rXPoly.GetPointCount()<2) { + aPathPolygon.Remove(aPathPolygon.Count()-1); + } + if (aPathPolygon.Count()>0) { + XPolygon& rLocalXPoly=aPathPolygon[aPathPolygon.Count()-1]; + sal_uInt16 nLocalCurrentPoint=rLocalXPoly.GetPointCount(); + if (nLocalCurrentPoint>0) { + nLocalCurrentPoint--; + rLocalXPoly[nLocalCurrentPoint]=rStat.GetNow(); + } + } + } + pU->ResetFormFlags(); + return aPathPolygon.Count()!=0; +} + +void ImpPathForDragAndCreate::BrkCreate(SdrDragStat& rStat) +{ + aPathPolygon.Clear(); + mbCreating=false; + rStat.SetUser(nullptr); +} + +basegfx::B2DPolyPolygon ImpPathForDragAndCreate::TakeObjectPolyPolygon(const SdrDragStat& rDrag) const +{ + basegfx::B2DPolyPolygon aRetval(aPathPolygon.getB2DPolyPolygon()); + SdrView* pView = rDrag.GetView(); + + if(pView && pView->IsUseIncompatiblePathCreateInterface()) + return aRetval; + + ImpPathCreateUser* pU = static_cast(rDrag.GetUser()); + basegfx::B2DPolygon aNewPolygon(aRetval.count() ? aRetval.getB2DPolygon(aRetval.count() - 1) : basegfx::B2DPolygon()); + + if(pU->IsFormFlag() && aNewPolygon.count() > 1) + { + // remove last segment and replace with current + // do not forget to rescue the previous control point which will be lost when + // the point it's associated with is removed + const sal_uInt32 nChangeIndex(aNewPolygon.count() - 2); + const basegfx::B2DPoint aSavedPrevCtrlPoint(aNewPolygon.getPrevControlPoint(nChangeIndex)); + + aNewPolygon.remove(nChangeIndex, 2); + aNewPolygon.append(pU->GetFormPoly().getB2DPolygon()); + + if(nChangeIndex < aNewPolygon.count()) + { + // if really something was added, set the saved previous control point to the + // point where it belongs + aNewPolygon.setPrevControlPoint(nChangeIndex, aSavedPrevCtrlPoint); + } + } + + if(aRetval.count()) + { + aRetval.setB2DPolygon(aRetval.count() - 1, aNewPolygon); + } + else + { + aRetval.append(aNewPolygon); + } + + return aRetval; +} + +basegfx::B2DPolyPolygon ImpPathForDragAndCreate::TakeDragPolyPolygon(const SdrDragStat& rDrag) +{ + basegfx::B2DPolyPolygon aRetval; + SdrView* pView = rDrag.GetView(); + + if(pView && pView->IsUseIncompatiblePathCreateInterface()) + return aRetval; + + const ImpPathCreateUser* pU = static_cast(rDrag.GetUser()); + + if(pU && pU->bBezier && rDrag.IsMouseDown()) + { + // no more XOR, no need for complicated helplines + basegfx::B2DPolygon aHelpline; + aHelpline.append(basegfx::B2DPoint(pU->aBezCtrl2.X(), pU->aBezCtrl2.Y())); + aHelpline.append(basegfx::B2DPoint(pU->aBezEnd.X(), pU->aBezEnd.Y())); + aRetval.append(aHelpline); + } + + return aRetval; +} + +PointerStyle ImpPathForDragAndCreate::GetCreatePointer() const +{ + switch (meObjectKind) { + case SdrObjKind::Line : return PointerStyle::DrawLine; + case SdrObjKind::Polygon : return PointerStyle::DrawPolygon; + case SdrObjKind::PolyLine : return PointerStyle::DrawPolygon; + case SdrObjKind::PathLine: return PointerStyle::DrawBezier; + case SdrObjKind::PathFill: return PointerStyle::DrawBezier; + case SdrObjKind::FreehandLine: return PointerStyle::DrawFreehand; + case SdrObjKind::FreehandFill: return PointerStyle::DrawFreehand; + case SdrObjKind::PathPoly: return PointerStyle::DrawPolygon; + case SdrObjKind::PathPolyLine: return PointerStyle::DrawPolygon; + default: break; + } // switch + return PointerStyle::Cross; +} + +SdrPathObjGeoData::SdrPathObjGeoData() + : meKind(SdrObjKind::NONE) +{ +} + +SdrPathObjGeoData::~SdrPathObjGeoData() +{ +} + +// DrawContact section + +std::unique_ptr SdrPathObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +SdrPathObj::SdrPathObj( + SdrModel& rSdrModel, + SdrObjKind eNewKind) +: SdrTextObj(rSdrModel), + meKind(eNewKind) +{ + m_bClosedObj = IsClosed(); +} + +SdrPathObj::SdrPathObj(SdrModel& rSdrModel, SdrPathObj const & rSource) +: SdrTextObj(rSdrModel, rSource), + meKind(rSource.meKind) +{ + m_bClosedObj = IsClosed(); + maPathPolygon = rSource.GetPathPoly(); +} + +SdrPathObj::SdrPathObj( + SdrModel& rSdrModel, + SdrObjKind eNewKind, + basegfx::B2DPolyPolygon aPathPoly) +: SdrTextObj(rSdrModel), + maPathPolygon(std::move(aPathPoly)), + meKind(eNewKind) +{ + m_bClosedObj = IsClosed(); + ImpForceKind(); +} + +SdrPathObj::~SdrPathObj() = default; + +static bool lcl_ImpIsLine(const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + return (1 == rPolyPolygon.count() && 2 == rPolyPolygon.getB2DPolygon(0).count()); +} + +static tools::Rectangle lcl_ImpGetBoundRect(const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + basegfx::B2DRange aRange(basegfx::utils::getRange(rPolyPolygon)); + + if (aRange.isEmpty()) + return tools::Rectangle(); + + return tools::Rectangle( + FRound(aRange.getMinX()), FRound(aRange.getMinY()), + FRound(aRange.getMaxX()), FRound(aRange.getMaxY())); +} + +void SdrPathObj::ImpForceLineAngle() +{ + if(SdrObjKind::Line != meKind || !lcl_ImpIsLine(GetPathPoly())) + return; + + const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(0)); + const basegfx::B2DPoint aB2DPoint0(aPoly.getB2DPoint(0)); + const basegfx::B2DPoint aB2DPoint1(aPoly.getB2DPoint(1)); + const Point aPoint0(FRound(aB2DPoint0.getX()), FRound(aB2DPoint0.getY())); + const Point aPoint1(FRound(aB2DPoint1.getX()), FRound(aB2DPoint1.getY())); + const basegfx::B2DPoint aB2DDelt(aB2DPoint1 - aB2DPoint0); + const Point aDelt(FRound(aB2DDelt.getX()), FRound(aB2DDelt.getY())); + + maGeo.m_nRotationAngle=GetAngle(aDelt); + maGeo.m_nShearAngle=0_deg100; + maGeo.RecalcSinCos(); + maGeo.RecalcTan(); + + // for SdrTextObj, keep aRect up to date + setRectangle(tools::Rectangle::Normalize(aPoint0, aPoint1)); +} + +void SdrPathObj::ImpForceKind() +{ + if (meKind==SdrObjKind::PathPolyLine) meKind=SdrObjKind::PolyLine; + if (meKind==SdrObjKind::PathPoly) meKind=SdrObjKind::Polygon; + + if(GetPathPoly().areControlPointsUsed()) + { + switch (meKind) + { + case SdrObjKind::Line: meKind=SdrObjKind::PathLine; break; + case SdrObjKind::PolyLine: meKind=SdrObjKind::PathLine; break; + case SdrObjKind::Polygon: meKind=SdrObjKind::PathFill; break; + default: break; + } + } + else + { + switch (meKind) + { + case SdrObjKind::PathLine: meKind=SdrObjKind::PolyLine; break; + case SdrObjKind::FreehandLine: meKind=SdrObjKind::PolyLine; break; + case SdrObjKind::PathFill: meKind=SdrObjKind::Polygon; break; + case SdrObjKind::FreehandFill: meKind=SdrObjKind::Polygon; break; + default: break; + } + } + + if (meKind==SdrObjKind::Line && !lcl_ImpIsLine(GetPathPoly())) meKind=SdrObjKind::PolyLine; + if (meKind==SdrObjKind::PolyLine && lcl_ImpIsLine(GetPathPoly())) meKind=SdrObjKind::Line; + + m_bClosedObj=IsClosed(); + + if (meKind==SdrObjKind::Line) + { + ImpForceLineAngle(); + } + else + { + // #i10659#, for polys with more than 2 points. + + // Here i again need to fix something, because when Path-Polys are Copy-Pasted + // between Apps with different measurements (e.g. 100TH_MM and TWIPS) there is + // a scaling loop started from SdrExchangeView::Paste. In itself, this is not + // wrong, but aRect is wrong here and not even updated by RecalcSnapRect(). If + // this is the case, some size needs to be set here in aRect to avoid that the cycle + // through Rect2Poly - Poly2Rect does something badly wrong since that cycle is + // BASED on aRect. That cycle is triggered in SdrTextObj::NbcResize() which is called + // from the local Resize() implementation. + + // Basic problem is that the member aRect in SdrTextObj basically is a unrotated + // text rectangle for the text object itself and methods at SdrTextObj do handle it + // in that way. Many draw objects derived from SdrTextObj 'abuse' aRect as SnapRect + // which is basically wrong. To make the SdrText methods which deal with aRect directly + // work it is necessary to always keep aRect updated. This e.g. not done after a Clone() + // command for SdrPathObj. Since adding this update mechanism with #101412# to + // ImpForceLineAngle() for lines was very successful, i add it to where ImpForceLineAngle() + // was called, once here below and once on a 2nd place below. + + // #i10659# for SdrTextObj, keep aRect up to date + if(GetPathPoly().count()) + { + setRectangle(lcl_ImpGetBoundRect(GetPathPoly())); + } + } + + // #i75974# adapt polygon state to object type. This may include a reinterpretation + // of a closed geometry as open one, but with identical first and last point + for(auto& rPolygon : maPathPolygon) + { + if(IsClosed() != rPolygon.isClosed()) + { + // #i80213# really change polygon geometry; else e.g. the last point which + // needs to be identical with the first one will be missing when opening + // due to OBJ_PATH type + if(rPolygon.isClosed()) + { + basegfx::utils::openWithGeometryChange(rPolygon); + } + else + { + basegfx::utils::closeWithGeometryChange(rPolygon); + } + } + } +} + +void SdrPathObj::ImpSetClosed(bool bClose) +{ + if(bClose) + { + switch (meKind) + { + case SdrObjKind::Line : meKind=SdrObjKind::Polygon; break; + case SdrObjKind::PolyLine : meKind=SdrObjKind::Polygon; break; + case SdrObjKind::PathLine: meKind=SdrObjKind::PathFill; break; + case SdrObjKind::FreehandLine: meKind=SdrObjKind::FreehandFill; break; + default: break; + } + + m_bClosedObj = true; + } + else + { + switch (meKind) + { + case SdrObjKind::Polygon : meKind=SdrObjKind::PolyLine; break; + case SdrObjKind::PathFill: meKind=SdrObjKind::PathLine; break; + case SdrObjKind::FreehandFill: meKind=SdrObjKind::FreehandLine; break; + default: break; + } + + m_bClosedObj = false; + } + + ImpForceKind(); +} + +void SdrPathObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bNoContortion=false; + + bool bCanConv = !HasText() || ImpCanConvTextToCurve(); + bool bIsPath = IsBezier(); + + rInfo.bEdgeRadiusAllowed = false; + rInfo.bCanConvToPath = bCanConv && !bIsPath; + rInfo.bCanConvToPoly = bCanConv && bIsPath; + rInfo.bCanConvToContour = !IsFontwork() && (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrPathObj::GetObjIdentifier() const +{ + return meKind; +} + +rtl::Reference SdrPathObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrPathObj(rTargetModel, *this); +} + +OUString SdrPathObj::TakeObjNameSingul() const +{ + OUString sName; + + if(SdrObjKind::Line == meKind) + { + TranslateId pId(STR_ObjNameSingulLINE); + + if(lcl_ImpIsLine(GetPathPoly())) + { + const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(0)); + const basegfx::B2DPoint aB2DPoint0(aPoly.getB2DPoint(0)); + const basegfx::B2DPoint aB2DPoint1(aPoly.getB2DPoint(1)); + + if(aB2DPoint0 != aB2DPoint1) + { + if(aB2DPoint0.getY() == aB2DPoint1.getY()) + { + pId = STR_ObjNameSingulLINE_Hori; + } + else if(aB2DPoint0.getX() == aB2DPoint1.getX()) + { + pId = STR_ObjNameSingulLINE_Vert; + } + else + { + const double fDx(fabs(aB2DPoint0.getX() - aB2DPoint1.getX())); + const double fDy(fabs(aB2DPoint0.getY() - aB2DPoint1.getY())); + + if(fDx == fDy) + { + pId = STR_ObjNameSingulLINE_Diag; + } + } + } + } + + sName = SvxResId(pId); + } + else if(SdrObjKind::PolyLine == meKind || SdrObjKind::Polygon == meKind) + { + const bool bClosed(SdrObjKind::Polygon == meKind); + TranslateId pId; + + if(mpDAC && mpDAC->IsCreating()) + { + if(bClosed) + { + pId = STR_ObjNameSingulPOLY; + } + else + { + pId = STR_ObjNameSingulPLIN; + } + + sName = SvxResId(pId); + } + else + { + // get point count + sal_uInt32 nPointCount(0); + + for(auto const& rPolygon : GetPathPoly()) + { + nPointCount += rPolygon.count(); + } + + if(bClosed) + { + pId = STR_ObjNameSingulPOLY_PointCount; + } + else + { + pId = STR_ObjNameSingulPLIN_PointCount; + } + + // #i96537# + sName = SvxResId(pId).replaceFirst("%2", OUString::number(nPointCount)); + } + } + else + { + switch (meKind) + { + case SdrObjKind::PathLine: sName = SvxResId(STR_ObjNameSingulPATHLINE); break; + case SdrObjKind::FreehandLine: sName = SvxResId(STR_ObjNameSingulFREELINE); break; + case SdrObjKind::PathFill: sName = SvxResId(STR_ObjNameSingulPATHFILL); break; + case SdrObjKind::FreehandFill: sName = SvxResId(STR_ObjNameSingulFREEFILL); break; + default: break; + } + } + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrPathObj::TakeObjNamePlural() const +{ + OUString sName; + switch(meKind) + { + case SdrObjKind::Line : sName=SvxResId(STR_ObjNamePluralLINE ); break; + case SdrObjKind::PolyLine : sName=SvxResId(STR_ObjNamePluralPLIN ); break; + case SdrObjKind::Polygon : sName=SvxResId(STR_ObjNamePluralPOLY ); break; + case SdrObjKind::PathLine: sName=SvxResId(STR_ObjNamePluralPATHLINE); break; + case SdrObjKind::FreehandLine: sName=SvxResId(STR_ObjNamePluralFREELINE); break; + case SdrObjKind::PathFill: sName=SvxResId(STR_ObjNamePluralPATHFILL); break; + case SdrObjKind::FreehandFill: sName=SvxResId(STR_ObjNamePluralFREEFILL); break; + default: break; + } + return sName; +} + +basegfx::B2DPolyPolygon SdrPathObj::TakeXorPoly() const +{ + return GetPathPoly(); +} + +sal_uInt32 SdrPathObj::GetHdlCount() const +{ + sal_uInt32 nRetval(0); + + for(auto const& rPolygon : GetPathPoly()) + { + nRetval += rPolygon.count(); + } + + return nRetval; +} + +void SdrPathObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + // keep old stuff to be able to keep old SdrHdl stuff, too + const XPolyPolygon aOldPathPolygon(GetPathPoly()); + sal_uInt16 nPolyCnt=aOldPathPolygon.Count(); + bool bClosed=IsClosed(); + sal_uInt16 nIdx=0; + + for (sal_uInt16 i=0; i1) nPntCnt--; + + for (sal_uInt16 j=0; j pHdl(new SdrHdl(rPnt,SdrHdlKind::Poly)); + pHdl->SetPolyNum(i); + pHdl->SetPointNum(j); + pHdl->Set1PixMore(j==0); + pHdl->SetSourceHdlNum(nIdx); + nIdx++; + rHdlList.AddHdl(std::move(pHdl)); + } + } + } +} + +void SdrPathObj::AddToPlusHdlList(SdrHdlList& rHdlList, SdrHdl& rHdl) const +{ + // keep old stuff to be able to keep old SdrHdl stuff, too + const XPolyPolygon aOldPathPolygon(GetPathPoly()); + sal_uInt16 nPnt = static_cast(rHdl.GetPointNum()); + sal_uInt16 nPolyNum = static_cast(rHdl.GetPolyNum()); + + if (nPolyNum>=aOldPathPolygon.Count()) + return; + + const XPolygon& rXPoly = aOldPathPolygon[nPolyNum]; + sal_uInt16 nPntMax = rXPoly.GetPointCount(); + + if (nPntMax<=0) + return; + nPntMax--; + if (nPnt>nPntMax) + return; + + // calculate the number of plus points + sal_uInt16 nCnt = 0; + if (rXPoly.GetFlags(nPnt)!=PolyFlags::Control) + { + if (nPnt==0 && IsClosed()) + nPnt=nPntMax; + if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==PolyFlags::Control) + nCnt++; + if (nPnt==nPntMax && IsClosed()) + nPnt=0; + if (nPnt(rHdl.GetPointNum()); + std::unique_ptr pHdl(new SdrHdlBezWgt(&rHdl)); + pHdl->SetPolyNum(rHdl.GetPolyNum()); + + if (nPnt==0 && IsClosed()) + nPnt=nPntMax; + if (nPnt>0 && rXPoly.GetFlags(nPnt-1)==PolyFlags::Control && nPlusNum==0) + { + pHdl->SetPos(rXPoly[nPnt-1]); + pHdl->SetPointNum(nPnt-1); + } + else + { + if (nPnt==nPntMax && IsClosed()) + nPnt=0; + if (nPntSetPos(rXPoly[nPnt+1]); + pHdl->SetPointNum(nPnt+1); + } + } + + pHdl->SetSourceHdlNum(rHdl.GetSourceHdlNum()); + pHdl->SetPlusHdl(true); + rHdlList.AddHdl(std::move(pHdl)); + } +} + +// tdf#123321: Make sure that SdrPathObj (e.g. line) has big enough extent for +// visibility. This is realised by ensuring GetLogicRect() is the same as +// GetSnapRect() for the SdrPathObj. Other SdrTextObj objects like +// SdrObjCustomShape will still use a different version of this method that +// does not consider the rotation. Otherwise, the rotated SdrObjCustomShape +// would become mistakenly larger after save and reload (tdf#91687). +// The invocation of the GetLogicRect() method that caused tdf#123321 was in +// PlcDrawObj::WritePlc(). +const tools::Rectangle &SdrPathObj::GetLogicRect() const +{ + return GetSnapRect(); +} + +// dragging + +bool SdrPathObj::hasSpecialDrag() const +{ + return true; +} + +bool SdrPathObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + ImpPathForDragAndCreate aDragAndCreate(*const_cast(this)); + + return aDragAndCreate.beginPathDrag(rDrag); +} + +bool SdrPathObj::applySpecialDrag(SdrDragStat& rDrag) +{ + ImpPathForDragAndCreate aDragAndCreate(*this); + bool bRetval(aDragAndCreate.beginPathDrag(rDrag)); + + if(bRetval) + { + bRetval = aDragAndCreate.movePathDrag(rDrag); + } + + if(bRetval) + { + bRetval = aDragAndCreate.endPathDrag(rDrag); + } + + if(bRetval) + { + NbcSetPathPoly(aDragAndCreate.getModifiedPolyPolygon()); + } + + return bRetval; +} + +OUString SdrPathObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + OUString aRetval; + + if(mpDAC) + { + // #i103058# also get a comment when in creation + const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment) + { + aRetval = mpDAC->getSpecialDragComment(rDrag); + } + } + else + { + ImpPathForDragAndCreate aDragAndCreate(*const_cast(this)); + bool bDidWork(aDragAndCreate.beginPathDrag(rDrag)); + + if(bDidWork) + { + aRetval = aDragAndCreate.getSpecialDragComment(rDrag); + } + } + + return aRetval; +} + +basegfx::B2DPolyPolygon SdrPathObj::getSpecialDragPoly(const SdrDragStat& rDrag) const +{ + basegfx::B2DPolyPolygon aRetval; + ImpPathForDragAndCreate aDragAndCreate(*const_cast(this)); + bool bDidWork(aDragAndCreate.beginPathDrag(rDrag)); + + if(bDidWork) + { + aRetval = aDragAndCreate.getSpecialDragPoly(rDrag); + } + + return aRetval; +} + +// creation + +bool SdrPathObj::BegCreate(SdrDragStat& rStat) +{ + mpDAC.reset(); + impGetDAC().BegCreate(rStat); + return true; +} + +bool SdrPathObj::MovCreate(SdrDragStat& rStat) +{ + return impGetDAC().MovCreate(rStat); +} + +bool SdrPathObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + bool bRetval(impGetDAC().EndCreate(rStat, eCmd)); + + if(bRetval && mpDAC) + { + SetPathPoly(mpDAC->getModifiedPolyPolygon()); + + // #i75974# Check for AutoClose feature. Moved here from ImpPathForDragAndCreate::EndCreate + // to be able to use the type-changing ImpSetClosed method + if(!IsClosedObj()) + { + SdrView* pView = rStat.GetView(); + + if(pView && !pView->IsUseIncompatiblePathCreateInterface()) + { + OutputDevice* pOut = pView->GetFirstOutputDevice(); + + if(pOut) + { + if(GetPathPoly().count()) + { + const basegfx::B2DPolygon aCandidate(GetPathPoly().getB2DPolygon(0)); + + if(aCandidate.count() > 2) + { + // check distance of first and last point + const sal_Int32 nCloseDist(pOut->PixelToLogic(Size(pView->GetAutoCloseDistPix(), 0)).Width()); + const basegfx::B2DVector aDistVector(aCandidate.getB2DPoint(aCandidate.count() - 1) - aCandidate.getB2DPoint(0)); + + if(aDistVector.getLength() <= static_cast(nCloseDist)) + { + // close it + ImpSetClosed(true); + } + } + } + } + } + } + + mpDAC.reset(); + } + + return bRetval; +} + +bool SdrPathObj::BckCreate(SdrDragStat& rStat) +{ + return impGetDAC().BckCreate(rStat); +} + +void SdrPathObj::BrkCreate(SdrDragStat& rStat) +{ + impGetDAC().BrkCreate(rStat); + mpDAC.reset(); +} + +// polygons + +basegfx::B2DPolyPolygon SdrPathObj::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + basegfx::B2DPolyPolygon aRetval; + + if(mpDAC) + { + aRetval = mpDAC->TakeObjectPolyPolygon(rDrag); + aRetval.append(ImpPathForDragAndCreate::TakeDragPolyPolygon(rDrag)); + } + + return aRetval; +} + +// during drag or create, allow accessing the so-far created/modified polyPolygon +basegfx::B2DPolyPolygon SdrPathObj::getObjectPolyPolygon(const SdrDragStat& rDrag) const +{ + basegfx::B2DPolyPolygon aRetval; + + if(mpDAC) + { + aRetval = mpDAC->TakeObjectPolyPolygon(rDrag); + } + + return aRetval; +} + +basegfx::B2DPolyPolygon SdrPathObj::getDragPolyPolygon(const SdrDragStat& rDrag) const +{ + basegfx::B2DPolyPolygon aRetval; + + if(mpDAC) + { + aRetval = ImpPathForDragAndCreate::TakeDragPolyPolygon(rDrag); + } + + return aRetval; +} + +PointerStyle SdrPathObj::GetCreatePointer() const +{ + return impGetDAC().GetCreatePointer(); +} + +void SdrPathObj::NbcMove(const Size& rSiz) +{ + maPathPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(rSiz.Width(), rSiz.Height())); + + // #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints) + SdrTextObj::NbcMove(rSiz); +} + +void SdrPathObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + const double fResizeX(xFact); + const double fResizeY(yFact); + + if(basegfx::fTools::equal(fResizeX, 1.0) && basegfx::fTools::equal(fResizeY, 1.0)) + { + // tdf#106792 avoid numerical unprecisions: If both scale factors are 1.0, do not + // manipulate at all - that may change maGeo rapidly (and wrongly) in + // SdrTextObj::NbcResize. Combined with the UNO API trying to not 'apply' + // a rotation but to manipulate the existing one, this is fatal. So just + // avoid this error as long as we have to deal with imprecise geometry + // manipulations + return; + } + + basegfx::B2DHomMatrix aTrans(basegfx::utils::createTranslateB2DHomMatrix(-rRef.X(), -rRef.Y())); + aTrans = basegfx::utils::createScaleTranslateB2DHomMatrix( + double(xFact), double(yFact), rRef.X(), rRef.Y()) * aTrans; + maPathPolygon.transform(aTrans); + + // #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints) + SdrTextObj::NbcResize(rRef,xFact,yFact); +} + +void SdrPathObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + // Thank JOE, the angles are defined mirrored to the mathematical meanings + const basegfx::B2DHomMatrix aTrans( + basegfx::utils::createRotateAroundPoint(rRef.X(), rRef.Y(), -toRadians(nAngle))); + maPathPolygon.transform(aTrans); + + // #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints) + SdrTextObj::NbcRotate(rRef,nAngle,sn,cs); +} + +void SdrPathObj::NbcShear(const Point& rRefPnt, Degree100 nAngle, double fTan, bool bVShear) +{ + basegfx::B2DHomMatrix aTrans(basegfx::utils::createTranslateB2DHomMatrix(-rRefPnt.X(), -rRefPnt.Y())); + + if(bVShear) + { + // Thank JOE, the angles are defined mirrored to the mathematical meanings + aTrans.shearY(-fTan); + } + else + { + aTrans.shearX(-fTan); + } + + aTrans.translate(rRefPnt.X(), rRefPnt.Y()); + maPathPolygon.transform(aTrans); + + // #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints) + SdrTextObj::NbcShear(rRefPnt,nAngle,fTan,bVShear); +} + +void SdrPathObj::NbcMirror(const Point& rRefPnt1, const Point& rRefPnt2) +{ + const double fDiffX(rRefPnt2.X() - rRefPnt1.X()); + const double fDiffY(rRefPnt2.Y() - rRefPnt1.Y()); + const double fRot(atan2(fDiffY, fDiffX)); + basegfx::B2DHomMatrix aTrans(basegfx::utils::createTranslateB2DHomMatrix(-rRefPnt1.X(), -rRefPnt1.Y())); + aTrans.rotate(-fRot); + aTrans.scale(1.0, -1.0); + aTrans.rotate(fRot); + aTrans.translate(rRefPnt1.X(), rRefPnt1.Y()); + maPathPolygon.transform(aTrans); + + // Do Joe's special handling for lines when mirroring, too + ImpForceKind(); + + // #i19871# first modify locally, then call parent (to get correct SnapRect with GluePoints) + SdrTextObj::NbcMirror(rRefPnt1,rRefPnt2); +} + +void SdrPathObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + if(!maGeo.m_nRotationAngle) + { + rRect = GetSnapRect(); + } + else + { + XPolyPolygon aXPP(GetPathPoly()); + RotateXPoly(aXPP,Point(),-maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + rRect=aXPP.GetBoundRect(); + Point aTmp(rRect.TopLeft()); + RotatePoint(aTmp,Point(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + aTmp-=rRect.TopLeft(); + rRect.Move(aTmp.X(),aTmp.Y()); + } +} + +void SdrPathObj::RecalcSnapRect() +{ + if(GetPathPoly().count()) + { + maSnapRect = lcl_ImpGetBoundRect(GetPathPoly()); + } +} + +void SdrPathObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aOld(GetSnapRect()); + if (aOld.IsEmpty()) + { + Fraction aX(1,1); + Fraction aY(1,1); + NbcResize(aOld.TopLeft(), aX, aY); + NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top())); + return; + } + + // Take empty into account when calculating scale factors + tools::Long nMulX = rRect.IsWidthEmpty() ? 0 : rRect.Right() - rRect.Left(); + + tools::Long nDivX = aOld.Right() - aOld.Left(); + + // Take empty into account when calculating scale factors + tools::Long nMulY = rRect.IsHeightEmpty() ? 0 : rRect.Bottom() - rRect.Top(); + + tools::Long nDivY = aOld.Bottom() - aOld.Top(); + if ( nDivX == 0 ) { nMulX = 1; nDivX = 1; } + if ( nDivY == 0 ) { nMulY = 1; nDivY = 1; } + if ( nDivX == nMulX ) { nMulX = 1; nDivX = 1; } + if ( nDivY == nMulY ) { nMulY = 1; nDivY = 1; } + Fraction aX(nMulX,nDivX); + Fraction aY(nMulY,nDivY); + NbcResize(aOld.TopLeft(), aX, aY); + NbcMove(Size(rRect.Left() - aOld.Left(), rRect.Top() - aOld.Top())); +} + +sal_uInt32 SdrPathObj::GetSnapPointCount() const +{ + return GetHdlCount(); +} + +Point SdrPathObj::GetSnapPoint(sal_uInt32 nSnapPnt) const +{ + sal_uInt32 nPoly,nPnt; + if(!PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nSnapPnt, nPoly, nPnt)) + { + SAL_WARN("svx", "SdrPathObj::GetSnapPoint: Point nSnapPnt does not exist."); + } + + const basegfx::B2DPoint aB2DPoint(GetPathPoly().getB2DPolygon(nPoly).getB2DPoint(nPnt)); + return Point(FRound(aB2DPoint.getX()), FRound(aB2DPoint.getY())); +} + +bool SdrPathObj::IsPolyObj() const +{ + return true; +} + +sal_uInt32 SdrPathObj::GetPointCount() const +{ + sal_uInt32 nRetval(0); + + for(auto const& rPolygon : GetPathPoly()) + { + nRetval += rPolygon.count(); + } + + return nRetval; +} + +Point SdrPathObj::GetPoint(sal_uInt32 nHdlNum) const +{ + Point aRetval; + sal_uInt32 nPoly,nPnt; + + if(PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nHdlNum, nPoly, nPnt)) + { + const basegfx::B2DPolygon aPoly(GetPathPoly().getB2DPolygon(nPoly)); + const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(nPnt)); + aRetval = Point(FRound(aPoint.getX()), FRound(aPoint.getY())); + } + + return aRetval; +} + +void SdrPathObj::NbcSetPoint(const Point& rPnt, sal_uInt32 nHdlNum) +{ + sal_uInt32 nPoly,nPnt; + + if(!PolyPolygonEditor::GetRelativePolyPoint(GetPathPoly(), nHdlNum, nPoly, nPnt)) + return; + + basegfx::B2DPolygon aNewPolygon(GetPathPoly().getB2DPolygon(nPoly)); + aNewPolygon.setB2DPoint(nPnt, basegfx::B2DPoint(rPnt.X(), rPnt.Y())); + maPathPolygon.setB2DPolygon(nPoly, aNewPolygon); + + if(meKind==SdrObjKind::Line) + { + ImpForceLineAngle(); + } + else + { + if(GetPathPoly().count()) + { + // #i10659# for SdrTextObj, keep aRect up to date + setRectangle(lcl_ImpGetBoundRect(GetPathPoly())); + } + } + + SetBoundAndSnapRectsDirty(); +} + +sal_uInt32 SdrPathObj::NbcInsPointOld(const Point& rPos, bool bNewObj) +{ + sal_uInt32 nNewHdl; + + if(bNewObj) + { + nNewHdl = NbcInsPoint(rPos, true); + } + else + { + // look for smallest distance data + const basegfx::B2DPoint aTestPoint(rPos.X(), rPos.Y()); + sal_uInt32 nSmallestPolyIndex(0); + sal_uInt32 nSmallestEdgeIndex(0); + double fSmallestCut; + basegfx::utils::getSmallestDistancePointToPolyPolygon(GetPathPoly(), aTestPoint, nSmallestPolyIndex, nSmallestEdgeIndex, fSmallestCut); + + nNewHdl = NbcInsPoint(rPos, false); + } + + ImpForceKind(); + return nNewHdl; +} + +sal_uInt32 SdrPathObj::NbcInsPoint(const Point& rPos, bool bNewObj) +{ + sal_uInt32 nNewHdl; + + if(bNewObj) + { + basegfx::B2DPolygon aNewPoly; + const basegfx::B2DPoint aPoint(rPos.X(), rPos.Y()); + aNewPoly.append(aPoint); + aNewPoly.setClosed(IsClosed()); + maPathPolygon.append(aNewPoly); + SetBoundAndSnapRectsDirty(); + nNewHdl = GetHdlCount(); + } + else + { + // look for smallest distance data + const basegfx::B2DPoint aTestPoint(rPos.X(), rPos.Y()); + sal_uInt32 nSmallestPolyIndex(0); + sal_uInt32 nSmallestEdgeIndex(0); + double fSmallestCut; + basegfx::utils::getSmallestDistancePointToPolyPolygon(GetPathPoly(), aTestPoint, nSmallestPolyIndex, nSmallestEdgeIndex, fSmallestCut); + basegfx::B2DPolygon aCandidate(GetPathPoly().getB2DPolygon(nSmallestPolyIndex)); + const bool bBefore(!aCandidate.isClosed() && 0 == nSmallestEdgeIndex && 0.0 == fSmallestCut); + const bool bAfter(!aCandidate.isClosed() && aCandidate.count() == nSmallestEdgeIndex + 2 && 1.0 == fSmallestCut); + + if(bBefore) + { + // before first point + aCandidate.insert(0, aTestPoint); + + if(aCandidate.areControlPointsUsed()) + { + if(aCandidate.isNextControlPointUsed(1)) + { + aCandidate.setNextControlPoint(0, interpolate(aTestPoint, aCandidate.getB2DPoint(1), (1.0 / 3.0))); + aCandidate.setPrevControlPoint(1, interpolate(aTestPoint, aCandidate.getB2DPoint(1), (2.0 / 3.0))); + } + } + + nNewHdl = 0; + } + else if(bAfter) + { + // after last point + aCandidate.append(aTestPoint); + + if(aCandidate.areControlPointsUsed()) + { + if(aCandidate.isPrevControlPointUsed(aCandidate.count() - 2)) + { + aCandidate.setNextControlPoint(aCandidate.count() - 2, interpolate(aCandidate.getB2DPoint(aCandidate.count() - 2), aTestPoint, (1.0 / 3.0))); + aCandidate.setPrevControlPoint(aCandidate.count() - 1, interpolate(aCandidate.getB2DPoint(aCandidate.count() - 2), aTestPoint, (2.0 / 3.0))); + } + } + + nNewHdl = aCandidate.count() - 1; + } + else + { + // in between + bool bSegmentSplit(false); + const sal_uInt32 nNextIndex((nSmallestEdgeIndex + 1) % aCandidate.count()); + + if(aCandidate.areControlPointsUsed()) + { + if(aCandidate.isNextControlPointUsed(nSmallestEdgeIndex) || aCandidate.isPrevControlPointUsed(nNextIndex)) + { + bSegmentSplit = true; + } + } + + if(bSegmentSplit) + { + // rebuild original segment to get the split data + basegfx::B2DCubicBezier aBezierA, aBezierB; + const basegfx::B2DCubicBezier aBezier( + aCandidate.getB2DPoint(nSmallestEdgeIndex), + aCandidate.getNextControlPoint(nSmallestEdgeIndex), + aCandidate.getPrevControlPoint(nNextIndex), + aCandidate.getB2DPoint(nNextIndex)); + + // split and insert hit point + aBezier.split(fSmallestCut, &aBezierA, &aBezierB); + aCandidate.insert(nSmallestEdgeIndex + 1, aTestPoint); + + // since we inserted hit point and not split point, we need to add an offset + // to the control points to get the C1 continuity we want to achieve + const basegfx::B2DVector aOffset(aTestPoint - aBezierA.getEndPoint()); + aCandidate.setNextControlPoint(nSmallestEdgeIndex, aBezierA.getControlPointA() + aOffset); + aCandidate.setPrevControlPoint(nSmallestEdgeIndex + 1, aBezierA.getControlPointB() + aOffset); + aCandidate.setNextControlPoint(nSmallestEdgeIndex + 1, aBezierB.getControlPointA() + aOffset); + aCandidate.setPrevControlPoint((nSmallestEdgeIndex + 2) % aCandidate.count(), aBezierB.getControlPointB() + aOffset); + } + else + { + aCandidate.insert(nSmallestEdgeIndex + 1, aTestPoint); + } + + nNewHdl = nSmallestEdgeIndex + 1; + } + + maPathPolygon.setB2DPolygon(nSmallestPolyIndex, aCandidate); + + // create old polygon index from it + for(sal_uInt32 a(0); a < nSmallestPolyIndex; a++) + { + nNewHdl += GetPathPoly().getB2DPolygon(a).count(); + } + } + + ImpForceKind(); + return nNewHdl; +} + +rtl::Reference SdrPathObj::RipPoint(sal_uInt32 nHdlNum, sal_uInt32& rNewPt0Index) +{ + rtl::Reference pNewObj; + const basegfx::B2DPolyPolygon aLocalPolyPolygon(GetPathPoly()); + sal_uInt32 nPoly, nPnt; + + if(PolyPolygonEditor::GetRelativePolyPoint(aLocalPolyPolygon, nHdlNum, nPoly, nPnt)) + { + if(0 == nPoly) + { + const basegfx::B2DPolygon& aCandidate(aLocalPolyPolygon.getB2DPolygon(nPoly)); + const sal_uInt32 nPointCount(aCandidate.count()); + + if(nPointCount) + { + if(IsClosed()) + { + // when closed, RipPoint means to open the polygon at the selected point. To + // be able to do that, it is necessary to make the selected point the first one + basegfx::B2DPolygon aNewPolygon(basegfx::utils::makeStartPoint(aCandidate, nPnt)); + SetPathPoly(basegfx::B2DPolyPolygon(aNewPolygon)); + ToggleClosed(); + + // give back new position of old start point (historical reasons) + rNewPt0Index = (nPointCount - nPnt) % nPointCount; + } + else + { + if(nPointCount >= 3 && nPnt != 0 && nPnt + 1 < nPointCount) + { + // split in two objects at point nPnt + basegfx::B2DPolygon aSplitPolyA(aCandidate, 0, nPnt + 1); + SetPathPoly(basegfx::B2DPolyPolygon(aSplitPolyA)); + + pNewObj = SdrObject::Clone(*this, getSdrModelFromSdrObject()); + basegfx::B2DPolygon aSplitPolyB(aCandidate, nPnt, nPointCount - nPnt); + pNewObj->SetPathPoly(basegfx::B2DPolyPolygon(aSplitPolyB)); + } + } + } + } + } + + return pNewObj; +} + +rtl::Reference SdrPathObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + // #i89784# check for FontWork with activated HideContour + const drawinglayer::attribute::SdrTextAttribute aText( + drawinglayer::primitive2d::createNewSdrTextAttribute(GetObjectItemSet(), *getText(0))); + const bool bHideContour( + !aText.isDefault() && !aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour()); + + rtl::Reference pRet; + + if(!bHideContour) + { + rtl::Reference pPath = ImpConvertMakeObj(GetPathPoly(), IsClosed(), bBezier); + + if(pPath->GetPathPoly().areControlPointsUsed()) + { + if(!bBezier) + { + // reduce all bezier curves + pPath->SetPathPoly(basegfx::utils::adaptiveSubdivideByAngle(pPath->GetPathPoly())); + } + } + else + { + if(bBezier) + { + // create bezier curves + pPath->SetPathPoly(basegfx::utils::expandToCurve(pPath->GetPathPoly())); + } + } + pRet = std::move(pPath); + } + + if(bAddText) + { + pRet = ImpConvertAddText(std::move(pRet), bBezier); + } + + return pRet; +} + +std::unique_ptr SdrPathObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrPathObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrTextObj::SaveGeoData(rGeo); + SdrPathObjGeoData& rPGeo = static_cast( rGeo ); + rPGeo.maPathPolygon=GetPathPoly(); + rPGeo.meKind=meKind; +} + +void SdrPathObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrTextObj::RestoreGeoData(rGeo); + const SdrPathObjGeoData& rPGeo=static_cast(rGeo); + maPathPolygon=rPGeo.maPathPolygon; + meKind=rPGeo.meKind; + ImpForceKind(); // to set bClosed (among other things) +} + +void SdrPathObj::NbcSetPathPoly(const basegfx::B2DPolyPolygon& rPathPoly) +{ + if(GetPathPoly() != rPathPoly) + { + maPathPolygon=rPathPoly; + ImpForceKind(); + SetBoundAndSnapRectsDirty(); + } +} + +void SdrPathObj::SetPathPoly(const basegfx::B2DPolyPolygon& rPathPoly) +{ + if(GetPathPoly() != rPathPoly) + { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetPathPoly(rPathPoly); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrPathObj::ToggleClosed() +{ + tools::Rectangle aBoundRect0; + if(m_pUserCall != nullptr) + aBoundRect0 = GetLastBoundRect(); + ImpSetClosed(!IsClosed()); // set new ObjKind + ImpForceKind(); // because we want Line -> Poly -> PolyLine instead of Line -> Poly -> Line + SetBoundAndSnapRectsDirty(); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize, aBoundRect0); +} + +ImpPathForDragAndCreate& SdrPathObj::impGetDAC() const +{ + if(!mpDAC) + { + const_cast(this)->mpDAC.reset(new ImpPathForDragAndCreate(*const_cast(this))); + } + + return *mpDAC; +} + + +// transformation interface for StarOfficeAPI. This implements support for +// homogeneous 3x3 matrices containing the transformation of the SdrObject. At the +// moment it contains a shearX, rotation and translation, but for setting all linear +// transforms like Scale, ShearX, ShearY, Rotate and Translate are supported. + + +// gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon +// with the base geometry and returns TRUE. Otherwise it returns FALSE. +bool SdrPathObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& rPolyPolygon) const +{ + double fRotate(0.0); + double fShearX(0.0); + basegfx::B2DTuple aScale(1.0, 1.0); + basegfx::B2DTuple aTranslate(0.0, 0.0); + + if(GetPathPoly().count()) + { + // copy geometry + basegfx::B2DHomMatrix aMoveToZeroMatrix; + rPolyPolygon = GetPathPoly(); + + if(SdrObjKind::Line == meKind) + { + // ignore shear and rotate, just use scale and translate + OSL_ENSURE(GetPathPoly().count() > 0 && GetPathPoly().getB2DPolygon(0).count() > 1, "OBJ_LINE with too few polygons (!)"); + // #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon + // itself, else this method will no longer return the full polygon information (curve will + // be lost) + const basegfx::B2DRange aPolyRangeNoCurve(basegfx::utils::getRange(rPolyPolygon)); + aScale = aPolyRangeNoCurve.getRange(); + aTranslate = aPolyRangeNoCurve.getMinimum(); + + // define matrix for move polygon to zero point + aMoveToZeroMatrix.translate(-aTranslate.getX(), -aTranslate.getY()); + } + else + { + if(maGeo.m_nShearAngle || maGeo.m_nRotationAngle) + { + // get rotate and shear in drawingLayer notation + fRotate = toRadians(maGeo.m_nRotationAngle); + fShearX = toRadians(maGeo.m_nShearAngle); + + // build mathematically correct (negative shear and rotate) object transform + // containing shear and rotate to extract unsheared, unrotated polygon + basegfx::B2DHomMatrix aObjectMatrix; + aObjectMatrix.shearX(-maGeo.mfTanShearAngle); + aObjectMatrix.rotate(toRadians(36000_deg100 - maGeo.m_nRotationAngle)); + + // create inverse from it and back-transform polygon + basegfx::B2DHomMatrix aInvObjectMatrix(aObjectMatrix); + aInvObjectMatrix.invert(); + rPolyPolygon.transform(aInvObjectMatrix); + + // get range from unsheared, unrotated polygon and extract scale and translate. + // transform topLeft from it back to transformed state to get original + // topLeft (rotation center) + // #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon + // itself, else this method will no longer return the full polygon information (curve will + // be lost) + const basegfx::B2DRange aCorrectedRangeNoCurve(basegfx::utils::getRange(rPolyPolygon)); + aTranslate = aObjectMatrix * aCorrectedRangeNoCurve.getMinimum(); + aScale = aCorrectedRangeNoCurve.getRange(); + + // define matrix for move polygon to zero point + // #i112280# Added missing minus for Y-Translation + aMoveToZeroMatrix.translate(-aCorrectedRangeNoCurve.getMinX(), -aCorrectedRangeNoCurve.getMinY()); + } + else + { + // get scale and translate from unsheared, unrotated polygon + // #i72287# use polygon without control points for range calculation. Do not change rPolyPolygon + // itself, else this method will no longer return the full polygon information (curve will + // be lost) + const basegfx::B2DRange aPolyRangeNoCurve(basegfx::utils::getRange(rPolyPolygon)); + aScale = aPolyRangeNoCurve.getRange(); + aTranslate = aPolyRangeNoCurve.getMinimum(); + + // define matrix for move polygon to zero point + aMoveToZeroMatrix.translate(-aTranslate.getX(), -aTranslate.getY()); + } + } + + // move polygon to zero point with pre-defined matrix + rPolyPolygon.transform(aMoveToZeroMatrix); + } + + // position maybe relative to anchorpos, convert + if( getSdrModelFromSdrObject().IsWriter() ) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build return value matrix + rMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, + basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX), + basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate, + aTranslate); + + return true; +} + +void SdrPathObj::SetHandleScale(bool bHandleScale) +{ + mbHandleScale = bHandleScale; +} + +// Sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix. +// If it's an SdrPathObj it will use the provided geometry information. The Polygon has +// to use (0,0) as upper left and will be scaled to the given size in the matrix. +void SdrPathObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + // break up matrix + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + rMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings + // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly + if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0)) + { + aScale.setX(fabs(aScale.getX())); + aScale.setY(fabs(aScale.getY())); + fRotate = fmod(fRotate + M_PI, 2 * M_PI); + } + + // copy poly + basegfx::B2DPolyPolygon aNewPolyPolygon(rPolyPolygon); + + // reset object shear and rotations + maGeo.m_nRotationAngle = 0_deg100; + maGeo.RecalcSinCos(); + maGeo.m_nShearAngle = 0_deg100; + maGeo.RecalcTan(); + + if( getSdrModelFromSdrObject().IsWriter() ) + { + // if anchor is used, make position relative to it + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // create transformation for polygon, set values at maGeo direct + basegfx::B2DHomMatrix aTransform; + + // #i75086# + // Given polygon is already scaled (for historical reasons), but not mirrored yet. + // Thus, when scale is negative in X or Y, apply the needed mirroring accordingly. + double fScaleX(basegfx::fTools::less(aScale.getX(), 0.0) ? -1.0 : 1.0); + double fScaleY(basegfx::fTools::less(aScale.getY(), 0.0) ? -1.0 : 1.0); + + // tdf#98565, tdf#98584. While loading a shape, svg:width and svg:height is used to scale + // the polygon. But draw:transform might introduce additional scaling factors, which need to + // be applied to the polygon too, so aScale cannot be ignored while loading. + // I use "maSnapRect.IsEmpty() && GetPathPoly().count()" to detect this case. Any better + // idea? The behavior in other cases is the same as it was before this fix. + if (maSnapRect.IsEmpty() && GetPathPoly().count() && mbHandleScale) + { + // In case of a Writer document, the scaling factors were converted to twips. That is not + // correct here, because width and height are already in the points coordinates and aScale + // is no length but only a factor here. Convert back. + if (getSdrModelFromSdrObject().IsWriter()) + { + aScale.setX(o3tl::convert(aScale.getX(), o3tl::Length::twip, o3tl::Length::mm100)); + aScale.setY(o3tl::convert(aScale.getY(), o3tl::Length::twip, o3tl::Length::mm100)); + } + fScaleX *= fabs(aScale.getX()); + fScaleY *= fabs(aScale.getY()); + } + + if (fScaleX != 1.0 || fScaleY != 1.0) + aTransform.scale(fScaleX, fScaleY); + + if(!basegfx::fTools::equalZero(fShearX)) + { + aTransform.shearX(tan(-atan(fShearX))); + maGeo.m_nShearAngle = Degree100(FRound(basegfx::rad2deg<100>(atan(fShearX)))); + maGeo.RecalcTan(); + } + + if(!basegfx::fTools::equalZero(fRotate)) + { + // #i78696# + // fRotate is mathematically correct for linear transformations, so it's + // the one to use for the geometry change + aTransform.rotate(fRotate); + + // #i78696# + // fRotate is mathematically correct, but aGeoStat.nRotationAngle is + // mirrored -> mirror value here + maGeo.m_nRotationAngle = NormAngle36000(Degree100(FRound(-basegfx::rad2deg<100>(fRotate)))); + maGeo.RecalcSinCos(); + } + + if(!aTranslate.equalZero()) + { + // #i39529# absolute positioning, so get current position (without control points (!)) + const basegfx::B2DRange aCurrentRange(basegfx::utils::getRange(aNewPolyPolygon)); + aTransform.translate(aTranslate.getX() - aCurrentRange.getMinX(), aTranslate.getY() - aCurrentRange.getMinY()); + } + + // transform polygon and trigger change + aNewPolyPolygon.transform(aTransform); + SetPathPoly(aNewPolyPolygon); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdorect.cxx b/svx/source/svdraw/svdorect.cxx new file mode 100644 index 0000000000..7f805a2d28 --- /dev/null +++ b/svx/source/svdraw/svdorect.cxx @@ -0,0 +1,573 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +// BaseProperties section + +std::unique_ptr SdrRectObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + + +// DrawContact section + +std::unique_ptr SdrRectObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + + +SdrRectObj::SdrRectObj(SdrModel& rSdrModel) +: SdrTextObj(rSdrModel) +{ + m_bClosedObj=true; +} + +SdrRectObj::SdrRectObj(SdrModel& rSdrModel, SdrRectObj const & rSource) +: SdrTextObj(rSdrModel, rSource) +{ + m_bClosedObj=true; + mpXPoly = rSource.mpXPoly; +} + +SdrRectObj::SdrRectObj( + SdrModel& rSdrModel, + const tools::Rectangle& rRect) +: SdrTextObj(rSdrModel, rRect) +{ + m_bClosedObj=true; +} + +SdrRectObj::SdrRectObj( + SdrModel& rSdrModel, + SdrObjKind eNewTextKind) +: SdrTextObj(rSdrModel, eNewTextKind) +{ + DBG_ASSERT(meTextKind == SdrObjKind::Text || + meTextKind == SdrObjKind::OutlineText || meTextKind == SdrObjKind::TitleText, + "SdrRectObj::SdrRectObj(SdrObjKind) can only be applied to text frames."); + m_bClosedObj=true; +} + +SdrRectObj::SdrRectObj( + SdrModel& rSdrModel, + SdrObjKind eNewTextKind, + const tools::Rectangle& rRect) +: SdrTextObj(rSdrModel, eNewTextKind, rRect) +{ + DBG_ASSERT(meTextKind == SdrObjKind::Text || + meTextKind == SdrObjKind::OutlineText || meTextKind == SdrObjKind::TitleText, + "SdrRectObj::SdrRectObj(SdrObjKind,...) can only be applied to text frames."); + m_bClosedObj=true; +} + +SdrRectObj::~SdrRectObj() +{ +} + +void SdrRectObj::SetXPolyDirty() +{ + mpXPoly.reset(); +} + +XPolygon SdrRectObj::ImpCalcXPoly(const tools::Rectangle& rRect1, tools::Long nRad1) const +{ + XPolygon aXPoly(rRect1,nRad1,nRad1); + const sal_uInt16 nPointCnt(aXPoly.GetPointCount()); + XPolygon aNewPoly(nPointCnt+1); + sal_uInt16 nShift=nPointCnt-2; + if (nRad1!=0) nShift=nPointCnt-5; + sal_uInt16 j=nShift; + for (sal_uInt16 i=1; i=nPointCnt) j=1; + } + aNewPoly[0]=rRect1.BottomCenter(); + aNewPoly[nPointCnt]=aNewPoly[0]; + aXPoly=aNewPoly; + + // these angles always relate to the top left corner of aRect + if (maGeo.m_nShearAngle) ShearXPoly(aXPoly, getRectangle().TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) RotateXPoly(aXPoly, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + return aXPoly; +} + +void SdrRectObj::RecalcXPoly() +{ + mpXPoly = ImpCalcXPoly(getRectangle(), GetEckenradius()); +} + +const XPolygon& SdrRectObj::GetXPoly() const +{ + if(!mpXPoly) + { + const_cast(this)->RecalcXPoly(); + } + + return *mpXPoly; +} + +void SdrRectObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + bool bNoTextFrame=!IsTextFrame(); + rInfo.bResizeFreeAllowed=bNoTextFrame || ((maGeo.m_nRotationAngle.get() % 9000) == 0); + rInfo.bResizePropAllowed=true; + rInfo.bRotateFreeAllowed=true; + rInfo.bRotate90Allowed =true; + rInfo.bMirrorFreeAllowed=bNoTextFrame; + rInfo.bMirror45Allowed =bNoTextFrame; + rInfo.bMirror90Allowed =bNoTextFrame; + + // allow transparency + rInfo.bTransparenceAllowed = true; + + rInfo.bShearAllowed =bNoTextFrame; + rInfo.bEdgeRadiusAllowed=true; + + bool bCanConv=!HasText() || ImpCanConvTextToCurve(); + if (bCanConv && !bNoTextFrame && !HasText()) { + bCanConv=HasFill() || HasLine(); + } + rInfo.bCanConvToPath =bCanConv; + rInfo.bCanConvToPoly =bCanConv; + rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrRectObj::GetObjIdentifier() const +{ + if (IsTextFrame()) + return meTextKind; + else return SdrObjKind::Rectangle; +} + +void SdrRectObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + rRect = getRectangle(); + if (maGeo.m_nShearAngle==0_deg100) + return; + + tools::Long nDst=FRound((getRectangle().Bottom()-getRectangle().Top()) * maGeo.mfTanShearAngle); + if (maGeo.m_nShearAngle>0_deg100) + { + Point aRef(rRect.TopLeft()); + rRect.AdjustLeft( -nDst ); + Point aTmpPt(rRect.TopLeft()); + RotatePoint(aTmpPt,aRef,maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + aTmpPt-=rRect.TopLeft(); + rRect.Move(aTmpPt.X(),aTmpPt.Y()); + } + else + { + rRect.AdjustRight( -nDst ); + } +} + +OUString SdrRectObj::TakeObjNameSingul() const +{ + if (IsTextFrame()) + { + return SdrTextObj::TakeObjNameSingul(); + } + + bool bRounded = GetEckenradius() != 0; // rounded down + TranslateId pResId = bRounded ? STR_ObjNameSingulRECTRND : STR_ObjNameSingulRECT; + if (maGeo.m_nShearAngle) + { + pResId = bRounded ? STR_ObjNameSingulPARALRND : STR_ObjNameSingulPARAL; // parallelogram or, maybe, rhombus + } + else if (getRectangle().GetWidth() == getRectangle().GetHeight()) + { + pResId = bRounded ? STR_ObjNameSingulQUADRND : STR_ObjNameSingulQUAD; // square + } + OUString sName(SvxResId(pResId)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrRectObj::TakeObjNamePlural() const +{ + if (IsTextFrame()) + { + return SdrTextObj::TakeObjNamePlural(); + } + + bool bRounded = GetEckenradius() != 0; // rounded down + TranslateId pResId = bRounded ? STR_ObjNamePluralRECTRND : STR_ObjNamePluralRECT; + if (maGeo.m_nShearAngle) + { + pResId = bRounded ? STR_ObjNamePluralPARALRND : STR_ObjNamePluralPARAL; // parallelogram or rhombus + } + else if (getRectangle().GetWidth() == getRectangle().GetHeight()) + { + pResId = bRounded ? STR_ObjNamePluralQUADRND : STR_ObjNamePluralQUAD; // square + } + + return SvxResId(pResId); +} + +rtl::Reference SdrRectObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrRectObj(rTargetModel, *this); +} + +basegfx::B2DPolyPolygon SdrRectObj::TakeXorPoly() const +{ + XPolyPolygon aXPP; + aXPP.Insert(ImpCalcXPoly(getRectangle(), GetEckenradius())); + return aXPP.getB2DPolyPolygon(); +} + +void SdrRectObj::RecalcSnapRect() +{ + tools::Long nEckRad=GetEckenradius(); + if ((maGeo.m_nRotationAngle || maGeo.m_nShearAngle) && nEckRad!=0) { + maSnapRect=GetXPoly().GetBoundRect(); + } else { + SdrTextObj::RecalcSnapRect(); + } +} + +void SdrRectObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + SdrTextObj::NbcSetSnapRect(rRect); + SetXPolyDirty(); +} + +void SdrRectObj::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + SdrTextObj::NbcSetLogicRect(rRect); + SetXPolyDirty(); +} + +sal_uInt32 SdrRectObj::GetHdlCount() const +{ + return IsTextFrame() ? 10 : 9; +} + +void SdrRectObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + // A text box has an additional (pseudo-)handle for the blinking frame. + if(IsTextFrame()) + { + OSL_ENSURE(!IsTextEditActive(), "Do not use an ImpTextframeHdl for highlighting text in active text edit, this will collide with EditEngine paints (!)"); + std::unique_ptr pH(new ImpTextframeHdl(getRectangle())); + pH->SetObj(const_cast(this)); + pH->SetRotationAngle(maGeo.m_nRotationAngle); + rHdlList.AddHdl(std::move(pH)); + } + + for(sal_Int32 nHdlNum = 1; nHdlNum <= 9; ++nHdlNum) + { + Point aPnt; + SdrHdlKind eKind = SdrHdlKind::Move; + auto const& rRectangle = getRectangle(); + switch(nHdlNum) + { + case 1: // Handle for changing the corner radius + { + tools::Long a = GetEckenradius(); + tools::Long b = std::max(rRectangle.GetWidth(), rRectangle.GetHeight())/2; // rounded up, because GetWidth() adds 1 + if (a>b) a=b; + if (a<0) a=0; + aPnt = rRectangle.TopLeft(); + aPnt.AdjustX(a ); + eKind = SdrHdlKind::Circle; + break; + } + case 2: aPnt = rRectangle.TopLeft(); eKind = SdrHdlKind::UpperLeft; break; + case 3: aPnt = rRectangle.TopCenter(); eKind = SdrHdlKind::Upper; break; + case 4: aPnt = rRectangle.TopRight(); eKind = SdrHdlKind::UpperRight; break; + case 5: aPnt = rRectangle.LeftCenter(); eKind = SdrHdlKind::Left ; break; + case 6: aPnt = rRectangle.RightCenter(); eKind = SdrHdlKind::Right; break; + case 7: aPnt = rRectangle.BottomLeft(); eKind = SdrHdlKind::LowerLeft; break; + case 8: aPnt = rRectangle.BottomCenter(); eKind = SdrHdlKind::Lower; break; + case 9: aPnt = rRectangle.BottomRight(); eKind = SdrHdlKind::LowerRight; break; + } + + if (maGeo.m_nShearAngle) + { + ShearPoint(aPnt,rRectangle.TopLeft(),maGeo.mfTanShearAngle); + } + if (maGeo.m_nRotationAngle) + { + RotatePoint(aPnt,rRectangle.TopLeft(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + } + + std::unique_ptr pH(new SdrHdl(aPnt,eKind)); + pH->SetObj(const_cast(this)); + pH->SetRotationAngle(maGeo.m_nRotationAngle); + rHdlList.AddHdl(std::move(pH)); + } +} + +bool SdrRectObj::hasSpecialDrag() const +{ + return true; +} + +bool SdrRectObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + const bool bRad(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if(bRad) + { + rDrag.SetEndDragChangesAttributes(true); + + return true; + } + + return SdrTextObj::beginSpecialDrag(rDrag); +} + +bool SdrRectObj::applySpecialDrag(SdrDragStat& rDrag) +{ + const bool bRad(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if (bRad) + { + Point aPt(rDrag.GetNow()); + + if (maGeo.m_nRotationAngle) + RotatePoint(aPt, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + sal_Int32 nRad(aPt.X() - getRectangle().Left()); + + if (nRad < 0) + nRad = 0; + + if(nRad != GetEckenradius()) + { + NbcSetEckenradius(nRad); + } + + return true; + } + else + { + return SdrTextObj::applySpecialDrag(rDrag); + } +} + +OUString SdrRectObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj()); + + if(bCreateComment) + { + return OUString(); + } + else + { + const bool bRad(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind()); + + if(bRad) + { + Point aPt(rDrag.GetNow()); + + // -sin for reversal + if (maGeo.m_nRotationAngle) + RotatePoint(aPt, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + sal_Int32 nRad(aPt.X() - getRectangle().Left()); + + if(nRad < 0) + nRad = 0; + + return ImpGetDescriptionStr(STR_DragRectEckRad) + + " (" + + GetMetrStr(nRad) + + ")"; + } + else + { + return SdrTextObj::getSpecialDragComment(rDrag); + } + } +} + + +basegfx::B2DPolyPolygon SdrRectObj::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + tools::Rectangle aRect1; + rDrag.TakeCreateRect(aRect1); + aRect1.Normalize(); + + basegfx::B2DPolyPolygon aRetval; + aRetval.append(ImpCalcXPoly(aRect1,GetEckenradius()).getB2DPolygon()); + return aRetval; +} + +PointerStyle SdrRectObj::GetCreatePointer() const +{ + if (IsTextFrame()) return PointerStyle::DrawText; + return PointerStyle::DrawRect; +} + +void SdrRectObj::NbcMove(const Size& rSiz) +{ + SdrTextObj::NbcMove(rSiz); + SetXPolyDirty(); +} + +void SdrRectObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + SdrTextObj::NbcResize(rRef,xFact,yFact); + SetXPolyDirty(); +} + +void SdrRectObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + SdrTextObj::NbcRotate(rRef,nAngle,sn,cs); + SetXPolyDirty(); +} + +void SdrRectObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + SdrTextObj::NbcShear(rRef,nAngle,tn,bVShear); + SetXPolyDirty(); +} + +void SdrRectObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + SdrTextObj::NbcMirror(rRef1,rRef2); + SetXPolyDirty(); +} + +SdrGluePoint SdrRectObj::GetVertexGluePoint(sal_uInt16 nPosNum) const +{ + sal_Int32 nWdt = ImpGetLineWdt(); // #i25616# + + // #i25616# + if(!LineIsOutsideGeometry()) + { + nWdt++; + nWdt /= 2; + } + + Point aPt; + auto const& rRectangle = getRectangle(); + switch (nPosNum) { + case 0: aPt = rRectangle.TopCenter(); aPt.AdjustY( -nWdt ); break; + case 1: aPt = rRectangle.RightCenter(); aPt.AdjustX(nWdt ); break; + case 2: aPt = rRectangle.BottomCenter(); aPt.AdjustY(nWdt ); break; + case 3: aPt = rRectangle.LeftCenter(); aPt.AdjustX( -nWdt ); break; + } + if (maGeo.m_nShearAngle) + ShearPoint(aPt, rRectangle.TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) + RotatePoint(aPt, rRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aPt-=GetSnapRect().Center(); + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + return aGP; +} + +SdrGluePoint SdrRectObj::GetCornerGluePoint(sal_uInt16 nPosNum) const +{ + sal_Int32 nWdt = ImpGetLineWdt(); // #i25616# + + // #i25616# + if(!LineIsOutsideGeometry()) + { + nWdt++; + nWdt /= 2; + } + + Point aPt; + auto const& rRectangle = getRectangle(); + switch (nPosNum) { + case 0: aPt = rRectangle.TopLeft(); aPt.AdjustX( -nWdt ); aPt.AdjustY( -nWdt ); break; + case 1: aPt = rRectangle.TopRight(); aPt.AdjustX(nWdt ); aPt.AdjustY( -nWdt ); break; + case 2: aPt = rRectangle.BottomRight(); aPt.AdjustX(nWdt ); aPt.AdjustY(nWdt ); break; + case 3: aPt = rRectangle.BottomLeft(); aPt.AdjustX( -nWdt ); aPt.AdjustY(nWdt ); break; + } + if (maGeo.m_nShearAngle) + ShearPoint(aPt, rRectangle.TopLeft(),maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) + RotatePoint(aPt, rRectangle.TopLeft(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + aPt-=GetSnapRect().Center(); + SdrGluePoint aGP(aPt); + aGP.SetPercent(false); + return aGP; +} + +rtl::Reference SdrRectObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + XPolygon aXP(ImpCalcXPoly(getRectangle(), GetEckenradius())); + { // TODO: this is only for the moment, until we have the new TakeContour() + aXP.Remove(0,1); + aXP[aXP.GetPointCount()-1]=aXP[0]; + } + + basegfx::B2DPolyPolygon aPolyPolygon(aXP.getB2DPolygon()); + aPolyPolygon.removeDoublePoints(); + rtl::Reference pRet; + + // small correction: Do not create something when no fill and no line. To + // be sure to not damage something with non-text frames, do this only + // when used with bAddText==false from other converters + if((bAddText && !IsTextFrame()) || HasFill() || HasLine()) + { + pRet = ImpConvertMakeObj(aPolyPolygon, true, bBezier); + } + + if(bAddText) + { + pRet = ImpConvertAddText(std::move(pRet), bBezier); + } + + return pRet; +} + +void SdrRectObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + SdrTextObj::Notify(rBC,rHint); + SetXPolyDirty(); // because of the corner radius +} + +void SdrRectObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + SdrTextObj::RestoreGeoData(rGeo); + SetXPolyDirty(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotext.cxx b/svx/source/svdraw/svdotext.cxx new file mode 100644 index 0000000000..e88e127e4f --- /dev/null +++ b/svx/source/svdraw/svdotext.cxx @@ -0,0 +1,2251 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +// BaseProperties section +std::unique_ptr SdrTextObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + +// DrawContact section +std::unique_ptr SdrTextObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +SdrTextObj::SdrTextObj(SdrModel& rSdrModel) + : SdrAttrObj(rSdrModel) + , mpEditingOutliner(nullptr) + , meTextKind(SdrObjKind::Text) + , maTextEditOffset(Point(0, 0)) + , mbTextFrame(false) + , mbNoShear(false) + , mbTextSizeDirty(false) + , mbInEditMode(false) + , mbDisableAutoWidthOnDragging(false) + , mbTextAnimationAllowed(true) + , mbInDownScale(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = true; +} + +SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrTextObj const & rSource) + : SdrAttrObj(rSdrModel, rSource) + , mpEditingOutliner(nullptr) + , meTextKind(rSource.meTextKind) + , maTextEditOffset(Point(0, 0)) + , mbTextFrame(rSource.mbTextFrame) + , mbNoShear(rSource.mbNoShear) + , mbTextSizeDirty(rSource.mbTextSizeDirty) + , mbInEditMode(false) + , mbDisableAutoWidthOnDragging(rSource.mbDisableAutoWidthOnDragging) + , mbTextAnimationAllowed(true) + , mbInDownScale(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = true; + + maRectangle = rSource.maRectangle; + maGeo = rSource.maGeo; + maTextSize = rSource.maTextSize; + + // Not all of the necessary parameters were copied yet. + SdrText* pText = getActiveText(); + + if( pText && rSource.HasText() ) + { + // before pNewOutlinerParaObject was created the same, but + // set at mpText (outside this scope), but mpText might be + // empty (this operator== seems not prepared for MultiText + // objects). In the current form it makes only sense to + // create locally and use locally on a known existing SdrText + const Outliner* pEO = rSource.mpEditingOutliner; + std::optional pNewOutlinerParaObject; + + if (pEO!=nullptr) + { + pNewOutlinerParaObject = pEO->CreateParaObject(); + } + else if (nullptr != rSource.getActiveText()->GetOutlinerParaObject()) + { + pNewOutlinerParaObject = *rSource.getActiveText()->GetOutlinerParaObject(); + } + + pText->SetOutlinerParaObject( std::move(pNewOutlinerParaObject) ); + } + + ImpSetTextStyleSheetListeners(); +} + +SdrTextObj::SdrTextObj(SdrModel& rSdrModel, const tools::Rectangle& rNewRect) + : SdrAttrObj(rSdrModel) + , mpEditingOutliner(nullptr) + , meTextKind(SdrObjKind::Text) + , maTextEditOffset(Point(0, 0)) + , mbTextFrame(false) + , mbNoShear(false) + , mbTextSizeDirty(false) + , mbInEditMode(false) + , mbDisableAutoWidthOnDragging(false) + , mbTextAnimationAllowed(true) + , mbInDownScale(false) +{ + tools::Rectangle aRectangle(rNewRect); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = true; +} + +SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrObjKind eNewTextKind) + : SdrAttrObj(rSdrModel) + , mpEditingOutliner(nullptr) + , meTextKind(eNewTextKind) + , maTextEditOffset(Point(0, 0)) + , mbTextFrame(true) + , mbNoShear(true) + , mbTextSizeDirty(false) + , mbInEditMode(false) + , mbDisableAutoWidthOnDragging(false) + , mbTextAnimationAllowed(true) + , mbInDownScale(false) +{ + // #i25616# + mbSupportTextIndentingOnLineWidthChange = true; +} + +SdrTextObj::SdrTextObj(SdrModel& rSdrModel, SdrObjKind eNewTextKind, + const tools::Rectangle& rNewRect) + : SdrAttrObj(rSdrModel) + , mpEditingOutliner(nullptr) + , meTextKind(eNewTextKind) + , maTextEditOffset(Point(0, 0)) + , mbTextFrame(true) + , mbNoShear(true) + , mbTextSizeDirty(false) + , mbInEditMode(false) + , mbDisableAutoWidthOnDragging(false) + , mbTextAnimationAllowed(true) + , mbInDownScale(false) +{ + tools::Rectangle aRectangle(rNewRect); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + + // #i25616# + mbSupportTextIndentingOnLineWidthChange = true; +} + +SdrTextObj::~SdrTextObj() +{ + mxText.clear(); + ImpDeregisterLink(); +} + +void SdrTextObj::FitFrameToTextSize() +{ + ImpJustifyRect(maRectangle); + + SdrText* pText = getActiveText(); + if(pText==nullptr || !pText->GetOutlinerParaObject()) + return; + + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + rOutliner.SetPaperSize(Size(getRectangle().Right() - getRectangle().Left(), getRectangle().Bottom() - getRectangle().Top())); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(*pText->GetOutlinerParaObject()); + Size aNewSize(rOutliner.CalcTextSize()); + rOutliner.Clear(); + aNewSize.AdjustWidth( 1 ); // because of possible rounding errors + aNewSize.AdjustWidth(GetTextLeftDistance()+GetTextRightDistance() ); + aNewSize.AdjustHeight(GetTextUpperDistance()+GetTextLowerDistance() ); + tools::Rectangle aNewRect(getRectangle()); + aNewRect.SetSize(aNewSize); + ImpJustifyRect(aNewRect); + + if (aNewRect != getRectangle()) + SetLogicRect(aNewRect); +} + +void SdrTextObj::NbcSetText(const OUString& rStr) +{ + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + rOutliner.SetStyleSheet( 0, GetStyleSheet()); + rOutliner.SetText(rStr,rOutliner.GetParagraph( 0 )); + std::optional pNewText=rOutliner.CreateParaObject(); + NbcSetOutlinerParaObject(std::move(pNewText)); + mbTextSizeDirty=true; +} + +void SdrTextObj::SetText(const OUString& rStr) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetText(rStr); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrTextObj::NbcSetText(SvStream& rInput, const OUString& rBaseURL, EETextFormat eFormat) +{ + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + rOutliner.SetStyleSheet( 0, GetStyleSheet()); + rOutliner.Read(rInput,rBaseURL,eFormat); + std::optional pNewText=rOutliner.CreateParaObject(); + rOutliner.SetUpdateLayout(true); + Size aSize(rOutliner.CalcTextSize()); + rOutliner.Clear(); + NbcSetOutlinerParaObject(std::move(pNewText)); + maTextSize=aSize; + mbTextSizeDirty=false; +} + +void SdrTextObj::SetText(SvStream& rInput, const OUString& rBaseURL, EETextFormat eFormat) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcSetText(rInput,rBaseURL,eFormat); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +const Size& SdrTextObj::GetTextSize() const +{ + if (mbTextSizeDirty) + { + Size aSiz; + SdrText* pText = getActiveText(); + if( pText && pText->GetOutlinerParaObject ()) + { + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + rOutliner.SetText(*pText->GetOutlinerParaObject()); + rOutliner.SetUpdateLayout(true); + aSiz=rOutliner.CalcTextSize(); + rOutliner.Clear(); + } + // casting to nonconst twice + const_cast(this)->maTextSize = aSiz; + const_cast(this)->mbTextSizeDirty = false; + } + return maTextSize; +} + +bool SdrTextObj::IsAutoGrowHeight() const +{ + if(!mbTextFrame) + return false; // AutoGrow only together with TextFrames + + const SfxItemSet& rSet = GetObjectItemSet(); + bool bRet = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + + if(bRet) + { + SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue(); + + if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide) + { + SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); + + if(eDirection == SdrTextAniDirection::Up || eDirection == SdrTextAniDirection::Down) + { + bRet = false; + } + } + } + return bRet; +} + +bool SdrTextObj::IsAutoGrowWidth() const +{ + if (!mbTextFrame) + return false; // AutoGrow only together with TextFrames + + const SfxItemSet& rSet = GetObjectItemSet(); + bool bRet = rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue(); + + bool bInEditMOde = IsInEditMode(); + + if(!bInEditMOde && bRet) + { + SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue(); + + if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide) + { + SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); + + if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right) + { + bRet = false; + } + } + } + return bRet; +} + +SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust() const +{ + return GetTextHorizontalAdjust(GetObjectItemSet()); +} + +SdrTextHorzAdjust SdrTextObj::GetTextHorizontalAdjust(const SfxItemSet& rSet) const +{ + if(IsContourTextFrame()) + return SDRTEXTHORZADJUST_BLOCK; + + SdrTextHorzAdjust eRet = rSet.Get(SDRATTR_TEXT_HORZADJUST).GetValue(); + + bool bInEditMode = IsInEditMode(); + + if(!bInEditMode && eRet == SDRTEXTHORZADJUST_BLOCK) + { + SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue(); + + if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide) + { + SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); + + if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right) + { + eRet = SDRTEXTHORZADJUST_LEFT; + } + } + } + + return eRet; +} // defaults: BLOCK (justify) for text frame, CENTER for captions of drawing objects + +SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust() const +{ + return GetTextVerticalAdjust(GetObjectItemSet()); +} + +SdrTextVertAdjust SdrTextObj::GetTextVerticalAdjust(const SfxItemSet& rSet) const +{ + if(IsContourTextFrame()) + return SDRTEXTVERTADJUST_TOP; + + // Take care for vertical text animation here + SdrTextVertAdjust eRet = rSet.Get(SDRATTR_TEXT_VERTADJUST).GetValue(); + bool bInEditMode = IsInEditMode(); + + // Take care for vertical text animation here + if(!bInEditMode && eRet == SDRTEXTVERTADJUST_BLOCK) + { + SdrTextAniKind eAniKind = rSet.Get(SDRATTR_TEXT_ANIKIND).GetValue(); + + if(eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide) + { + SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); + + if(eDirection == SdrTextAniDirection::Left || eDirection == SdrTextAniDirection::Right) + { + eRet = SDRTEXTVERTADJUST_TOP; + } + } + } + + return eRet; +} // defaults: TOP for text frame, CENTER for captions of drawing objects + +void SdrTextObj::ImpJustifyRect(tools::Rectangle& rRect) +{ + if (!rRect.IsEmpty()) { + rRect.Normalize(); + if (rRect.Left()==rRect.Right()) rRect.AdjustRight( 1 ); + if (rRect.Top()==rRect.Bottom()) rRect.AdjustBottom( 1 ); + } +} + +void SdrTextObj::ImpCheckShear() +{ + if (mbNoShear && maGeo.m_nShearAngle) + { + maGeo.m_nShearAngle = 0_deg100; + maGeo.mfTanShearAngle = 0; + } +} + +void SdrTextObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + bool bNoTextFrame=!IsTextFrame(); + rInfo.bResizeFreeAllowed=bNoTextFrame || ((maGeo.m_nRotationAngle.get() % 9000) == 0); + rInfo.bResizePropAllowed=true; + rInfo.bRotateFreeAllowed=true; + rInfo.bRotate90Allowed =true; + rInfo.bMirrorFreeAllowed=bNoTextFrame; + rInfo.bMirror45Allowed =bNoTextFrame; + rInfo.bMirror90Allowed =bNoTextFrame; + + // allow transparency + rInfo.bTransparenceAllowed = true; + + rInfo.bShearAllowed =bNoTextFrame; + rInfo.bEdgeRadiusAllowed=true; + bool bCanConv=ImpCanConvTextToCurve(); + rInfo.bCanConvToPath =bCanConv; + rInfo.bCanConvToPoly =bCanConv; + rInfo.bCanConvToPathLineToArea=bCanConv; + rInfo.bCanConvToPolyLineToArea=bCanConv; + rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); +} + +SdrObjKind SdrTextObj::GetObjIdentifier() const +{ + return meTextKind; +} + +bool SdrTextObj::HasTextImpl( SdrOutliner const * pOutliner ) +{ + bool bRet=false; + if(pOutliner) + { + Paragraph* p1stPara=pOutliner->GetParagraph( 0 ); + sal_Int32 nParaCount=pOutliner->GetParagraphCount(); + if(p1stPara==nullptr) + nParaCount=0; + + if(nParaCount==1) + { + // if it is only one paragraph, check if that paragraph is empty + if( pOutliner->GetText(p1stPara).isEmpty() ) + nParaCount = 0; + } + + bRet= nParaCount!=0; + } + return bRet; +} + +void SdrTextObj::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage) +{ + const bool bRemove(pNewPage == nullptr && pOldPage != nullptr); + const bool bInsert(pNewPage != nullptr && pOldPage == nullptr); + const bool bLinked(IsLinkedText()); + + if (bLinked && bRemove) + { + ImpDeregisterLink(); + } + + // call parent + SdrAttrObj::handlePageChange(pOldPage, pNewPage); + + if (bLinked && bInsert) + { + ImpRegisterLink(); + } +} + +void SdrTextObj::NbcSetEckenradius(tools::Long nRad) +{ + SetObjectItem(makeSdrEckenradiusItem(nRad)); +} + +// #115391# This implementation is based on the object size (aRect) and the +// states of IsAutoGrowWidth/Height to correctly set TextMinFrameWidth/Height +void SdrTextObj::AdaptTextMinSize() +{ + if (!mbTextFrame) + // Only do this for text frame. + return; + + if (getSdrModelFromSdrObject().IsPasteResize()) + // Don't do this during paste resize. + return; + + const bool bW = IsAutoGrowWidth(); + const bool bH = IsAutoGrowHeight(); + + if (!bW && !bH) + // No auto grow requested. Bail out. + return; + + SfxItemSetFixed // contains SDRATTR_TEXT_MAXFRAMEWIDTH + aSet(*GetObjectItemSet().GetPool()); + + if(bW) + { + // Set minimum width. + const tools::Long nDist = GetTextLeftDistance() + GetTextRightDistance(); + const tools::Long nW = std::max(0, getRectangle().GetWidth() - 1 - nDist); // text width without margins + + aSet.Put(makeSdrTextMinFrameWidthItem(nW)); + + if(!IsVerticalWriting() && mbDisableAutoWidthOnDragging) + { + mbDisableAutoWidthOnDragging = true; + aSet.Put(makeSdrTextAutoGrowWidthItem(false)); + } + } + + if(bH) + { + // Set Minimum height. + const tools::Long nDist = GetTextUpperDistance() + GetTextLowerDistance(); + const tools::Long nH = std::max(0, getRectangle().GetHeight() - 1 - nDist); // text height without margins + + aSet.Put(makeSdrTextMinFrameHeightItem(nH)); + + if(IsVerticalWriting() && mbDisableAutoWidthOnDragging) + { + mbDisableAutoWidthOnDragging = false; + aSet.Put(makeSdrTextAutoGrowHeightItem(false)); + } + } + + SetObjectItemSet(aSet); +} + +void SdrTextObj::ImpSetContourPolygon( SdrOutliner& rOutliner, tools::Rectangle const & rAnchorRect, bool bLineWidth ) const +{ + basegfx::B2DPolyPolygon aXorPolyPolygon(TakeXorPoly()); + std::optional pContourPolyPolygon; + basegfx::B2DHomMatrix aMatrix(basegfx::utils::createTranslateB2DHomMatrix( + -rAnchorRect.Left(), -rAnchorRect.Top())); + + if(maGeo.m_nRotationAngle) + { + // Unrotate! + aMatrix.rotate(-toRadians(maGeo.m_nRotationAngle)); + } + + aXorPolyPolygon.transform(aMatrix); + + if( bLineWidth ) + { + // Take line width into account. + // When doing the hit test, avoid this. (Performance!) + pContourPolyPolygon.emplace(); + + // test if shadow needs to be avoided for TakeContour() + const SfxItemSet& rSet = GetObjectItemSet(); + bool bShadowOn = rSet.Get(SDRATTR_SHADOW).GetValue(); + + // #i33696# + // Remember TextObject currently set at the DrawOutliner, it WILL be + // replaced during calculating the outline since it uses an own paint + // and that one uses the DrawOutliner, too. + const SdrTextObj* pLastTextObject = rOutliner.GetTextObj(); + + if(bShadowOn) + { + // force shadow off + rtl::Reference pCopy = SdrObject::Clone(*this, getSdrModelFromSdrObject()); + pCopy->SetMergedItem(makeSdrShadowItem(false)); + *pContourPolyPolygon = pCopy->TakeContour(); + } + else + { + *pContourPolyPolygon = TakeContour(); + } + + // #i33696# + // restore remembered text object + if(pLastTextObject != rOutliner.GetTextObj()) + { + rOutliner.SetTextObj(pLastTextObject); + } + + pContourPolyPolygon->transform(aMatrix); + } + + rOutliner.SetPolygon(aXorPolyPolygon, pContourPolyPolygon ? &*pContourPolyPolygon : nullptr); +} + +void SdrTextObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const +{ + rRect = getRectangle(); +} + +// See also: ::getTextAnchorRange in svx/source/sdr/primitive2d/sdrdecompositiontools.cxx +void SdrTextObj::AdjustRectToTextDistance(tools::Rectangle& rAnchorRect) const +{ + const tools::Long nLeftDist = GetTextLeftDistance(); + const tools::Long nRightDist = GetTextRightDistance(); + const tools::Long nUpperDist = GetTextUpperDistance(); + const tools::Long nLowerDist = GetTextLowerDistance(); + if (!IsVerticalWriting()) + { + rAnchorRect.AdjustLeft(nLeftDist); + rAnchorRect.AdjustTop(nUpperDist); + rAnchorRect.AdjustRight(-nRightDist); + rAnchorRect.AdjustBottom(-nLowerDist); + } + else if (IsTopToBottom()) + { + rAnchorRect.AdjustLeft(nLowerDist); + rAnchorRect.AdjustTop(nLeftDist); + rAnchorRect.AdjustRight(-nUpperDist); + rAnchorRect.AdjustBottom(-nRightDist); + } + else + { + rAnchorRect.AdjustLeft(nUpperDist); + rAnchorRect.AdjustTop(nRightDist); + rAnchorRect.AdjustRight(-nLowerDist); + rAnchorRect.AdjustBottom(-nLeftDist); + } + + // Since sizes may be bigger than the object bounds it is necessary to + // justify the rect now. + ImpJustifyRect(rAnchorRect); +} + +void SdrTextObj::TakeTextAnchorRect(tools::Rectangle& rAnchorRect) const +{ + tools::Rectangle aAnkRect(getRectangle()); // the rectangle in which we anchor + bool bFrame=IsTextFrame(); + if (!bFrame) { + TakeUnrotatedSnapRect(aAnkRect); + } + Point aRotateRef(aAnkRect.TopLeft()); + AdjustRectToTextDistance(aAnkRect); + + if (bFrame) { + // TODO: Optimize this. + if (aAnkRect.GetWidth()<2) aAnkRect.SetRight(aAnkRect.Left()+1 ); // minimum size h and v: 2 px + if (aAnkRect.GetHeight()<2) aAnkRect.SetBottom(aAnkRect.Top()+1 ); + } + if (maGeo.m_nRotationAngle) { + Point aTmpPt(aAnkRect.TopLeft()); + RotatePoint(aTmpPt,aRotateRef,maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + aTmpPt-=aAnkRect.TopLeft(); + aAnkRect.Move(aTmpPt.X(),aTmpPt.Y()); + } + rAnchorRect=aAnkRect; +} + +void SdrTextObj::TakeTextRect( SdrOutliner& rOutliner, tools::Rectangle& rTextRect, bool bNoEditText, + tools::Rectangle* pAnchorRect, bool bLineWidth ) const +{ + tools::Rectangle aAnkRect; // the rectangle in which we anchor + TakeTextAnchorRect(aAnkRect); + SdrTextVertAdjust eVAdj=GetTextVerticalAdjust(); + SdrTextHorzAdjust eHAdj=GetTextHorizontalAdjust(); + SdrTextAniKind eAniKind=GetTextAniKind(); + SdrTextAniDirection eAniDirection=GetTextAniDirection(); + + bool bFitToSize(IsFitToSize()); + bool bContourFrame=IsContourTextFrame(); + + bool bFrame=IsTextFrame(); + EEControlBits nStat0=rOutliner.GetControlWord(); + Size aNullSize; + if (!bContourFrame) + { + rOutliner.SetControlWord(nStat0|EEControlBits::AUTOPAGESIZE); + rOutliner.SetMinAutoPaperSize(aNullSize); + rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000)); + } + + if (!bFitToSize && !bContourFrame) + { + tools::Long nAnkWdt=aAnkRect.GetWidth(); + tools::Long nAnkHgt=aAnkRect.GetHeight(); + if (bFrame) + { + tools::Long nWdt=nAnkWdt; + tools::Long nHgt=nAnkHgt; + + bool bInEditMode = IsInEditMode(); + + if (!bInEditMode && (eAniKind==SdrTextAniKind::Scroll || eAniKind==SdrTextAniKind::Alternate || eAniKind==SdrTextAniKind::Slide)) + { + // unlimited paper size for ticker text + if (eAniDirection==SdrTextAniDirection::Left || eAniDirection==SdrTextAniDirection::Right) nWdt=1000000; + if (eAniDirection==SdrTextAniDirection::Up || eAniDirection==SdrTextAniDirection::Down) nHgt=1000000; + } + + bool bChainedFrame = IsChainable(); + // Might be required for overflow check working: do limit height to frame if box is chainable. + if (!bChainedFrame) { + // #i119885# Do not limit/force height to geometrical frame (vice versa for vertical writing) + + if(IsVerticalWriting()) + { + nWdt = 1000000; + } + else + { + nHgt = 1000000; + } + } + + rOutliner.SetMaxAutoPaperSize(Size(nWdt,nHgt)); + } + + // New try with _BLOCK for hor and ver after completely + // supporting full width for vertical text. + if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting()) + { + rOutliner.SetMinAutoPaperSize(Size(nAnkWdt, 0)); + rOutliner.SetMinColumnWrapHeight(nAnkHgt); + } + + if(SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting()) + { + rOutliner.SetMinAutoPaperSize(Size(0, nAnkHgt)); + rOutliner.SetMinColumnWrapHeight(nAnkWdt); + } + } + + rOutliner.SetPaperSize(aNullSize); + if (bContourFrame) + ImpSetContourPolygon( rOutliner, aAnkRect, bLineWidth ); + + // put text into the outliner, if available from the edit outliner + SdrText* pText = getActiveText(); + OutlinerParaObject* pOutlinerParaObject = pText ? pText->GetOutlinerParaObject() : nullptr; + std::optional pPara; + if (mpEditingOutliner && !bNoEditText) + pPara = mpEditingOutliner->CreateParaObject(); + else if (pOutlinerParaObject) + pPara = *pOutlinerParaObject; + + if (pPara) + { + const bool bHitTest(&getSdrModelFromSdrObject().GetHitTestOutliner() == &rOutliner); + const SdrTextObj* pTestObj = rOutliner.GetTextObj(); + + if( !pTestObj || !bHitTest || pTestObj != this || + pTestObj->GetOutlinerParaObject() != pOutlinerParaObject ) + { + if( bHitTest ) // #i33696# take back fix #i27510# + { + rOutliner.SetTextObj( this ); + rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + } + + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(*pPara); + } + } + else + { + rOutliner.SetTextObj( nullptr ); + } + + rOutliner.SetUpdateLayout(true); + rOutliner.SetControlWord(nStat0); + + if( pText ) + pText->CheckPortionInfo(rOutliner); + + Point aTextPos(aAnkRect.TopLeft()); + Size aTextSiz(rOutliner.GetPaperSize()); // GetPaperSize() adds a little tolerance, right? + + // For draw objects containing text correct hor/ver alignment if text is bigger + // than the object itself. Without that correction, the text would always be + // formatted to the left edge (or top edge when vertical) of the draw object. + if(!IsTextFrame()) + { + if(aAnkRect.GetWidth() < aTextSiz.Width() && !IsVerticalWriting()) + { + // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTHORZADJUST_BLOCK == eHAdj) + { + eHAdj = SDRTEXTHORZADJUST_CENTER; + } + } + + if(aAnkRect.GetHeight() < aTextSiz.Height() && IsVerticalWriting()) + { + // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTVERTADJUST_BLOCK == eVAdj) + { + eVAdj = SDRTEXTVERTADJUST_CENTER; + } + } + } + + if (eHAdj==SDRTEXTHORZADJUST_CENTER || eHAdj==SDRTEXTHORZADJUST_RIGHT) + { + tools::Long nFreeWdt=aAnkRect.GetWidth()-aTextSiz.Width(); + if (eHAdj==SDRTEXTHORZADJUST_CENTER) + aTextPos.AdjustX(nFreeWdt/2 ); + if (eHAdj==SDRTEXTHORZADJUST_RIGHT) + aTextPos.AdjustX(nFreeWdt ); + } + if (eVAdj==SDRTEXTVERTADJUST_CENTER || eVAdj==SDRTEXTVERTADJUST_BOTTOM) + { + tools::Long nFreeHgt=aAnkRect.GetHeight()-aTextSiz.Height(); + if (eVAdj==SDRTEXTVERTADJUST_CENTER) + aTextPos.AdjustY(nFreeHgt/2 ); + if (eVAdj==SDRTEXTVERTADJUST_BOTTOM) + aTextPos.AdjustY(nFreeHgt ); + } + if (maGeo.m_nRotationAngle) + RotatePoint(aTextPos,aAnkRect.TopLeft(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + + if (pAnchorRect) + *pAnchorRect=aAnkRect; + + // rTextRect might not be correct in some cases at ContourFrame + rTextRect=tools::Rectangle(aTextPos,aTextSiz); + if (bContourFrame) + rTextRect=aAnkRect; +} + +bool SdrTextObj::CanCreateEditOutlinerParaObject() const +{ + if( HasTextImpl( mpEditingOutliner ) ) + { + return mpEditingOutliner->GetParagraphCount() > 0; + } + return false; +} + +std::optional SdrTextObj::CreateEditOutlinerParaObject() const +{ + std::optional pPara; + if( HasTextImpl( mpEditingOutliner ) ) + { + sal_Int32 nParaCount = mpEditingOutliner->GetParagraphCount(); + pPara = mpEditingOutliner->CreateParaObject(0, nParaCount); + } + return pPara; +} + +void SdrTextObj::ImpSetCharStretching(SdrOutliner& rOutliner, const Size& rTextSize, const Size& rShapeSize, Fraction& rFitXCorrection) +{ + OutputDevice* pOut = rOutliner.GetRefDevice(); + bool bNoStretching(false); + + if(pOut && pOut->GetOutDevType() == OUTDEV_PRINTER) + { + // check whether CharStretching is possible at all + GDIMetaFile* pMtf = pOut->GetConnectMetaFile(); + OUString aTestString(u'J'); + + if(pMtf && (!pMtf->IsRecord() || pMtf->IsPause())) + pMtf = nullptr; + + if(pMtf) + pMtf->Pause(true); + + vcl::Font aOriginalFont(pOut->GetFont()); + vcl::Font aTmpFont( OutputDevice::GetDefaultFont( DefaultFontType::SERIF, LANGUAGE_SYSTEM, GetDefaultFontFlags::OnlyOne ) ); + + aTmpFont.SetFontSize(Size(0,100)); + pOut->SetFont(aTmpFont); + Size aSize1(pOut->GetTextWidth(aTestString), pOut->GetTextHeight()); + aTmpFont.SetFontSize(Size(800,100)); + pOut->SetFont(aTmpFont); + Size aSize2(pOut->GetTextWidth(aTestString), pOut->GetTextHeight()); + pOut->SetFont(aOriginalFont); + + if(pMtf) + pMtf->Pause(false); + + bNoStretching = (aSize1 == aSize2); + +#ifdef _WIN32 + // Windows zooms the font proportionally when using Size(100,500), + // we don't like that. + if(aSize2.Height() >= aSize1.Height() * 2) + { + bNoStretching = true; + } +#endif + } + + rOutliner.setRoundFontSizeToPt(false); + + unsigned nLoopCount=0; + bool bNoMoreLoop = false; + tools::Long nXDiff0=0x7FFFFFFF; + tools::Long nWantWdt=rShapeSize.Width(); + tools::Long nIsWdt=rTextSize.Width(); + if (nIsWdt==0) nIsWdt=1; + + tools::Long nWantHgt=rShapeSize.Height(); + tools::Long nIsHgt=rTextSize.Height(); + if (nIsHgt==0) nIsHgt=1; + + tools::Long nXTolPl=nWantWdt/100; // tolerance: +1% + tools::Long nXTolMi=nWantWdt/25; // tolerance: -4% + tools::Long nXCorr =nWantWdt/20; // correction scale: 5% + + double nX = (nWantWdt * 100.0) / double(nIsWdt); // calculate X stretching + double nY = (nWantHgt * 100.0) / double(nIsHgt); // calculate Y stretching + bool bChkX = true; + if (bNoStretching) + { // might only be possible proportionally + if (nX > nY) + { + nX = nY; + bChkX = false; + } + else + { + nY = nX; + } + } + + while (nLoopCount<5 && !bNoMoreLoop) + { + if (nX < 0.0) + nX = -nX; + if (nX < 1.0) + { + nX = 1.0; + bNoMoreLoop = true; + } + if (nX > 65535.0) + { + nX = 65535.0; + bNoMoreLoop = true; + } + + if (nY < 0.0) + { + nY = -nY; + } + if (nY < 1.0) + { + nY = 1.0; + bNoMoreLoop = true; + } + if (nY > 65535.0) + { + nY = 65535.0; + bNoMoreLoop = true; + } + + // exception, there is no text yet (horizontal case) + if (nIsWdt <= 1) + { + nX = nY; + bNoMoreLoop = true; + } + + // exception, there is no text yet (vertical case) + if (nIsHgt <= 1) + { + nY = nX; + bNoMoreLoop = true; + } + rOutliner.setGlobalScale(nX, nY); + nLoopCount++; + Size aSiz(rOutliner.CalcTextSize()); + tools::Long nXDiff = aSiz.Width() - nWantWdt; + rFitXCorrection=Fraction(nWantWdt,aSiz.Width()); + if (((nXDiff>=nXTolMi || !bChkX) && nXDiff<=nXTolPl) || nXDiff==nXDiff0) { + bNoMoreLoop = true; + } else { + // correct stretching factors + tools::Long nMul = nWantWdt; + tools::Long nDiv = aSiz.Width(); + if (std::abs(nXDiff) <= 2 * nXCorr) + { + if (nMul > nDiv) + nDiv += (nMul - nDiv) / 2.0; // but only add half of what we calculated, + else + nMul += (nDiv - nMul) / 2.0;// because the EditEngine calculates wrongly later on + } + nX = nX * double(nMul) / double(nDiv); + if (bNoStretching) + nY = nX; + } + nXDiff0 = nXDiff; + } +} + +OUString SdrTextObj::TakeObjNameSingul() const +{ + OUString aStr; + + switch(meTextKind) + { + case SdrObjKind::OutlineText: + { + aStr = SvxResId(STR_ObjNameSingulOUTLINETEXT); + break; + } + + case SdrObjKind::TitleText : + { + aStr = SvxResId(STR_ObjNameSingulTITLETEXT); + break; + } + + default: + { + if(IsLinkedText()) + aStr = SvxResId(STR_ObjNameSingulTEXTLNK); + else + aStr = SvxResId(STR_ObjNameSingulTEXT); + break; + } + } + + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if(pOutlinerParaObject && meTextKind != SdrObjKind::OutlineText) + { + // shouldn't currently cause any problems at OUTLINETEXT + OUString aStr2(comphelper::string::stripStart(pOutlinerParaObject->GetTextObject().GetText(0), ' ')); + + // avoid non expanded text portions in object name + // (second condition is new) + if(!aStr2.isEmpty() && aStr2.indexOf(u'\x00FF') == -1) + { + // space between ResStr and content text + aStr += " \'"; + + if(aStr2.getLength() > 10) + { + aStr2 = OUString::Concat(aStr2.subView(0, 8)) + "..."; + } + + aStr += aStr2 + "\'"; + } + } + + OUString sName(aStr); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrTextObj::TakeObjNamePlural() const +{ + OUString sName; + switch (meTextKind) + { + case SdrObjKind::OutlineText: sName=SvxResId(STR_ObjNamePluralOUTLINETEXT); break; + case SdrObjKind::TitleText : sName=SvxResId(STR_ObjNamePluralTITLETEXT); break; + default: { + if (IsLinkedText()) { + sName=SvxResId(STR_ObjNamePluralTEXTLNK); + } else { + sName=SvxResId(STR_ObjNamePluralTEXT); + } + } break; + } // switch + return sName; +} + +rtl::Reference SdrTextObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrTextObj(rTargetModel, *this); +} + +basegfx::B2DPolyPolygon SdrTextObj::TakeXorPoly() const +{ + tools::Polygon aPol(getRectangle()); + if (maGeo.m_nShearAngle) + ShearPoly(aPol, getRectangle().TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) + RotatePoly(aPol, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + basegfx::B2DPolyPolygon aRetval; + aRetval.append(aPol.getB2DPolygon()); + return aRetval; +} + +basegfx::B2DPolyPolygon SdrTextObj::TakeContour() const +{ + basegfx::B2DPolyPolygon aRetval(SdrAttrObj::TakeContour()); + + // and now add the BoundRect of the text, if necessary + if ( GetOutlinerParaObject() && !IsFontwork() && !IsContourTextFrame() ) + { + // using Clone()-Paint() strategy inside TakeContour() leaves a destroyed + // SdrObject as pointer in DrawOutliner. Set *this again in fetching the outliner + // in every case + SdrOutliner& rOutliner=ImpGetDrawOutliner(); + + tools::Rectangle aAnchor2; + tools::Rectangle aR; + TakeTextRect(rOutliner,aR,false,&aAnchor2); + rOutliner.Clear(); + bool bFitToSize(IsFitToSize()); + if (bFitToSize) aR=aAnchor2; + tools::Polygon aPol(aR); + if (maGeo.m_nRotationAngle) RotatePoly(aPol,aR.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + aRetval.append(aPol.getB2DPolygon()); + } + + return aRetval; +} + +void SdrTextObj::RecalcSnapRect() +{ + if (maGeo.m_nRotationAngle || maGeo.m_nShearAngle) + { + maSnapRect = Rect2Poly(getRectangle(), maGeo).GetBoundRect(); + } else { + maSnapRect = getRectangle(); + } +} + +sal_uInt32 SdrTextObj::GetSnapPointCount() const +{ + return 4; +} + +Point SdrTextObj::GetSnapPoint(sal_uInt32 i) const +{ + Point aP; + auto aRectangle = getRectangle(); + switch (i) { + case 0: aP = aRectangle.TopLeft(); break; + case 1: aP = aRectangle.TopRight(); break; + case 2: aP = aRectangle.BottomLeft(); break; + case 3: aP = aRectangle.BottomRight(); break; + default: aP = aRectangle.Center(); break; + } + if (maGeo.m_nShearAngle) + ShearPoint(aP, aRectangle.TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) + RotatePoint(aP, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + return aP; +} + +// Extracted from ImpGetDrawOutliner() +void SdrTextObj::ImpInitDrawOutliner( SdrOutliner& rOutl ) const +{ + rOutl.SetUpdateLayout(false); + OutlinerMode nOutlinerMode = OutlinerMode::OutlineObject; + if ( !IsOutlText() ) + nOutlinerMode = OutlinerMode::TextObject; + rOutl.Init( nOutlinerMode ); + + rOutl.setGlobalScale(100.0, 100.0, 100.0, 100.0); + + EEControlBits nStat=rOutl.GetControlWord(); + nStat &= ~EEControlBits(EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE); + rOutl.SetControlWord(nStat); + Size aMaxSize(100000,100000); + rOutl.SetMinAutoPaperSize(Size()); + rOutl.SetMaxAutoPaperSize(aMaxSize); + rOutl.SetPaperSize(aMaxSize); + rOutl.ClearPolygon(); +} + +SdrOutliner& SdrTextObj::ImpGetDrawOutliner() const +{ + SdrOutliner& rOutl(getSdrModelFromSdrObject().GetDrawOutliner(this)); + + // Code extracted to ImpInitDrawOutliner() + ImpInitDrawOutliner( rOutl ); + + return rOutl; +} + +// Extracted from Paint() +void SdrTextObj::ImpSetupDrawOutlinerForPaint( bool bContourFrame, + SdrOutliner& rOutliner, + tools::Rectangle& rTextRect, + tools::Rectangle& rAnchorRect, + tools::Rectangle& rPaintRect, + Fraction& rFitXCorrection ) const +{ + if (!bContourFrame) + { + // FitToSize can't be used together with ContourFrame for now + if (IsFitToSize() || IsAutoFit()) + { + EEControlBits nStat=rOutliner.GetControlWord(); + nStat|=EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE; + rOutliner.SetControlWord(nStat); + } + } + rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + TakeTextRect(rOutliner, rTextRect, false, &rAnchorRect); + rPaintRect = rTextRect; + + if (bContourFrame) + return; + + // FitToSize can't be used together with ContourFrame for now + if (IsFitToSize()) + { + ImpSetCharStretching(rOutliner,rTextRect.GetSize(),rAnchorRect.GetSize(),rFitXCorrection); + rPaintRect=rAnchorRect; + } + else if (IsAutoFit()) + { + ImpAutoFitText(rOutliner); + } +} + +double SdrTextObj::GetFontScale() const +{ + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + // This eventually calls ImpAutoFitText + UpdateOutlinerFormatting(rOutliner, o3tl::temporary(tools::Rectangle())); + + double fScaleY; + rOutliner.getGlobalScale(o3tl::temporary(double()), fScaleY, o3tl::temporary(double()), o3tl::temporary(double())); + return fScaleY; +} + +double SdrTextObj::GetSpacingScale() const +{ + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + // This eventually calls ImpAutoFitText + UpdateOutlinerFormatting(rOutliner, o3tl::temporary(tools::Rectangle())); + + double fSpacingScaleY; + rOutliner.getGlobalScale(o3tl::temporary(double()), o3tl::temporary(double()), o3tl::temporary(double()), fSpacingScaleY); + return fSpacingScaleY; +} + +void SdrTextObj::ImpAutoFitText( SdrOutliner& rOutliner ) const +{ + const Size aShapeSize=GetSnapRect().GetSize(); + ImpAutoFitText( rOutliner, + Size(aShapeSize.Width()-GetTextLeftDistance()-GetTextRightDistance(), + aShapeSize.Height()-GetTextUpperDistance()-GetTextLowerDistance()), + IsVerticalWriting() ); +} + +void SdrTextObj::ImpAutoFitText(SdrOutliner& rOutliner, const Size& rTextSize, + bool bIsVerticalWriting) const +{ + autoFitTextForCompatibility(rOutliner, rTextSize, bIsVerticalWriting); +} + +void SdrTextObj::autoFitTextForCompatibility(SdrOutliner& rOutliner, const Size& rTextBoxSize, bool bIsVerticalWriting) const +{ + rOutliner.setRoundFontSizeToPt(true); + + const SdrTextFitToSizeTypeItem& rItem = GetObjectItem(SDRATTR_TEXT_FITTOSIZE); + double fMaxScale = rItem.GetMaxScale(); + if (fMaxScale > 0.0) + { + rOutliner.setGlobalScale(fMaxScale, fMaxScale, 100.0, 100.0); + } + else + { + fMaxScale = 100.0; + } + + Size aCurrentTextBoxSize = rOutliner.CalcTextSizeNTP(); + if (aCurrentTextBoxSize.Height() == 0) + return; + + tools::Long nExtendTextBoxBy = -50; + aCurrentTextBoxSize.extendBy(0, nExtendTextBoxBy); + double fCurrentFitFactor = 1.0; + + if (bIsVerticalWriting) + fCurrentFitFactor = double(rTextBoxSize.Width()) / aCurrentTextBoxSize.Width(); + else + fCurrentFitFactor = double(rTextBoxSize.Height()) / aCurrentTextBoxSize.Height(); + + double fInitialFontScaleY = 0.0; + double fInitialSpacing = 0.0; + rOutliner.getGlobalScale(o3tl::temporary(double()), fInitialFontScaleY, o3tl::temporary(double()), fInitialSpacing); + + if (fCurrentFitFactor >= 1.0 && fInitialFontScaleY >= 100.0 && fInitialSpacing >= 100.0) + return; + + sal_Int32 nFontHeight = GetObjectItemSet().Get(EE_CHAR_FONTHEIGHT).GetHeight(); + + double fFontHeightPt = o3tl::convert(double(nFontHeight), o3tl::Length::mm100, o3tl::Length::pt); + double fMinY = 0.0; + double fMaxY = fMaxScale; + + double fBestFontScale = 0.0; + double fBestSpacing = 100.0; + double fBestFitFactor = fCurrentFitFactor; + + if (fCurrentFitFactor >= 1.0) + { + fMinY = fInitialFontScaleY; + fBestFontScale = fInitialFontScaleY; + fBestSpacing = fInitialSpacing; + fBestFitFactor = fCurrentFitFactor; + } + else + { + fMaxY = std::min(fInitialFontScaleY, fMaxScale); + } + + double fInTheMidle = 0.5; + + int iteration = 0; + double fFitFactorTarget = 1.00; + + while (iteration < 10) + { + iteration++; + double fScaleY = fMinY + (fMaxY - fMinY) * fInTheMidle; + + double fScaledFontHeight = fFontHeightPt * (fScaleY / 100.0); + double fRoundedScaledFontHeight = std::floor(fScaledFontHeight * 10.0) / 10.0; + double fCurrentFontScale = (fRoundedScaledFontHeight / fFontHeightPt) * 100.0; + + fCurrentFitFactor = 0.0; // reset fit factor; + + for (double fCurrentSpacing : {100.0, 90.0, 80.0}) + { + if (fCurrentFitFactor >= fFitFactorTarget) + continue; + + rOutliner.setGlobalScale(fCurrentFontScale, fCurrentFontScale, 100.0, fCurrentSpacing); + + aCurrentTextBoxSize = rOutliner.CalcTextSizeNTP(); + aCurrentTextBoxSize.extendBy(0, nExtendTextBoxBy); + if (bIsVerticalWriting) + fCurrentFitFactor = double(rTextBoxSize.Width()) / aCurrentTextBoxSize.Width(); + else + fCurrentFitFactor = double(rTextBoxSize.Height()) / aCurrentTextBoxSize.Height(); + + + if (fCurrentSpacing == 100.0) + { + if (fCurrentFitFactor > fFitFactorTarget) + fMinY = fCurrentFontScale; + else + fMaxY = fCurrentFontScale; + } + + if ((fBestFitFactor < fFitFactorTarget && fCurrentFitFactor > fBestFitFactor) + || (fCurrentFitFactor >= fFitFactorTarget && fCurrentFitFactor < fBestFitFactor)) + { + fBestFontScale = fCurrentFontScale; + fBestSpacing = fCurrentSpacing; + fBestFitFactor = fCurrentFitFactor; + } + } + } + rOutliner.setGlobalScale(fBestFontScale, fBestFontScale, 100.0, fBestSpacing); +} + +void SdrTextObj::SetupOutlinerFormatting( SdrOutliner& rOutl, tools::Rectangle& rPaintRect ) const +{ + ImpInitDrawOutliner( rOutl ); + UpdateOutlinerFormatting( rOutl, rPaintRect ); +} + +void SdrTextObj::UpdateOutlinerFormatting( SdrOutliner& rOutl, tools::Rectangle& rPaintRect ) const +{ + tools::Rectangle aTextRect; + tools::Rectangle aAnchorRect; + Fraction aFitXCorrection(1,1); + + const bool bContourFrame(IsContourTextFrame()); + const MapMode aMapMode(getSdrModelFromSdrObject().GetScaleUnit()); + + rOutl.SetRefMapMode(aMapMode); + ImpSetupDrawOutlinerForPaint( + bContourFrame, + rOutl, + aTextRect, + aAnchorRect, + rPaintRect, + aFitXCorrection); +} + + +OutlinerParaObject* SdrTextObj::GetOutlinerParaObject() const +{ + SdrText* pText = getActiveText(); + if( pText ) + return pText->GetOutlinerParaObject(); + else + return nullptr; +} + +void SdrTextObj::NbcSetOutlinerParaObject(std::optional pTextObject) +{ + NbcSetOutlinerParaObjectForText( std::move(pTextObject), getActiveText() ); +} + +namespace +{ + bool IsAutoGrow(const SdrTextObj& rObj) + { + bool bAutoGrow = rObj.IsAutoGrowHeight() || rObj.IsAutoGrowWidth(); + return bAutoGrow && !utl::ConfigManager::IsFuzzing(); + } +} + +void SdrTextObj::NbcSetOutlinerParaObjectForText( std::optional pTextObject, SdrText* pText ) +{ + if( pText ) + pText->SetOutlinerParaObject( std::move(pTextObject) ); + + if (pText && pText->GetOutlinerParaObject()) + { + SvxWritingModeItem aWritingMode(pText->GetOutlinerParaObject()->IsEffectivelyVertical() && pText->GetOutlinerParaObject()->IsTopToBottom() + ? css::text::WritingMode_TB_RL + : css::text::WritingMode_LR_TB, + SDRATTR_TEXTDIRECTION); + GetProperties().SetObjectItemDirect(aWritingMode); + } + + SetTextSizeDirty(); + if (IsTextFrame() && IsAutoGrow(*this)) + { // adapt text frame! + NbcAdjustTextFrameWidthAndHeight(); + } + if (!IsTextFrame()) + { + // the SnapRect keeps its size + SetBoundAndSnapRectsDirty(true); + } + + // always invalidate BoundRect on change + SetBoundRectDirty(); + ActionChanged(); + + ImpSetTextStyleSheetListeners(); +} + +void SdrTextObj::NbcReformatText() +{ + SdrText* pText = getActiveText(); + if( !(pText && pText->GetOutlinerParaObject()) ) + return; + + pText->ReformatText(); + if (mbTextFrame) + { + NbcAdjustTextFrameWidthAndHeight(); + } + else + { + // the SnapRect keeps its size + SetBoundRectDirty(); + SetBoundAndSnapRectsDirty(/*bNotMyself*/true); + } + SetTextSizeDirty(); + ActionChanged(); + // i22396 + // Necessary here since we have no compare operator at the outliner + // para object which may detect changes regarding the combination + // of outliner para data and configuration (e.g., change of + // formatting of text numerals) + GetViewContact().flushViewObjectContacts(false); +} + +std::unique_ptr SdrTextObj::NewGeoData() const +{ + return std::make_unique(); +} + +void SdrTextObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + SdrAttrObj::SaveGeoData(rGeo); + SdrTextObjGeoData& rTGeo=static_cast(rGeo); + rTGeo.maRect = getRectangle(); + rTGeo.maGeo = maGeo; +} + +void SdrTextObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ // RectsDirty is called by SdrObject + SdrAttrObj::RestoreGeoData(rGeo); + const SdrTextObjGeoData& rTGeo=static_cast(rGeo); + NbcSetLogicRect(rTGeo.maRect); + maGeo = rTGeo.maGeo; + SetTextSizeDirty(); +} + +drawing::TextFitToSizeType SdrTextObj::GetFitToSize() const +{ + drawing::TextFitToSizeType eType = drawing::TextFitToSizeType_NONE; + + if(!IsAutoGrowWidth()) + eType = GetObjectItem(SDRATTR_TEXT_FITTOSIZE).GetValue(); + + return eType; +} + +const tools::Rectangle& SdrTextObj::GetGeoRect() const +{ + return getRectangle(); +} + +void SdrTextObj::ForceOutlinerParaObject() +{ + SdrText* pText = getActiveText(); + if( pText && (pText->GetOutlinerParaObject() == nullptr) ) + { + OutlinerMode nOutlMode = OutlinerMode::TextObject; + if( IsTextFrame() && meTextKind == SdrObjKind::OutlineText ) + nOutlMode = OutlinerMode::OutlineObject; + + pText->ForceOutlinerParaObject( nOutlMode ); + } +} + +TextChain *SdrTextObj::GetTextChain() const +{ + //if (!IsChainable()) + // return NULL; + + return getSdrModelFromSdrObject().GetTextChain(); +} + +bool SdrTextObj::IsVerticalWriting() const +{ + if(mpEditingOutliner) + { + return mpEditingOutliner->IsVertical(); + } + + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if(pOutlinerParaObject) + { + return pOutlinerParaObject->IsEffectivelyVertical(); + } + + return false; +} + +void SdrTextObj::SetVerticalWriting(bool bVertical) +{ + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + + if( !pOutlinerParaObject && bVertical ) + { + // we only need to force an outliner para object if the default of + // horizontal text is changed + ForceOutlinerParaObject(); + pOutlinerParaObject = GetOutlinerParaObject(); + } + + if (!pOutlinerParaObject || + (pOutlinerParaObject->IsEffectivelyVertical() == bVertical)) + return; + + // get item settings + const SfxItemSet& rSet = GetObjectItemSet(); + bool bAutoGrowWidth = rSet.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue(); + bool bAutoGrowHeight = rSet.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + + // Also exchange hor/ver adjust items + SdrTextHorzAdjust eHorz = rSet.Get(SDRATTR_TEXT_HORZADJUST).GetValue(); + SdrTextVertAdjust eVert = rSet.Get(SDRATTR_TEXT_VERTADJUST).GetValue(); + + // rescue object size + tools::Rectangle aObjectRect = GetSnapRect(); + + // prepare ItemSet to set exchanged width and height items + SfxItemSetFixed aNewSet(*rSet.GetPool()); + + aNewSet.Put(rSet); + aNewSet.Put(makeSdrTextAutoGrowWidthItem(bAutoGrowHeight)); + aNewSet.Put(makeSdrTextAutoGrowHeightItem(bAutoGrowWidth)); + + // Exchange horz and vert adjusts + switch (eVert) + { + case SDRTEXTVERTADJUST_TOP: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT)); break; + case SDRTEXTVERTADJUST_CENTER: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); break; + case SDRTEXTVERTADJUST_BOTTOM: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); break; + case SDRTEXTVERTADJUST_BLOCK: aNewSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_BLOCK)); break; + } + switch (eHorz) + { + case SDRTEXTHORZADJUST_LEFT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM)); break; + case SDRTEXTHORZADJUST_CENTER: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); break; + case SDRTEXTHORZADJUST_RIGHT: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP)); break; + case SDRTEXTHORZADJUST_BLOCK: aNewSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK)); break; + } + + SetObjectItemSet(aNewSet); + + pOutlinerParaObject = GetOutlinerParaObject(); + if (pOutlinerParaObject) + { + // set ParaObject orientation accordingly + pOutlinerParaObject->SetVertical(bVertical); + } + + // restore object size + SetSnapRect(aObjectRect); +} + +bool SdrTextObj::IsTopToBottom() const +{ + if (mpEditingOutliner) + return mpEditingOutliner->IsTopToBottom(); + + if (OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject()) + return pOutlinerParaObject->IsTopToBottom(); + + return false; +} + +// transformation interface for StarOfficeAPI. This implements support for +// homogeneous 3x3 matrices containing the transformation of the SdrObject. At the +// moment it contains a shearX, rotation and translation, but for setting all linear +// transforms like Scale, ShearX, ShearY, Rotate and Translate are supported. + + +// gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon +// with the base geometry and returns TRUE. Otherwise it returns FALSE. +bool SdrTextObj::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const +{ + // get turn and shear + double fRotate = toRadians(maGeo.m_nRotationAngle); + double fShearX = toRadians(maGeo.m_nShearAngle); + + // get aRect, this is the unrotated snaprect + tools::Rectangle aRectangle(getRectangle()); + + // fill other values + basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight()); + basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top()); + + // position maybe relative to anchorpos, convert + if( getSdrModelFromSdrObject().IsWriter() ) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build matrix + rMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, + basegfx::fTools::equalZero(fShearX) ? 0.0 : tan(fShearX), + basegfx::fTools::equalZero(fRotate) ? 0.0 : -fRotate, + aTranslate); + + return false; +} + +// sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix. +// If it's an SdrPathObj it will use the provided geometry information. The Polygon has +// to use (0,0) as upper left and will be scaled to the given size in the matrix. +void SdrTextObj::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/) +{ + // break up matrix + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate(0.0); + double fShearX(0.0); + rMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // flip? + bool bFlipX = aScale.getX() < 0.0, + bFlipY = aScale.getY() < 0.0; + if (bFlipX) + { + aScale.setX(fabs(aScale.getX())); + } + if (bFlipY) + { + aScale.setY(fabs(aScale.getY())); + } + + // reset object shear and rotations + maGeo.m_nRotationAngle = 0_deg100; + maGeo.RecalcSinCos(); + maGeo.m_nShearAngle = 0_deg100; + maGeo.RecalcTan(); + + // if anchor is used, make position relative to it + if( getSdrModelFromSdrObject().IsWriter() ) + { + if(GetAnchorPos().X() || GetAnchorPos().Y()) + { + aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y()); + } + } + + // build and set BaseRect (use scale) + Size aSize(FRound(aScale.getX()), FRound(aScale.getY())); + tools::Rectangle aBaseRect(Point(), aSize); + SetSnapRect(aBaseRect); + + // flip? + if (bFlipX) + { + Mirror(Point(), Point(0, 1)); + } + if (bFlipY) + { + Mirror(Point(), Point(1, 0)); + } + + // shear? + if(!basegfx::fTools::equalZero(fShearX)) + { + GeoStat aGeoStat; + aGeoStat.m_nShearAngle = Degree100(FRound(basegfx::rad2deg<100>(atan(fShearX)))); + aGeoStat.RecalcTan(); + Shear(Point(), aGeoStat.m_nShearAngle, aGeoStat.mfTanShearAngle, false); + } + + // rotation? + if(!basegfx::fTools::equalZero(fRotate)) + { + GeoStat aGeoStat; + + // #i78696# + // fRotate is matematically correct, but aGeoStat.nRotationAngle is + // mirrored -> mirror value here + aGeoStat.m_nRotationAngle = NormAngle36000(Degree100(FRound(-basegfx::rad2deg<100>(fRotate)))); + aGeoStat.RecalcSinCos(); + Rotate(Point(), aGeoStat.m_nRotationAngle, aGeoStat.mfSinRotationAngle, aGeoStat.mfCosRotationAngle); + } + + // translate? + if(!aTranslate.equalZero()) + { + Move(Size(FRound(aTranslate.getX()), FRound(aTranslate.getY()))); + } +} + +bool SdrTextObj::IsReallyEdited() const +{ + return mpEditingOutliner && mpEditingOutliner->IsModified(); +} + +// moved inlines here form hxx + +tools::Long SdrTextObj::GetEckenradius() const +{ + return GetObjectItemSet().Get(SDRATTR_CORNER_RADIUS).GetValue(); +} + +tools::Long SdrTextObj::GetMinTextFrameHeight() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEHEIGHT).GetValue(); +} + +tools::Long SdrTextObj::GetMaxTextFrameHeight() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEHEIGHT).GetValue(); +} + +tools::Long SdrTextObj::GetMinTextFrameWidth() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_MINFRAMEWIDTH).GetValue(); +} + +tools::Long SdrTextObj::GetMaxTextFrameWidth() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_MAXFRAMEWIDTH).GetValue(); +} + +bool SdrTextObj::IsFontwork() const +{ + return !mbTextFrame // Default is FALSE + && GetObjectItemSet().Get(XATTR_FORMTXTSTYLE).GetValue() != XFormTextStyle::NONE; +} + +bool SdrTextObj::IsHideContour() const +{ + return !mbTextFrame // Default is: no, don't HideContour; HideContour not together with TextFrames + && GetObjectItemSet().Get(XATTR_FORMTXTHIDEFORM).GetValue(); +} + +bool SdrTextObj::IsContourTextFrame() const +{ + return !mbTextFrame // ContourFrame not together with normal TextFrames + && GetObjectItemSet().Get(SDRATTR_TEXT_CONTOURFRAME).GetValue(); +} + +tools::Long SdrTextObj::GetTextLeftDistance() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_LEFTDIST).GetValue(); +} + +tools::Long SdrTextObj::GetTextRightDistance() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_RIGHTDIST).GetValue(); +} + +tools::Long SdrTextObj::GetTextUpperDistance() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_UPPERDIST).GetValue(); +} + +tools::Long SdrTextObj::GetTextLowerDistance() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_LOWERDIST).GetValue(); +} + +SdrTextAniKind SdrTextObj::GetTextAniKind() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_ANIKIND).GetValue(); +} + +SdrTextAniDirection SdrTextObj::GetTextAniDirection() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); +} + +bool SdrTextObj::HasTextColumnsNumber() const +{ + return GetObjectItemSet().HasItem(SDRATTR_TEXTCOLUMNS_NUMBER); +} + +sal_Int16 SdrTextObj::GetTextColumnsNumber() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXTCOLUMNS_NUMBER).GetValue(); +} + +void SdrTextObj::SetTextColumnsNumber(sal_Int16 nColumns) +{ + SetObjectItem(SfxInt16Item(SDRATTR_TEXTCOLUMNS_NUMBER, nColumns)); +} + +bool SdrTextObj::HasTextColumnsSpacing() const +{ + return GetObjectItemSet().HasItem(SDRATTR_TEXTCOLUMNS_SPACING); +} + +sal_Int32 SdrTextObj::GetTextColumnsSpacing() const +{ + return GetObjectItemSet().Get(SDRATTR_TEXTCOLUMNS_SPACING).GetValue(); +} + +void SdrTextObj::SetTextColumnsSpacing(sal_Int32 nSpacing) +{ + SetObjectItem(SdrMetricItem(SDRATTR_TEXTCOLUMNS_SPACING, nSpacing)); +} + +// Get necessary data for text scroll animation. ATM base it on a Text-Metafile and a +// painting rectangle. Rotation is excluded from the returned values. +GDIMetaFile* SdrTextObj::GetTextScrollMetaFileAndRectangle( + tools::Rectangle& rScrollRectangle, tools::Rectangle& rPaintRectangle) +{ + GDIMetaFile* pRetval = nullptr; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + tools::Rectangle aTextRect; + tools::Rectangle aAnchorRect; + tools::Rectangle aPaintRect; + Fraction aFitXCorrection(1,1); + bool bContourFrame(IsContourTextFrame()); + + // get outliner set up. To avoid getting a somehow rotated MetaFile, + // temporarily disable object rotation. + Degree100 nAngle(maGeo.m_nRotationAngle); + maGeo.m_nRotationAngle = 0_deg100; + ImpSetupDrawOutlinerForPaint( bContourFrame, rOutliner, aTextRect, aAnchorRect, aPaintRect, aFitXCorrection ); + maGeo.m_nRotationAngle = nAngle; + + tools::Rectangle aScrollFrameRect(aPaintRect); + const SfxItemSet& rSet = GetObjectItemSet(); + SdrTextAniDirection eDirection = rSet.Get(SDRATTR_TEXT_ANIDIRECTION).GetValue(); + + if(SdrTextAniDirection::Left == eDirection || SdrTextAniDirection::Right == eDirection) + { + aScrollFrameRect.SetLeft( aAnchorRect.Left() ); + aScrollFrameRect.SetRight( aAnchorRect.Right() ); + } + + if(SdrTextAniDirection::Up == eDirection || SdrTextAniDirection::Down == eDirection) + { + aScrollFrameRect.SetTop( aAnchorRect.Top() ); + aScrollFrameRect.SetBottom( aAnchorRect.Bottom() ); + } + + // create the MetaFile + pRetval = new GDIMetaFile; + ScopedVclPtrInstance< VirtualDevice > pBlackHole; + pBlackHole->EnableOutput(false); + pRetval->Record(pBlackHole); + Point aPaintPos = aPaintRect.TopLeft(); + + rOutliner.Draw(*pBlackHole, aPaintPos); + + pRetval->Stop(); + pRetval->WindStart(); + + // return PaintRectanglePixel and pRetval; + rScrollRectangle = aScrollFrameRect; + rPaintRectangle = aPaintRect; + + return pRetval; +} + +// Access to TextAnimationAllowed flag +bool SdrTextObj::IsAutoFit() const +{ + return GetFitToSize() == drawing::TextFitToSizeType_AUTOFIT; +} + +bool SdrTextObj::IsFitToSize() const +{ + const drawing::TextFitToSizeType eFit = GetFitToSize(); + return (eFit == drawing::TextFitToSizeType_PROPORTIONAL + || eFit == drawing::TextFitToSizeType_ALLLINES); +} + +void SdrTextObj::SetTextAnimationAllowed(bool bNew) +{ + if(mbTextAnimationAllowed != bNew) + { + mbTextAnimationAllowed = bNew; + ActionChanged(); + } +} + +/** called from the SdrObjEditView during text edit when the status of the edit outliner changes */ +void SdrTextObj::onEditOutlinerStatusEvent( EditStatus* pEditStatus ) +{ + const EditStatusFlags nStat = pEditStatus->GetStatusWord(); + const bool bGrowX = bool(nStat & EditStatusFlags::TEXTWIDTHCHANGED); + const bool bGrowY = bool(nStat & EditStatusFlags::TextHeightChanged); + if(!(mbTextFrame && (bGrowX || bGrowY))) + return; + + if ((bGrowX && IsAutoGrowWidth()) || (bGrowY && IsAutoGrowHeight())) + { + AdjustTextFrameWidthAndHeight(); + } + else if ( (IsAutoFit() || IsFitToSize()) && !mbInDownScale) + { + assert(mpEditingOutliner); + mbInDownScale = true; + + // sucks that we cannot disable paints via + // mpEditingOutliner->SetUpdateMode(FALSE) - but EditEngine skips + // formatting as well, then. + ImpAutoFitText(*mpEditingOutliner); + mbInDownScale = false; + } +} + +/* Begin chaining code */ + +// XXX: Make it a method somewhere? +static SdrObject *ImpGetObjByName(SdrObjList const *pObjList, std::u16string_view aObjName) +{ + // scan the whole list + for (const rtl::Reference& pCurObj : *pObjList) + if (pCurObj->GetName() == aObjName) + return pCurObj.get(); + // not found + return nullptr; +} + +// XXX: Make it a (private) method of SdrTextObj +static void ImpUpdateChainLinks(SdrTextObj *pTextObj, std::u16string_view aNextLinkName) +{ + // XXX: Current implementation constraints text boxes to be on the same page + + // No next link + if (aNextLinkName.empty()) { + pTextObj->SetNextLinkInChain(nullptr); + return; + } + + SdrPage *pPage(pTextObj->getSdrPageFromSdrObject()); + assert(pPage); + SdrTextObj *pNextTextObj = DynCastSdrTextObj + (ImpGetObjByName(pPage, aNextLinkName)); + if (!pNextTextObj) { + SAL_INFO("svx.chaining", "[CHAINING] Can't find object as next link."); + return; + } + + pTextObj->SetNextLinkInChain(pNextTextObj); +} + +bool SdrTextObj::IsChainable() const +{ + // Read it as item + const SfxItemSet& rSet = GetObjectItemSet(); + OUString aNextLinkName = rSet.Get(SDRATTR_TEXT_CHAINNEXTNAME).GetValue(); + + // Update links if any inconsistency is found + bool bNextLinkUnsetYet = !aNextLinkName.isEmpty() && !mpNextInChain; + bool bInconsistentNextLink = mpNextInChain && mpNextInChain->GetName() != aNextLinkName; + // if the link is not set despite there should be one OR if it has changed + if (bNextLinkUnsetYet || bInconsistentNextLink) { + ImpUpdateChainLinks(const_cast(this), aNextLinkName); + } + + return !aNextLinkName.isEmpty(); // XXX: Should we also check for GetNilChainingEvent? (see old code below) + +/* + // Check that no overflow is going on + if (!GetTextChain() || GetTextChain()->GetNilChainingEvent(this)) + return false; +*/ +} + +void SdrTextObj::onChainingEvent() +{ + if (!mpEditingOutliner) + return; + + // Outliner for text transfer + SdrOutliner &aDrawOutliner = ImpGetDrawOutliner(); + + EditingTextChainFlow aTxtChainFlow(this); + aTxtChainFlow.CheckForFlowEvents(mpEditingOutliner); + + if (aTxtChainFlow.IsOverflow()) { + SAL_INFO("svx.chaining", "[CHAINING] Overflow going on"); + // One outliner is for non-overflowing text, the other for overflowing text + // We remove text directly from the editing outliner + aTxtChainFlow.ExecuteOverflow(mpEditingOutliner, &aDrawOutliner); + } else if (aTxtChainFlow.IsUnderflow()) { + SAL_INFO("svx.chaining", "[CHAINING] Underflow going on"); + // underflow-induced overflow + aTxtChainFlow.ExecuteUnderflow(&aDrawOutliner); + bool bIsOverflowFromUnderflow = aTxtChainFlow.IsOverflow(); + // handle overflow + if (bIsOverflowFromUnderflow) { + SAL_INFO("svx.chaining", "[CHAINING] Overflow going on (underflow induced)"); + // prevents infinite loops when setting text for editing outliner + aTxtChainFlow.ExecuteOverflow(&aDrawOutliner, &aDrawOutliner); + } + } +} + +SdrTextObj* SdrTextObj::GetNextLinkInChain() const +{ + /* + if (GetTextChain()) + return GetTextChain()->GetNextLink(this); + + return NULL; + */ + + return mpNextInChain; +} + +void SdrTextObj::SetNextLinkInChain(SdrTextObj *pNextObj) +{ + // Basically a doubly linked list implementation + + SdrTextObj *pOldNextObj = mpNextInChain; + + // Replace next link + mpNextInChain = pNextObj; + // Deal with old next link's prev link + if (pOldNextObj) { + pOldNextObj->mpPrevInChain = nullptr; + } + + // Deal with new next link's prev link + if (mpNextInChain) { + // If there is a prev already at all and this is not already the current object + if (mpNextInChain->mpPrevInChain && + mpNextInChain->mpPrevInChain != this) + mpNextInChain->mpPrevInChain->mpNextInChain = nullptr; + mpNextInChain->mpPrevInChain = this; + } + + // TODO: Introduce check for circular chains + +} + +SdrTextObj* SdrTextObj::GetPrevLinkInChain() const +{ + /* + if (GetTextChain()) + return GetTextChain()->GetPrevLink(this); + + return NULL; + */ + + return mpPrevInChain; +} + +bool SdrTextObj::GetPreventChainable() const +{ + // Prevent chaining it 1) during dragging && 2) when we are editing next link + return mbIsUnchainableClone || (GetNextLinkInChain() && GetNextLinkInChain()->IsInEditMode()); +} + +rtl::Reference SdrTextObj::getFullDragClone() const +{ + rtl::Reference pClone = SdrAttrObj::getFullDragClone(); + SdrTextObj *pTextObjClone = DynCastSdrTextObj(pClone.get()); + if (pTextObjClone != nullptr) { + // Avoid transferring of text for chainable object during dragging + pTextObjClone->mbIsUnchainableClone = true; + } + + return pClone; + } + +/* End chaining code */ + +/** returns the currently active text. */ +SdrText* SdrTextObj::getActiveText() const +{ + if( !mxText ) + return getText( 0 ); + else + return mxText.get(); +} + +/** returns the nth available text. */ +SdrText* SdrTextObj::getText( sal_Int32 nIndex ) const +{ + if( nIndex == 0 ) + { + if( !mxText ) + const_cast< SdrTextObj* >(this)->mxText = new SdrText( *const_cast< SdrTextObj* >(this) ); + return mxText.get(); + } + else + { + return nullptr; + } +} + +/** returns the number of texts available for this object. */ +sal_Int32 SdrTextObj::getTextCount() const +{ + return 1; +} + +/** changes the current active text */ +void SdrTextObj::setActiveText( sal_Int32 /*nIndex*/ ) +{ +} + +/** returns the index of the text that contains the given point or -1 */ +sal_Int32 SdrTextObj::CheckTextHit(const Point& /*rPnt*/) const +{ + return 0; +} + +void SdrTextObj::SetObjectItemNoBroadcast(const SfxPoolItem& rItem) +{ + static_cast< sdr::properties::TextProperties& >(GetProperties()).SetObjectItemNoBroadcast(rItem); +} + + +// The concept of the text object: +// ~~~~~~~~~~~~~~~~~~~~~~~~ +// Attributes/Variations: +// - bool text frame / graphics object with caption +// - bool FontWork (if it is not a text frame and not a ContourTextFrame) +// - bool ContourTextFrame (if it is not a text frame and not Fontwork) +// - long rotation angle (if it is not FontWork) +// - long text frame margins (if it is not FontWork) +// - bool FitToSize (if it is not FontWork) +// - bool AutoGrowingWidth/Height (if it is not FitToSize and not FontWork) +// - long Min/MaxFrameWidth/Height (if AutoGrowingWidth/Height) +// - enum horizontal text anchoring left,center,right,justify/block,Stretch(ni) +// - enum vertical text anchoring top, middle, bottom, block, stretch(ni) +// - enum ticker text (if it is not FontWork) + +// Every derived object is either a text frame (mbTextFrame=true) +// or a drawing object with a caption (mbTextFrame=false). + +// Default anchoring for text frames: +// SDRTEXTHORZADJUST_BLOCK, SDRTEXTVERTADJUST_TOP +// = static Pool defaults +// Default anchoring for drawing objects with a caption: +// SDRTEXTHORZADJUST_CENTER, SDRTEXTVERTADJUST_CENTER +// via "hard" attribution of SdrAttrObj + +// Every object derived from SdrTextObj must return an "UnrotatedSnapRect" +// (->TakeUnrotatedSnapRect()) (the reference point for the rotation is the top +// left of the rectangle (maGeo.nRotationAngle)) which is the basis for anchoring +// text. We then subtract the text frame margins from this rectangle, as a re- +// sult we get the anchoring area (->TakeTextAnchorRect()). Within this area, we +// calculate the anchoring point and the painting area, depending on the hori- +// zontal and vertical adjustment of the text (SdrTextVertAdjust, +// SdrTextHorzAdjust). +// In the case of drawing objects with a caption the painting area might well +// be larger than the anchoring area, for text frames on the other hand, it is +// always of the same or a smaller size (except when there are negative text +// frame margins). + +// FitToSize takes priority over text anchoring and AutoGrowHeight/Width. When +// FitToSize is turned on, the painting area is always equal to the anchoring +// area. Additionally, FitToSize doesn't allow automatic line breaks. + +// ContourTextFrame: +// - long rotation angle +// - long text frame margins (maybe later) +// - bool FitToSize (maybe later) +// - bool AutoGrowingWidth/Height (maybe much later) +// - long Min/MaxFrameWidth/Height (maybe much later) +// - enum horizontal text anchoring (maybe later, for now: left, centered) +// - enum vertical text anchoring (maybe later, for now: top) +// - enum ticker text (maybe later, maybe even with correct clipping) + +// When making changes, check these: +// - Paint +// - HitTest +// - ConvertToPoly +// - Edit +// - Printing, Saving, Painting in neighboring View while editing +// - ModelChanged (e. g. through a neighboring View or rulers) while editing +// - FillColorChanged while editing +// - and many more... + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotextdecomposition.cxx b/svx/source/svdraw/svdotextdecomposition.cxx new file mode 100644 index 0000000000..1bad74cebb --- /dev/null +++ b/svx/source/svdraw/svdotextdecomposition.cxx @@ -0,0 +1,1838 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +// helpers + +namespace +{ + rtl::Reference buildTextPortionPrimitive(const DrawPortionInfo& rInfo, const OUString& rText, + const drawinglayer::attribute::FontAttribute& rFontAttribute, + const std::vector& rDXArray, + const basegfx::B2DHomMatrix& rNewTransform); + + class impTextBreakupHandler + { + private: + drawinglayer::primitive2d::Primitive2DContainer maTextPortionPrimitives; + drawinglayer::primitive2d::Primitive2DContainer maLinePrimitives; + drawinglayer::primitive2d::Primitive2DContainer maParagraphPrimitives; + + SdrOutliner& mrOutliner; + basegfx::B2DHomMatrix maNewTransformA; + basegfx::B2DHomMatrix maNewTransformB; + + // the visible area for contour text decomposition + basegfx::B2DVector maScale; + + // ClipRange for BlockText decomposition; only text portions completely + // inside are to be accepted, so this is different from geometric clipping + // (which would allow e.g. upper parts of portions to remain). Only used for + // BlockText (see there) + basegfx::B2DRange maClipRange; + + DECL_LINK(decomposeContourTextPrimitive, DrawPortionInfo*, void); + DECL_LINK(decomposeBlockTextPrimitive, DrawPortionInfo*, void); + DECL_LINK(decomposeStretchTextPrimitive, DrawPortionInfo*, void); + + DECL_LINK(decomposeContourBulletPrimitive, DrawBulletInfo*, void); + DECL_LINK(decomposeBlockBulletPrimitive, DrawBulletInfo*, void); + DECL_LINK(decomposeStretchBulletPrimitive, DrawBulletInfo*, void); + + static rtl::Reference impCheckFieldPrimitive(drawinglayer::primitive2d::BasePrimitive2D* pPrimitive, const DrawPortionInfo& rInfo); + void impFlushTextPortionPrimitivesToLinePrimitives(); + void impFlushLinePrimitivesToParagraphPrimitives(sal_Int32 nPara); + void impHandleDrawPortionInfo(const DrawPortionInfo& rInfo); + void impHandleDrawBulletInfo(const DrawBulletInfo& rInfo); + + public: + explicit impTextBreakupHandler(SdrOutliner& rOutliner) + : mrOutliner(rOutliner) + { + } + + void decomposeContourTextPrimitive(const basegfx::B2DHomMatrix& rNewTransformA, const basegfx::B2DHomMatrix& rNewTransformB, const basegfx::B2DVector& rScale) + { + maScale = rScale; + maNewTransformA = rNewTransformA; + maNewTransformB = rNewTransformB; + mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeContourTextPrimitive)); + mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeContourBulletPrimitive)); + mrOutliner.StripPortions(); + mrOutliner.SetDrawPortionHdl(Link()); + mrOutliner.SetDrawBulletHdl(Link()); + } + + void decomposeBlockTextPrimitive( + const basegfx::B2DHomMatrix& rNewTransformA, + const basegfx::B2DHomMatrix& rNewTransformB, + const basegfx::B2DRange& rClipRange) + { + maNewTransformA = rNewTransformA; + maNewTransformB = rNewTransformB; + maClipRange = rClipRange; + mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeBlockTextPrimitive)); + mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeBlockBulletPrimitive)); + mrOutliner.StripPortions(); + mrOutliner.SetDrawPortionHdl(Link()); + mrOutliner.SetDrawBulletHdl(Link()); + } + + void decomposeStretchTextPrimitive(const basegfx::B2DHomMatrix& rNewTransformA, const basegfx::B2DHomMatrix& rNewTransformB) + { + maNewTransformA = rNewTransformA; + maNewTransformB = rNewTransformB; + mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decomposeStretchTextPrimitive)); + mrOutliner.SetDrawBulletHdl(LINK(this, impTextBreakupHandler, decomposeStretchBulletPrimitive)); + mrOutliner.StripPortions(); + mrOutliner.SetDrawPortionHdl(Link()); + mrOutliner.SetDrawBulletHdl(Link()); + } + + drawinglayer::primitive2d::Primitive2DContainer extractPrimitive2DSequence(); + + void impCreateTextPortionPrimitive(const DrawPortionInfo& rInfo); + }; + + class DoCapitalsDrawPortionInfo : public SvxDoCapitals + { + private: + impTextBreakupHandler& m_rHandler; + const DrawPortionInfo& m_rInfo; + SvxFont m_aFont; + public: + DoCapitalsDrawPortionInfo(impTextBreakupHandler& rHandler, const DrawPortionInfo& rInfo) + : SvxDoCapitals(rInfo.maText, rInfo.mnTextStart, rInfo.mnTextLen) + , m_rHandler(rHandler) + , m_rInfo(rInfo) + , m_aFont(rInfo.mrFont) + { + assert(!m_rInfo.mpDXArray.empty()); + + /* turn all these off as they are handled outside subportions for the whole portion */ + m_aFont.SetTransparent(false); + m_aFont.SetUnderline(LINESTYLE_NONE); + m_aFont.SetOverline(LINESTYLE_NONE); + m_aFont.SetStrikeout(STRIKEOUT_NONE); + + m_aFont.SetCaseMap(SvxCaseMap::NotMapped); /* otherwise this would call itself */ + } + virtual void Do( const OUString &rSpanTxt, const sal_Int32 nSpanIdx, + const sal_Int32 nSpanLen, const bool bUpper ) override + { + sal_uInt8 nProp(0); + if (!bUpper) + { + nProp = m_aFont.GetPropr(); + m_aFont.SetProprRel(SMALL_CAPS_PERCENTAGE); + } + + sal_Int32 nStartOffset = nSpanIdx - nIdx; + sal_Int32 nStartX = nStartOffset ? m_rInfo.mpDXArray[nStartOffset - 1] : 0; + + Point aStartPos(m_rInfo.mrStartPos.X() + nStartX, m_rInfo.mrStartPos.Y()); + + std::vector aDXArray; + aDXArray.reserve(nSpanLen); + for (sal_Int32 i = 0; i < nSpanLen; ++i) + aDXArray.push_back(m_rInfo.mpDXArray[nStartOffset + i] - nStartX); + + auto aKashidaArray = !m_rInfo.mpKashidaArray.empty() ? + std::span(m_rInfo.mpKashidaArray.data() + nStartOffset, nSpanLen) : + std::span(); + + DrawPortionInfo aInfo(aStartPos, rSpanTxt, + nSpanIdx, nSpanLen, + m_aFont, m_rInfo.mnPara, + aDXArray, aKashidaArray, + nullptr, /* no spelling in subportion, handled outside */ + nullptr, /* no field in subportion, handled outside */ + m_rInfo.mpLocale, m_rInfo.maOverlineColor, m_rInfo.maTextLineColor, + m_rInfo.mnBiDiLevel, false, 0, false, false, false); + + m_rHandler.impCreateTextPortionPrimitive(aInfo); + + if (!bUpper) + m_aFont.SetPropr(nProp); + } + }; + + void impTextBreakupHandler::impCreateTextPortionPrimitive(const DrawPortionInfo& rInfo) + { + if(rInfo.maText.isEmpty() || !rInfo.mnTextLen) + return; + + basegfx::B2DVector aFontScaling; + drawinglayer::attribute::FontAttribute aFontAttribute( + drawinglayer::primitive2d::getFontAttributeFromVclFont( + aFontScaling, + rInfo.mrFont, + rInfo.IsRTL(), + false)); + basegfx::B2DHomMatrix aNewTransform; + + // add font scale to new transform + aNewTransform.scale(aFontScaling.getX(), aFontScaling.getY()); + + // look for proportional font scaling, if necessary, scale accordingly + sal_Int8 nPropr(rInfo.mrFont.GetPropr()); + const double fPropFontFactor(nPropr / 100.0); + if (100 != nPropr) + aNewTransform.scale(fPropFontFactor, fPropFontFactor); + + // apply font rotate + if(rInfo.mrFont.GetOrientation()) + { + aNewTransform.rotate(-toRadians(rInfo.mrFont.GetOrientation())); + } + + // look for escapement, if necessary, translate accordingly + if(rInfo.mrFont.GetEscapement()) + { + sal_Int16 nEsc(rInfo.mrFont.GetEscapement()); + + if(DFLT_ESC_AUTO_SUPER == nEsc) + { + nEsc = .8 * (100 - nPropr); + assert (nEsc == DFLT_ESC_SUPER && "I'm sure this formula needs to be changed, but how to confirm that???"); + nEsc = DFLT_ESC_SUPER; + } + else if(DFLT_ESC_AUTO_SUB == nEsc) + { + nEsc = .2 * -(100 - nPropr); + assert (nEsc == -20 && "I'm sure this formula needs to be changed, but how to confirm that???"); + nEsc = -20; + } + + if(nEsc > MAX_ESC_POS) + { + nEsc = MAX_ESC_POS; + } + else if(nEsc < -MAX_ESC_POS) + { + nEsc = -MAX_ESC_POS; + } + + const double fEscapement(nEsc / -100.0); + aNewTransform.translate(0.0, fEscapement * aFontScaling.getY()); + } + + // apply transformA + aNewTransform *= maNewTransformA; + + // apply local offset + aNewTransform.translate(rInfo.mrStartPos.X(), rInfo.mrStartPos.Y()); + + // also apply embedding object's transform + aNewTransform *= maNewTransformB; + + // prepare DXArray content. To make it independent from font size (and such from + // the text transformation), scale it to unit coordinates + ::std::vector< double > aDXArray; + + if (!rInfo.mpDXArray.empty()) + { + aDXArray.reserve(rInfo.mnTextLen); + for(sal_Int32 a=0; a < rInfo.mnTextLen; a++) + { + aDXArray.push_back(static_cast(rInfo.mpDXArray[a])); + } + } + + OUString caseMappedText = rInfo.mrFont.CalcCaseMap(rInfo.maText); + rtl::Reference pNewPrimitive(buildTextPortionPrimitive(rInfo, caseMappedText, + aFontAttribute, + aDXArray, aNewTransform)); + + bool bSmallCaps = rInfo.mrFont.IsCapital(); + if (bSmallCaps && rInfo.mpDXArray.empty()) + { + SAL_WARN("svx", "SmallCaps requested with DXArray, abandoning"); + bSmallCaps = false; + } + if (bSmallCaps) + { + // rerun with each sub-portion + DoCapitalsDrawPortionInfo aDoDrawPortionInfo(*this, rInfo); + rInfo.mrFont.DoOnCapitals(aDoDrawPortionInfo); + + // transfer collected primitives from maTextPortionPrimitives to a new container + drawinglayer::primitive2d::Primitive2DContainer aContainer; + aContainer.swap(maTextPortionPrimitives); + + // Take any decoration for the whole formatted portion and keep it to get continuous over/under/strike-through + if (pNewPrimitive->getPrimitive2DID() == PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D) + { + const drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D* pTCPP = + static_cast(pNewPrimitive.get()); + + pTCPP->CreateDecorationGeometryContent( + aContainer, + pTCPP->getTextTransform(), + caseMappedText, + rInfo.mnTextStart, + rInfo.mnTextLen, + aDXArray); + } + + pNewPrimitive = new drawinglayer::primitive2d::GroupPrimitive2D(std::move(aContainer)); + } + + const Color aFontColor(rInfo.mrFont.GetColor()); + if (aFontColor.IsTransparent()) + { + // Handle semi-transparent text for both the decorated and simple case here. + pNewPrimitive = new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( + drawinglayer::primitive2d::Primitive2DContainer{ pNewPrimitive }, + (255 - aFontColor.GetAlpha()) / 255.0); + } + + if(rInfo.mbEndOfBullet) + { + // embed in TextHierarchyBulletPrimitive2D + drawinglayer::primitive2d::Primitive2DReference aNewReference(pNewPrimitive); + drawinglayer::primitive2d::Primitive2DContainer aNewSequence { aNewReference } ; + pNewPrimitive = new drawinglayer::primitive2d::TextHierarchyBulletPrimitive2D(std::move(aNewSequence)); + } + + if(rInfo.mpFieldData) + { + pNewPrimitive = impCheckFieldPrimitive(pNewPrimitive.get(), rInfo); + } + + maTextPortionPrimitives.push_back(pNewPrimitive); + + // support for WrongSpellVector. Create WrongSpellPrimitives as needed + if(!rInfo.mpWrongSpellVector || aDXArray.empty()) + return; + + const sal_Int32 nSize(rInfo.mpWrongSpellVector->size()); + const sal_Int32 nDXCount(aDXArray.size()); + const basegfx::BColor aSpellColor(1.0, 0.0, 0.0); // red, hard coded + + for(sal_Int32 a(0); a < nSize; a++) + { + const EEngineData::WrongSpellClass& rCandidate = (*rInfo.mpWrongSpellVector)[a]; + + if(rCandidate.nStart >= rInfo.mnTextStart && rCandidate.nEnd >= rInfo.mnTextStart && rCandidate.nEnd > rCandidate.nStart) + { + const sal_Int32 nStart(rCandidate.nStart - rInfo.mnTextStart); + const sal_Int32 nEnd(rCandidate.nEnd - rInfo.mnTextStart); + double fStart(0.0); + double fEnd(0.0); + + if(nStart > 0 && nStart - 1 < nDXCount) + { + fStart = aDXArray[nStart - 1]; + } + + if(nEnd > 0 && nEnd - 1 < nDXCount) + { + fEnd = aDXArray[nEnd - 1]; + } + + if(!basegfx::fTools::equal(fStart, fEnd)) + { + if(rInfo.IsRTL()) + { + // #i98523# + // When the portion is RTL, mirror the redlining using the + // full portion width + const double fTextWidth(aDXArray[aDXArray.size() - 1]); + + fStart = fTextWidth - fStart; + fEnd = fTextWidth - fEnd; + + // tdf#151968 + // if start < end, OutputDevice::DrawWaveLine() will + // think it is a rotated line, so we swap fStart and + // fEnd to avoid this. + std::swap(fStart, fEnd); + } + + // need to take FontScaling out of values; it's already part of + // aNewTransform and would be double applied + const double fFontScaleX(aFontScaling.getX() * fPropFontFactor); + + if(!basegfx::fTools::equal(fFontScaleX, 1.0) + && !basegfx::fTools::equalZero(fFontScaleX)) + { + fStart /= fFontScaleX; + fEnd /= fFontScaleX; + } + + maTextPortionPrimitives.push_back(new drawinglayer::primitive2d::WrongSpellPrimitive2D( + aNewTransform, + fStart, + fEnd, + aSpellColor)); + } + } + } + } + + rtl::Reference buildTextPortionPrimitive( + const DrawPortionInfo& rInfo, const OUString& rText, + const drawinglayer::attribute::FontAttribute& rFontAttribute, + const std::vector& rDXArray, + const basegfx::B2DHomMatrix& rNewTransform) + { + ::std::vector< sal_Bool > aKashidaArray; + + if(!rInfo.mpKashidaArray.empty() && rInfo.mnTextLen) + { + aKashidaArray.reserve(rInfo.mnTextLen); + + for(sal_Int32 a=0; a < rInfo.mnTextLen; a++) + { + aKashidaArray.push_back(rInfo.mpKashidaArray[a]); + } + } + + // create complex text primitive and append + const Color aFontColor(rInfo.mrFont.GetColor()); + const basegfx::BColor aBFontColor(aFontColor.getBColor()); + + const Color aTextFillColor(rInfo.mrFont.GetFillColor()); + + // prepare wordLineMode (for underline and strikeout) + // NOT for bullet texts. It is set (this may be an error by itself), but needs to be suppressed to hinder e.g. '1)' + // to be split which would not look like the original + const bool bWordLineMode(rInfo.mrFont.IsWordLineMode() && !rInfo.mbEndOfBullet); + + // prepare new primitive + rtl::Reference pNewPrimitive; + const bool bDecoratedIsNeeded( + LINESTYLE_NONE != rInfo.mrFont.GetOverline() + || LINESTYLE_NONE != rInfo.mrFont.GetUnderline() + || STRIKEOUT_NONE != rInfo.mrFont.GetStrikeout() + || FontEmphasisMark::NONE != (rInfo.mrFont.GetEmphasisMark() & FontEmphasisMark::Style) + || FontRelief::NONE != rInfo.mrFont.GetRelief() + || rInfo.mrFont.IsShadow() + || bWordLineMode); + + if(bDecoratedIsNeeded) + { + // TextDecoratedPortionPrimitive2D needed, prepare some more data + // get overline and underline color. If it's on automatic (0xffffffff) use FontColor instead + const Color aUnderlineColor(rInfo.maTextLineColor); + const basegfx::BColor aBUnderlineColor((aUnderlineColor == COL_AUTO) ? aBFontColor : aUnderlineColor.getBColor()); + const Color aOverlineColor(rInfo.maOverlineColor); + const basegfx::BColor aBOverlineColor((aOverlineColor == COL_AUTO) ? aBFontColor : aOverlineColor.getBColor()); + + // prepare overline and underline data + const drawinglayer::primitive2d::TextLine eFontOverline( + drawinglayer::primitive2d::mapFontLineStyleToTextLine(rInfo.mrFont.GetOverline())); + const drawinglayer::primitive2d::TextLine eFontLineStyle( + drawinglayer::primitive2d::mapFontLineStyleToTextLine(rInfo.mrFont.GetUnderline())); + + // check UnderlineAbove + const bool bUnderlineAbove( + drawinglayer::primitive2d::TEXT_LINE_NONE != eFontLineStyle && rInfo.mrFont.IsUnderlineAbove()); + + // prepare strikeout data + const drawinglayer::primitive2d::TextStrikeout eTextStrikeout( + drawinglayer::primitive2d::mapFontStrikeoutToTextStrikeout(rInfo.mrFont.GetStrikeout())); + + // prepare emphasis mark data + drawinglayer::primitive2d::TextEmphasisMark eTextEmphasisMark(drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_NONE); + + switch(rInfo.mrFont.GetEmphasisMark() & FontEmphasisMark::Style) + { + case FontEmphasisMark::Dot : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_DOT; break; + case FontEmphasisMark::Circle : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_CIRCLE; break; + case FontEmphasisMark::Disc : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_DISC; break; + case FontEmphasisMark::Accent : eTextEmphasisMark = drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_ACCENT; break; + default: break; + } + + const bool bEmphasisMarkAbove(rInfo.mrFont.GetEmphasisMark() & FontEmphasisMark::PosAbove); + const bool bEmphasisMarkBelow(rInfo.mrFont.GetEmphasisMark() & FontEmphasisMark::PosBelow); + + // prepare font relief data + drawinglayer::primitive2d::TextRelief eTextRelief(drawinglayer::primitive2d::TEXT_RELIEF_NONE); + + switch(rInfo.mrFont.GetRelief()) + { + case FontRelief::Embossed : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_EMBOSSED; break; + case FontRelief::Engraved : eTextRelief = drawinglayer::primitive2d::TEXT_RELIEF_ENGRAVED; break; + default : break; // RELIEF_NONE, FontRelief_FORCE_EQUAL_SIZE + } + + // prepare shadow/outline data + const bool bShadow(rInfo.mrFont.IsShadow()); + + // TextDecoratedPortionPrimitive2D is needed, create one + pNewPrimitive = new drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D( + + // attributes for TextSimplePortionPrimitive2D + rNewTransform, + rText, + rInfo.mnTextStart, + rInfo.mnTextLen, + std::vector(rDXArray), + std::vector(aKashidaArray), + rFontAttribute, + rInfo.mpLocale ? *rInfo.mpLocale : css::lang::Locale(), + aBFontColor, + aTextFillColor, + + // attributes for TextDecoratedPortionPrimitive2D + aBOverlineColor, + aBUnderlineColor, + eFontOverline, + eFontLineStyle, + bUnderlineAbove, + eTextStrikeout, + bWordLineMode, + eTextEmphasisMark, + bEmphasisMarkAbove, + bEmphasisMarkBelow, + eTextRelief, + bShadow); + } + else + { + // TextSimplePortionPrimitive2D is enough + pNewPrimitive = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D( + rNewTransform, + rText, + rInfo.mnTextStart, + rInfo.mnTextLen, + std::vector(rDXArray), + std::vector(aKashidaArray), + rFontAttribute, + rInfo.mpLocale ? *rInfo.mpLocale : css::lang::Locale(), + aBFontColor, + rInfo.mbFilled, + rInfo.mnWidthToFill, + aTextFillColor); + } + + return pNewPrimitive; + } + + rtl::Reference impTextBreakupHandler::impCheckFieldPrimitive(drawinglayer::primitive2d::BasePrimitive2D* pPrimitive, const DrawPortionInfo& rInfo) + { + rtl::Reference xRet = pPrimitive; + if(rInfo.mpFieldData) + { + // Support for FIELD_SEQ_BEGIN, FIELD_SEQ_END. If used, create a TextHierarchyFieldPrimitive2D + // which holds the field type and, if applicable, the URL + const SvxURLField* pURLField = dynamic_cast< const SvxURLField* >(rInfo.mpFieldData); + const SvxPageField* pPageField = dynamic_cast< const SvxPageField* >(rInfo.mpFieldData); + + // embed current primitive to a sequence + drawinglayer::primitive2d::Primitive2DContainer aSequence; + + if(pPrimitive) + { + aSequence.resize(1); + aSequence[0] = drawinglayer::primitive2d::Primitive2DReference(pPrimitive); + } + + if(pURLField) + { + // extended this to hold more of the contents of the original + // SvxURLField since that stuff is still used in HitTest and e.g. Calc + std::vector< std::pair< OUString, OUString>> meValues; + meValues.emplace_back("URL", pURLField->GetURL()); + meValues.emplace_back("Representation", pURLField->GetRepresentation()); + meValues.emplace_back("TargetFrame", pURLField->GetTargetFrame()); + meValues.emplace_back("SvxURLFormat", OUString::number(static_cast(pURLField->GetFormat()))); + xRet = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(std::move(aSequence), drawinglayer::primitive2d::FIELD_TYPE_URL, &meValues); + } + else if(pPageField) + { + xRet = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(std::move(aSequence), drawinglayer::primitive2d::FIELD_TYPE_PAGE); + } + else + { + xRet = new drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D(std::move(aSequence), drawinglayer::primitive2d::FIELD_TYPE_COMMON); + } + } + + return xRet; + } + + void impTextBreakupHandler::impFlushTextPortionPrimitivesToLinePrimitives() + { + // only create a line primitive when we had content; there is no need for + // empty line primitives (contrary to paragraphs, see below). + if(!maTextPortionPrimitives.empty()) + { + maLinePrimitives.push_back(new drawinglayer::primitive2d::TextHierarchyLinePrimitive2D(std::move(maTextPortionPrimitives))); + } + } + + void impTextBreakupHandler::impFlushLinePrimitivesToParagraphPrimitives(sal_Int32 nPara) + { + sal_Int16 nDepth = mrOutliner.GetDepth(nPara); + EBulletInfo eInfo = mrOutliner.GetBulletInfo(nPara); + // Pass -1 to signal VclMetafileProcessor2D that there is no active + // bullets/numbering in this paragraph (i.e. this is normal text) + const sal_Int16 nOutlineLevel( eInfo.bVisible ? nDepth : -1); + + // ALWAYS create a paragraph primitive, even when no content was added. This is done to + // have the correct paragraph count even with empty paragraphs. Those paragraphs will + // have an empty sub-PrimitiveSequence. + maParagraphPrimitives.push_back( + new drawinglayer::primitive2d::TextHierarchyParagraphPrimitive2D( + std::move(maLinePrimitives), + nOutlineLevel)); + } + + void impTextBreakupHandler::impHandleDrawPortionInfo(const DrawPortionInfo& rInfo) + { + impCreateTextPortionPrimitive(rInfo); + + if(rInfo.mbEndOfLine || rInfo.mbEndOfParagraph) + { + impFlushTextPortionPrimitivesToLinePrimitives(); + } + + if(rInfo.mbEndOfParagraph) + { + impFlushLinePrimitivesToParagraphPrimitives(rInfo.mnPara); + } + } + + void impTextBreakupHandler::impHandleDrawBulletInfo(const DrawBulletInfo& rInfo) + { + basegfx::B2DHomMatrix aNewTransform; + + // add size to new transform + aNewTransform.scale(rInfo.maBulletSize.getWidth(), rInfo.maBulletSize.getHeight()); + + // apply transformA + aNewTransform *= maNewTransformA; + + // apply local offset + aNewTransform.translate(rInfo.maBulletPosition.X(), rInfo.maBulletPosition.Y()); + + // also apply embedding object's transform + aNewTransform *= maNewTransformB; + + // prepare empty GraphicAttr + const GraphicAttr aGraphicAttr; + + // create GraphicPrimitive2D + const drawinglayer::primitive2d::Primitive2DReference aNewReference(new drawinglayer::primitive2d::GraphicPrimitive2D( + aNewTransform, + rInfo.maBulletGraphicObject, + aGraphicAttr)); + + // embed in TextHierarchyBulletPrimitive2D + drawinglayer::primitive2d::Primitive2DContainer aNewSequence { aNewReference }; + rtl::Reference pNewPrimitive = new drawinglayer::primitive2d::TextHierarchyBulletPrimitive2D(std::move(aNewSequence)); + + // add to output + maTextPortionPrimitives.push_back(pNewPrimitive); + } + + IMPL_LINK(impTextBreakupHandler, decomposeContourTextPrimitive, DrawPortionInfo*, pInfo, void) + { + // for contour text, ignore (clip away) all portions which are below + // the visible area given by maScale + if(pInfo && static_cast(pInfo->mrStartPos.Y()) < maScale.getY()) + { + impHandleDrawPortionInfo(*pInfo); + } + } + + IMPL_LINK(impTextBreakupHandler, decomposeBlockTextPrimitive, DrawPortionInfo*, pInfo, void) + { + if(!pInfo) + return; + + // Is clipping wanted? This is text clipping; only accept a portion + // if it's completely in the range + if(!maClipRange.isEmpty()) + { + // Test start position first; this allows to not get the text range at + // all if text is far outside + const basegfx::B2DPoint aStartPosition(pInfo->mrStartPos.X(), pInfo->mrStartPos.Y()); + + if(!maClipRange.isInside(aStartPosition)) + { + return; + } + + // Start position is inside. Get TextBoundRect and TopLeft next + drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice; + aTextLayouterDevice.setFont(pInfo->mrFont); + + const basegfx::B2DRange aTextBoundRect( + aTextLayouterDevice.getTextBoundRect( + pInfo->maText, pInfo->mnTextStart, pInfo->mnTextLen)); + const basegfx::B2DPoint aTopLeft(aTextBoundRect.getMinimum() + aStartPosition); + + if(!maClipRange.isInside(aTopLeft)) + { + return; + } + + // TopLeft is inside. Get BottomRight and check + const basegfx::B2DPoint aBottomRight(aTextBoundRect.getMaximum() + aStartPosition); + + if(!maClipRange.isInside(aBottomRight)) + { + return; + } + + // all inside, clip was successful + } + impHandleDrawPortionInfo(*pInfo); + } + + IMPL_LINK(impTextBreakupHandler, decomposeStretchTextPrimitive, DrawPortionInfo*, pInfo, void) + { + if(pInfo) + { + impHandleDrawPortionInfo(*pInfo); + } + } + + IMPL_LINK(impTextBreakupHandler, decomposeContourBulletPrimitive, DrawBulletInfo*, pInfo, void) + { + if(pInfo) + { + impHandleDrawBulletInfo(*pInfo); + } + } + + IMPL_LINK(impTextBreakupHandler, decomposeBlockBulletPrimitive, DrawBulletInfo*, pInfo, void) + { + if(pInfo) + { + impHandleDrawBulletInfo(*pInfo); + } + } + + IMPL_LINK(impTextBreakupHandler, decomposeStretchBulletPrimitive, DrawBulletInfo*, pInfo, void) + { + if(pInfo) + { + impHandleDrawBulletInfo(*pInfo); + } + } + + drawinglayer::primitive2d::Primitive2DContainer impTextBreakupHandler::extractPrimitive2DSequence() + { + if(!maTextPortionPrimitives.empty()) + { + // collect non-closed lines + impFlushTextPortionPrimitivesToLinePrimitives(); + } + + if(!maLinePrimitives.empty()) + { + // collect non-closed paragraphs + impFlushLinePrimitivesToParagraphPrimitives(mrOutliner.GetParagraphCount() - 1); + } + + return std::move(maParagraphPrimitives); + } +} // end of anonymous namespace + + +// primitive decompositions + +void SdrTextObj::impDecomposeContourTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrContourTextPrimitive2D& rSdrContourTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + // decompose matrix to have position and size of text + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rSdrContourTextPrimitive.getObjectTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // prepare contour polygon, force to non-mirrored for laying out + basegfx::B2DPolyPolygon aPolyPolygon(rSdrContourTextPrimitive.getUnitPolyPolygon()); + aPolyPolygon.transform(basegfx::utils::createScaleB2DHomMatrix(fabs(aScale.getX()), fabs(aScale.getY()))); + + // prepare outliner + SolarMutexGuard aSolarGuard; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + const Size aNullSize; + rOutliner.SetPaperSize(aNullSize); + rOutliner.SetPolygon(aPolyPolygon); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(rSdrContourTextPrimitive.getOutlinerParaObject()); + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + // prepare matrices to apply to newly created primitives + basegfx::B2DHomMatrix aNewTransformA; + + // mirroring. We are now in the polygon sizes. When mirroring in X and Y, + // move the null point which was top left to bottom right. + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + + // in-between the translations of the single primitives will take place. Afterwards, + // the object's transformations need to be applied + const basegfx::B2DHomMatrix aNewTransformB(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0, + fShearX, fRotate, aTranslate.getX(), aTranslate.getY())); + + // now break up text primitives. + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeContourTextPrimitive(aNewTransformA, aNewTransformB, aScale); + + // cleanup outliner + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + + rTarget = aConverter.extractPrimitive2DSequence(); +} + +void SdrTextObj::impDecomposeAutoFitTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrAutoFitTextPrimitive2D& rSdrAutofitTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + // decompose matrix to have position and size of text + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rSdrAutofitTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // use B2DRange aAnchorTextRange for calculations + basegfx::B2DRange aAnchorTextRange(aTranslate); + aAnchorTextRange.expand(aTranslate + aScale); + + // prepare outliner + const SfxItemSet& rTextItemSet = rSdrAutofitTextPrimitive.getSdrText()->GetItemSet(); + SolarMutexGuard aSolarGuard; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + SdrTextVertAdjust eVAdj = GetTextVerticalAdjust(rTextItemSet); + SdrTextHorzAdjust eHAdj = GetTextHorizontalAdjust(rTextItemSet); + const EEControlBits nOriginalControlWord(rOutliner.GetControlWord()); + const Size aNullSize; + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + rOutliner.SetControlWord(nOriginalControlWord|EEControlBits::AUTOPAGESIZE|EEControlBits::STRETCHING); + rOutliner.SetMinAutoPaperSize(aNullSize); + rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000)); + + // That color needs to be restored on leaving this method + Color aOriginalBackColor(rOutliner.GetBackgroundColor()); + setSuitableOutlinerBg(rOutliner); + + // add one to range sizes to get back to the old Rectangle and outliner measurements + const sal_uInt32 nAnchorTextWidth(FRound(aAnchorTextRange.getWidth() + 1)); + const sal_uInt32 nAnchorTextHeight(FRound(aAnchorTextRange.getHeight() + 1)); + const OutlinerParaObject* pOutlinerParaObject = rSdrAutofitTextPrimitive.getSdrText()->GetOutlinerParaObject(); + OSL_ENSURE(pOutlinerParaObject, "impDecomposeBlockTextPrimitive used with no OutlinerParaObject (!)"); + const bool bVerticalWriting(pOutlinerParaObject->IsEffectivelyVertical()); + const bool bTopToBottom(pOutlinerParaObject->IsTopToBottom()); + const Size aAnchorTextSize(Size(nAnchorTextWidth, nAnchorTextHeight)); + + if(rSdrAutofitTextPrimitive.getWordWrap() || IsTextFrame()) + { + rOutliner.SetMaxAutoPaperSize(aAnchorTextSize); + } + + if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !bVerticalWriting) + { + rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0)); + rOutliner.SetMinColumnWrapHeight(nAnchorTextHeight); + } + + if(SDRTEXTVERTADJUST_BLOCK == eVAdj && bVerticalWriting) + { + rOutliner.SetMinAutoPaperSize(Size(0, nAnchorTextHeight)); + rOutliner.SetMinColumnWrapHeight(nAnchorTextWidth); + } + + rOutliner.SetPaperSize(aNullSize); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(*pOutlinerParaObject); + ImpAutoFitText(rOutliner,aAnchorTextSize,bVerticalWriting); + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + // now get back the layouted text size from outliner + const Size aOutlinerTextSize(rOutliner.GetPaperSize()); + const basegfx::B2DVector aOutlinerScale(aOutlinerTextSize.Width(), aOutlinerTextSize.Height()); + basegfx::B2DVector aAdjustTranslate(0.0, 0.0); + + // correct horizontal translation using the now known text size + if(SDRTEXTHORZADJUST_CENTER == eHAdj || SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + const double fFree(aAnchorTextRange.getWidth() - aOutlinerScale.getX()); + + if(SDRTEXTHORZADJUST_CENTER == eHAdj) + { + aAdjustTranslate.setX(fFree / 2.0); + } + + if(SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + aAdjustTranslate.setX(fFree); + } + } + + // correct vertical translation using the now known text size + if(SDRTEXTVERTADJUST_CENTER == eVAdj || SDRTEXTVERTADJUST_BOTTOM == eVAdj) + { + const double fFree(aAnchorTextRange.getHeight() - aOutlinerScale.getY()); + + if(SDRTEXTVERTADJUST_CENTER == eVAdj) + { + aAdjustTranslate.setY(fFree / 2.0); + } + + if(SDRTEXTVERTADJUST_BOTTOM == eVAdj) + { + aAdjustTranslate.setY(fFree); + } + } + + // prepare matrices to apply to newly created primitives. aNewTransformA + // will get coordinates in aOutlinerScale size and positive in X, Y. + basegfx::B2DHomMatrix aNewTransformA; + basegfx::B2DHomMatrix aNewTransformB; + + // translate relative to given primitive to get same rotation and shear + // as the master shape we are working on. For vertical, use the top-right + // corner + const double fStartInX(bVerticalWriting && bTopToBottom ? aAdjustTranslate.getX() + aOutlinerScale.getX() : aAdjustTranslate.getX()); + const double fStartInY(bVerticalWriting && !bTopToBottom ? aAdjustTranslate.getY() + aOutlinerScale.getY() : aAdjustTranslate.getY()); + aNewTransformA.translate(fStartInX, fStartInY); + + // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y, + // move the null point which was top left to bottom right. + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0); + + // in-between the translations of the single primitives will take place. Afterwards, + // the object's transformations need to be applied + aNewTransformB.shearX(fShearX); + aNewTransformB.rotate(fRotate); + aNewTransformB.translate(aTranslate.getX(), aTranslate.getY()); + + basegfx::B2DRange aClipRange; + + // now break up text primitives. + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeBlockTextPrimitive(aNewTransformA, aNewTransformB, aClipRange); + + // cleanup outliner + rOutliner.SetBackgroundColor(aOriginalBackColor); + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + rOutliner.SetControlWord(nOriginalControlWord); + + rTarget = aConverter.extractPrimitive2DSequence(); +} + +// Resolves: fdo#35779 set background color of this shape as the editeng background if there +// is one. Check the shape itself, then the host page, then that page's master page. +bool SdrObject::setSuitableOutlinerBg(::Outliner& rOutliner) const +{ + const SfxItemSet* pBackgroundFillSet = getBackgroundFillSet(); + if (drawing::FillStyle_NONE != pBackgroundFillSet->Get(XATTR_FILLSTYLE).GetValue()) + { + Color aColor(GetDraftFillColor(*pBackgroundFillSet).value_or(rOutliner.GetBackgroundColor())); + rOutliner.SetBackgroundColor(aColor); + return true; + } + return false; +} + +const SfxItemSet* SdrObject::getBackgroundFillSet() const +{ + const SfxItemSet* pBackgroundFillSet = &GetObjectItemSet(); + + if (drawing::FillStyle_NONE == pBackgroundFillSet->Get(XATTR_FILLSTYLE).GetValue()) + { + SdrPage* pOwnerPage(getSdrPageFromSdrObject()); + if (pOwnerPage) + { + pBackgroundFillSet = &pOwnerPage->getSdrPageProperties().GetItemSet(); + + if (drawing::FillStyle_NONE == pBackgroundFillSet->Get(XATTR_FILLSTYLE).GetValue()) + { + if (!pOwnerPage->IsMasterPage() && pOwnerPage->TRG_HasMasterPage()) + { + pBackgroundFillSet = &pOwnerPage->TRG_GetMasterPage().getSdrPageProperties().GetItemSet(); + } + } + } + } + return pBackgroundFillSet; +} + +const Graphic* SdrObject::getFillGraphic() const +{ + if(IsGroupObject()) // Doesn't make sense, and GetObjectItemSet() asserts. + return nullptr; + const SfxItemSet* pBackgroundFillSet = getBackgroundFillSet(); + if (drawing::FillStyle_BITMAP != pBackgroundFillSet->Get(XATTR_FILLSTYLE).GetValue()) + return nullptr; + return &pBackgroundFillSet->Get(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic(); +} + +void SdrTextObj::impDecomposeBlockTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrBlockTextPrimitive2D& rSdrBlockTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + // decompose matrix to have position and size of text + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rSdrBlockTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // use B2DRange aAnchorTextRange for calculations + basegfx::B2DRange aAnchorTextRange(aTranslate); + aAnchorTextRange.expand(aTranslate + aScale); + + // prepare outliner + const bool bIsCell(rSdrBlockTextPrimitive.getCellText()); + SolarMutexGuard aSolarGuard; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + SdrTextHorzAdjust eHAdj = rSdrBlockTextPrimitive.getSdrTextHorzAdjust(); + SdrTextVertAdjust eVAdj = rSdrBlockTextPrimitive.getSdrTextVertAdjust(); + const EEControlBits nOriginalControlWord(rOutliner.GetControlWord()); + const Size aNullSize; + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + rOutliner.SetFixedCellHeight(rSdrBlockTextPrimitive.isFixedCellHeight()); + rOutliner.SetControlWord(nOriginalControlWord|EEControlBits::AUTOPAGESIZE); + rOutliner.SetMinAutoPaperSize(aNullSize); + rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000)); + + // That color needs to be restored on leaving this method + Color aOriginalBackColor(rOutliner.GetBackgroundColor()); + setSuitableOutlinerBg(rOutliner); + + // add one to range sizes to get back to the old Rectangle and outliner measurements + const sal_uInt32 nAnchorTextWidth(FRound(aAnchorTextRange.getWidth() + 1)); + const sal_uInt32 nAnchorTextHeight(FRound(aAnchorTextRange.getHeight() + 1)); + const bool bVerticalWriting(rSdrBlockTextPrimitive.getOutlinerParaObject().IsEffectivelyVertical()); + const bool bTopToBottom(rSdrBlockTextPrimitive.getOutlinerParaObject().IsTopToBottom()); + const Size aAnchorTextSize(Size(nAnchorTextWidth, nAnchorTextHeight)); + + if(bIsCell) + { + // cell text is formatted neither like a text object nor like an object + // text, so use a special setup here + rOutliner.SetMaxAutoPaperSize(aAnchorTextSize); + + // #i106214# To work with an unchangeable PaperSize (CellSize in + // this case) Set(Min|Max)AutoPaperSize and SetPaperSize have to be used. + // #i106214# This was not completely correct; to still measure the real + // text height to allow vertical adjust (and vice versa for VerticalWritintg) + // only one aspect has to be set, but the other one to zero + if(bVerticalWriting) + { + // measure the horizontal text size + rOutliner.SetMinAutoPaperSize(Size(0, aAnchorTextSize.Height())); + } + else + { + // measure the vertical text size + rOutliner.SetMinAutoPaperSize(Size(aAnchorTextSize.Width(), 0)); + } + + rOutliner.SetPaperSize(aAnchorTextSize); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(rSdrBlockTextPrimitive.getOutlinerParaObject()); + } + else + { + // check if block text is used (only one of them can be true) + const bool bHorizontalIsBlock(SDRTEXTHORZADJUST_BLOCK == eHAdj && !bVerticalWriting); + const bool bVerticalIsBlock(SDRTEXTVERTADJUST_BLOCK == eVAdj && bVerticalWriting); + + // set minimal paper size horizontally/vertically if needed + if(bHorizontalIsBlock) + { + rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0)); + rOutliner.SetMinColumnWrapHeight(nAnchorTextHeight); + } + else if(bVerticalIsBlock) + { + rOutliner.SetMinAutoPaperSize(Size(0, nAnchorTextHeight)); + rOutliner.SetMinColumnWrapHeight(nAnchorTextWidth); + } + + if((rSdrBlockTextPrimitive.getWordWrap() || IsTextFrame()) && !rSdrBlockTextPrimitive.getUnlimitedPage()) + { + // #i103454# maximal paper size hor/ver needs to be limited to text + // frame size. If it's block text, still allow the 'other' direction + // to grow to get a correct real text size when using GetPaperSize(). + // When just using aAnchorTextSize as maximum, GetPaperSize() + // would just return aAnchorTextSize again: this means, the wanted + // 'measurement' of the real size of block text would not work + Size aMaxAutoPaperSize(aAnchorTextSize); + + // Usual processing - always grow in one of directions + bool bAllowGrowVertical = !bVerticalWriting; + bool bAllowGrowHorizontal = bVerticalWriting; + + // Compatibility mode for tdf#99729 + if (getSdrModelFromSdrObject().GetCompatibilityFlag( + SdrCompatibilityFlag::AnchoredTextOverflowLegacy)) + { + bAllowGrowVertical = bHorizontalIsBlock; + bAllowGrowHorizontal = bVerticalIsBlock; + } + + if (bAllowGrowVertical) + { + // allow to grow vertical for horizontal texts + aMaxAutoPaperSize.setHeight(1000000); + } + else if (bAllowGrowHorizontal) + { + // allow to grow horizontal for vertical texts + aMaxAutoPaperSize.setWidth(1000000); + } + + rOutliner.SetMaxAutoPaperSize(aMaxAutoPaperSize); + } + + rOutliner.SetPaperSize(aNullSize); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(rSdrBlockTextPrimitive.getOutlinerParaObject()); + } + + rOutliner.SetControlWord(nOriginalControlWord); + + // now get back the layouted text size from outliner + const Size aOutlinerTextSize(rOutliner.GetPaperSize()); + const basegfx::B2DVector aOutlinerScale(aOutlinerTextSize.Width(), aOutlinerTextSize.Height()); + basegfx::B2DVector aAdjustTranslate(0.0, 0.0); + + // For draw objects containing text correct hor/ver alignment if text is bigger + // than the object itself. Without that correction, the text would always be + // formatted to the left edge (or top edge when vertical) of the draw object. + if(!IsTextFrame() && !bIsCell) + { + if(aAnchorTextRange.getWidth() < aOutlinerScale.getX() && !bVerticalWriting) + { + // Horizontal case here. Correct only if eHAdj == SDRTEXTHORZADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTHORZADJUST_BLOCK == eHAdj) + { + SvxAdjust eAdjust = GetObjectItemSet().Get(EE_PARA_JUST).GetAdjust(); + switch(eAdjust) + { + case SvxAdjust::Left: eHAdj = SDRTEXTHORZADJUST_LEFT; break; + case SvxAdjust::Right: eHAdj = SDRTEXTHORZADJUST_RIGHT; break; + case SvxAdjust::Center: eHAdj = SDRTEXTHORZADJUST_CENTER; break; + default: break; + } + } + } + + if(aAnchorTextRange.getHeight() < aOutlinerScale.getY() && bVerticalWriting) + { + // Vertical case here. Correct only if eHAdj == SDRTEXTVERTADJUST_BLOCK, + // else the alignment is wanted. + if(SDRTEXTVERTADJUST_BLOCK == eVAdj) + { + eVAdj = SDRTEXTVERTADJUST_CENTER; + } + } + } + + // correct horizontal translation using the now known text size + if(SDRTEXTHORZADJUST_CENTER == eHAdj || SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + const double fFree(aAnchorTextRange.getWidth() - aOutlinerScale.getX()); + + if(SDRTEXTHORZADJUST_CENTER == eHAdj) + { + aAdjustTranslate.setX(fFree / 2.0); + } + + if(SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + aAdjustTranslate.setX(fFree); + } + } + + const double fFreeVerticalSpace(aAnchorTextRange.getHeight() - aOutlinerScale.getY()); + bool bClipVerticalTextOverflow = fFreeVerticalSpace < 0 + && GetObjectItemSet().Get(SDRATTR_TEXT_CLIPVERTOVERFLOW).GetValue(); + // correct vertical translation using the now known text size + if((SDRTEXTVERTADJUST_CENTER == eVAdj || SDRTEXTVERTADJUST_BOTTOM == eVAdj) + && !bClipVerticalTextOverflow) + { + if(SDRTEXTVERTADJUST_CENTER == eVAdj) + { + aAdjustTranslate.setY(fFreeVerticalSpace / 2.0); + } + + if(SDRTEXTVERTADJUST_BOTTOM == eVAdj) + { + aAdjustTranslate.setY(fFreeVerticalSpace); + } + } + + // prepare matrices to apply to newly created primitives. aNewTransformA + // will get coordinates in aOutlinerScale size and positive in X, Y. + // Translate relative to given primitive to get same rotation and shear + // as the master shape we are working on. For vertical, use the top-right + // corner + const double fStartInX(bVerticalWriting && bTopToBottom ? aAdjustTranslate.getX() + aOutlinerScale.getX() : aAdjustTranslate.getX()); + const double fStartInY(bVerticalWriting && !bTopToBottom ? aAdjustTranslate.getY() + aOutlinerScale.getY() : aAdjustTranslate.getY()); + basegfx::B2DHomMatrix aNewTransformA(basegfx::utils::createTranslateB2DHomMatrix(fStartInX, fStartInY)); + + // Apply the camera rotation. It have to be applied after adjustment of + // the text (top, bottom, center, left, right). + if(GetCameraZRotation() != 0) + { + // First find the text rect. + basegfx::B2DRange aTextRectangle(/*x1=*/aTranslate.getX() + aAdjustTranslate.getX(), + /*y1=*/aTranslate.getY() + aAdjustTranslate.getY(), + /*x2=*/aTranslate.getX() + aOutlinerScale.getX() - aAdjustTranslate.getX(), + /*y2=*/aTranslate.getY() + aOutlinerScale.getY() - aAdjustTranslate.getY()); + + // Rotate the text from the center point. + basegfx::B2DVector aTranslateToCenter(aTextRectangle.getWidth() / 2, aTextRectangle.getHeight() / 2); + aNewTransformA.translate(-aTranslateToCenter.getX(), -aTranslateToCenter.getY()); + aNewTransformA.rotate(basegfx::deg2rad(360.0 - GetCameraZRotation() )); + aNewTransformA.translate(aTranslateToCenter.getX(), aTranslateToCenter.getY()); + } + + // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y, + // move the null point which was top left to bottom right. + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + + // in-between the translations of the single primitives will take place. Afterwards, + // the object's transformations need to be applied + const basegfx::B2DHomMatrix aNewTransformB(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0, + fShearX, fRotate, aTranslate.getX(), aTranslate.getY())); + + + // create ClipRange (if needed) + basegfx::B2DRange aClipRange; + if(bClipVerticalTextOverflow) + aClipRange = {0, 0, std::numeric_limits::max(), aAnchorTextRange.getHeight()}; + + // now break up text primitives. + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeBlockTextPrimitive(aNewTransformA, aNewTransformB, aClipRange); + + // cleanup outliner + rOutliner.SetBackgroundColor(aOriginalBackColor); + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + + rTarget = aConverter.extractPrimitive2DSequence(); +} + +void SdrTextObj::impDecomposeStretchTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrStretchTextPrimitive2D& rSdrStretchTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + // decompose matrix to have position and size of text + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rSdrStretchTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // prepare outliner + SolarMutexGuard aSolarGuard; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + const EEControlBits nOriginalControlWord(rOutliner.GetControlWord()); + const Size aNullSize; + + rOutliner.SetControlWord(nOriginalControlWord|EEControlBits::STRETCHING|EEControlBits::AUTOPAGESIZE); + rOutliner.SetFixedCellHeight(rSdrStretchTextPrimitive.isFixedCellHeight()); + rOutliner.SetMinAutoPaperSize(aNullSize); + rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000)); + rOutliner.SetPaperSize(aNullSize); + rOutliner.SetUpdateLayout(true); + rOutliner.SetText(rSdrStretchTextPrimitive.getOutlinerParaObject()); + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + // now get back the laid out text size from outliner + const Size aOutlinerTextSize(rOutliner.CalcTextSize()); + const basegfx::B2DVector aOutlinerScale( + aOutlinerTextSize.Width() == tools::Long(0) ? 1.0 : aOutlinerTextSize.Width(), + aOutlinerTextSize.Height() == tools::Long(0) ? 1.0 : aOutlinerTextSize.Height()); + + // prepare matrices to apply to newly created primitives + basegfx::B2DHomMatrix aNewTransformA; + + // #i101957# Check for vertical text. If used, aNewTransformA + // needs to translate the text initially around object width to orient + // it relative to the topper right instead of the topper left + const bool bVertical(rSdrStretchTextPrimitive.getOutlinerParaObject().IsEffectivelyVertical()); + const bool bTopToBottom(rSdrStretchTextPrimitive.getOutlinerParaObject().IsTopToBottom()); + + if(bVertical) + { + if(bTopToBottom) + aNewTransformA.translate(aScale.getX(), 0.0); + else + aNewTransformA.translate(0.0, aScale.getY()); + } + + // calculate global char stretching scale parameters. Use non-mirrored sizes + // to layout without mirroring + const double fScaleX(fabs(aScale.getX()) / aOutlinerScale.getX()); + const double fScaleY(fabs(aScale.getY()) / aOutlinerScale.getY()); + rOutliner.setGlobalScale(fScaleX * 100.0, fScaleY * 100.0, 100.0, 100.0); + + // When mirroring in X and Y, + // move the null point which was top left to bottom right. + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + + // in-between the translations of the single primitives will take place. Afterwards, + // the object's transformations need to be applied + const basegfx::B2DHomMatrix aNewTransformB(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0, + fShearX, fRotate, aTranslate.getX(), aTranslate.getY())); + + // now break up text primitives. + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeStretchTextPrimitive(aNewTransformA, aNewTransformB); + + // cleanup outliner + rOutliner.SetControlWord(nOriginalControlWord); + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + + rTarget = aConverter.extractPrimitive2DSequence(); +} + + +// timing generators +#define ENDLESS_LOOP (0xffffffff) +#define ENDLESS_TIME (double(0xffffffff)) +#define PIXEL_DPI (96.0) + +void SdrTextObj::impGetBlinkTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList) const +{ + if(SdrTextAniKind::Blink != GetTextAniKind()) + return; + + // get values + const SfxItemSet& rSet = GetObjectItemSet(); + const sal_uInt32 nRepeat(static_cast(rSet.Get(SDRATTR_TEXT_ANICOUNT).GetValue())); + double fDelay(static_cast(rSet.Get(SDRATTR_TEXT_ANIDELAY).GetValue())); + + if(0.0 == fDelay) + { + // use default + fDelay = 250.0; + } + + // prepare loop and add + drawinglayer::animation::AnimationEntryLoop aLoop(nRepeat ? nRepeat : ENDLESS_LOOP); + drawinglayer::animation::AnimationEntryFixed aStart(fDelay, 0.0); + aLoop.append(aStart); + drawinglayer::animation::AnimationEntryFixed aEnd(fDelay, 1.0); + aLoop.append(aEnd); + rAnimList.append(aLoop); + + // add stopped state if loop is not endless + if(0 != nRepeat) + { + bool bVisibleWhenStopped(rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE).GetValue()); + drawinglayer::animation::AnimationEntryFixed aStop(ENDLESS_TIME, bVisibleWhenStopped ? 0.0 : 1.0); + rAnimList.append(aStop); + } +} + +static void impCreateScrollTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, bool bForward, double fTimeFullPath, double fFrequency) +{ + bool bVisibleWhenStopped(rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE).GetValue()); + bool bVisibleWhenStarted(rSet.Get(SDRATTR_TEXT_ANISTARTINSIDE).GetValue()); + const sal_uInt32 nRepeat(rSet.Get(SDRATTR_TEXT_ANICOUNT).GetValue()); + + if(bVisibleWhenStarted) + { + // move from center to outside + drawinglayer::animation::AnimationEntryLinear aInOut(fTimeFullPath * 0.5, fFrequency, 0.5, bForward ? 1.0 : 0.0); + rAnimList.append(aInOut); + } + + // loop. In loop, move through + drawinglayer::animation::AnimationEntryLoop aLoop(nRepeat ? nRepeat : ENDLESS_LOOP); + drawinglayer::animation::AnimationEntryLinear aThrough(fTimeFullPath, fFrequency, bForward ? 0.0 : 1.0, bForward ? 1.0 : 0.0); + aLoop.append(aThrough); + rAnimList.append(aLoop); + + if(0 != nRepeat && bVisibleWhenStopped) + { + // move from outside to center + drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, bForward ? 0.0 : 1.0, 0.5); + rAnimList.append(aOutIn); + + // add timing for staying at the end + drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5); + rAnimList.append(aEnd); + } +} + +static void impCreateAlternateTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, double fRelativeTextLength, bool bForward, double fTimeFullPath, double fFrequency) +{ + if(basegfx::fTools::more(fRelativeTextLength, 0.5)) + { + // this is the case when fTextLength > fFrameLength, text is bigger than animation frame. + // In that case, correct direction + bForward = !bForward; + } + + const double fStartPosition(bForward ? fRelativeTextLength : 1.0 - fRelativeTextLength); + const double fEndPosition(bForward ? 1.0 - fRelativeTextLength : fRelativeTextLength); + bool bVisibleWhenStarted(rSet.Get(SDRATTR_TEXT_ANISTARTINSIDE).GetValue()); + const sal_uInt32 nRepeat(rSet.Get(SDRATTR_TEXT_ANICOUNT).GetValue()); + + if(!bVisibleWhenStarted) + { + // move from outside to center + drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, bForward ? 0.0 : 1.0, 0.5); + rAnimList.append(aOutIn); + } + + // loop. In loop, move out and in again. fInnerMovePath may be negative when text is bigger then frame, + // so use absolute value + const double fInnerMovePath(fabs(1.0 - (fRelativeTextLength * 2.0))); + const double fTimeForInnerPath(fTimeFullPath * fInnerMovePath); + const double fHalfInnerPath(fTimeForInnerPath * 0.5); + const sal_uInt32 nDoubleRepeat(nRepeat / 2L); + + if(nDoubleRepeat || 0 == nRepeat) + { + // double forth and back loop + drawinglayer::animation::AnimationEntryLoop aLoop(nDoubleRepeat ? nDoubleRepeat : ENDLESS_LOOP); + drawinglayer::animation::AnimationEntryLinear aTime0(fHalfInnerPath, fFrequency, 0.5, fEndPosition); + aLoop.append(aTime0); + drawinglayer::animation::AnimationEntryLinear aTime1(fTimeForInnerPath, fFrequency, fEndPosition, fStartPosition); + aLoop.append(aTime1); + drawinglayer::animation::AnimationEntryLinear aTime2(fHalfInnerPath, fFrequency, fStartPosition, 0.5); + aLoop.append(aTime2); + rAnimList.append(aLoop); + } + + if(nRepeat % 2L) + { + // repeat is uneven, so we need one more forth and back to center + drawinglayer::animation::AnimationEntryLinear aTime0(fHalfInnerPath, fFrequency, 0.5, fEndPosition); + rAnimList.append(aTime0); + drawinglayer::animation::AnimationEntryLinear aTime1(fHalfInnerPath, fFrequency, fEndPosition, 0.5); + rAnimList.append(aTime1); + } + + if(0 == nRepeat) + return; + + bool bVisibleWhenStopped(rSet.Get(SDRATTR_TEXT_ANISTOPINSIDE).GetValue()); + if(bVisibleWhenStopped) + { + // add timing for staying at the end + drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5); + rAnimList.append(aEnd); + } + else + { + // move from center to outside + drawinglayer::animation::AnimationEntryLinear aInOut(fTimeFullPath * 0.5, fFrequency, 0.5, bForward ? 1.0 : 0.0); + rAnimList.append(aInOut); + } +} + +static void impCreateSlideTiming(const SfxItemSet& rSet, drawinglayer::animation::AnimationEntryList& rAnimList, bool bForward, double fTimeFullPath, double fFrequency) +{ + // move in from outside, start outside + const double fStartPosition(bForward ? 0.0 : 1.0); + const sal_uInt32 nRepeat(rSet.Get(SDRATTR_TEXT_ANICOUNT).GetValue()); + + // move from outside to center + drawinglayer::animation::AnimationEntryLinear aOutIn(fTimeFullPath * 0.5, fFrequency, fStartPosition, 0.5); + rAnimList.append(aOutIn); + + // loop. In loop, move out and in again + if(nRepeat > 1 || 0 == nRepeat) + { + drawinglayer::animation::AnimationEntryLoop aLoop(nRepeat ? nRepeat - 1 : ENDLESS_LOOP); + drawinglayer::animation::AnimationEntryLinear aTime0(fTimeFullPath * 0.5, fFrequency, 0.5, fStartPosition); + aLoop.append(aTime0); + drawinglayer::animation::AnimationEntryLinear aTime1(fTimeFullPath * 0.5, fFrequency, fStartPosition, 0.5); + aLoop.append(aTime1); + rAnimList.append(aLoop); + } + + // always visible when stopped, so add timing for staying at the end when not endless + if(0 != nRepeat) + { + drawinglayer::animation::AnimationEntryFixed aEnd(ENDLESS_TIME, 0.5); + rAnimList.append(aEnd); + } +} + +void SdrTextObj::impGetScrollTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList, double fFrameLength, double fTextLength) const +{ + const SdrTextAniKind eAniKind(GetTextAniKind()); + + if(SdrTextAniKind::Scroll != eAniKind && SdrTextAniKind::Alternate != eAniKind && SdrTextAniKind::Slide != eAniKind) + return; + + // get data. Goal is to calculate fTimeFullPath which is the time needed to + // move animation from (0.0) to (1.0) state + const SfxItemSet& rSet = GetObjectItemSet(); + double fAnimationDelay(static_cast(rSet.Get(SDRATTR_TEXT_ANIDELAY).GetValue())); + double fSingleStepWidth(static_cast(rSet.Get(SDRATTR_TEXT_ANIAMOUNT).GetValue())); + const SdrTextAniDirection eDirection(GetTextAniDirection()); + const bool bForward(SdrTextAniDirection::Right == eDirection || SdrTextAniDirection::Down == eDirection); + + if(basegfx::fTools::equalZero(fAnimationDelay)) + { + // default to 1/20 second + fAnimationDelay = 50.0; + } + + if(basegfx::fTools::less(fSingleStepWidth, 0.0)) + { + // data is in pixels, convert to logic. Imply PIXEL_DPI dpi. + // It makes no sense to keep the view-transformation centered + // definitions, so get rid of them here. + fSingleStepWidth = (-fSingleStepWidth * (2540.0 / PIXEL_DPI)); + } + + if(basegfx::fTools::equalZero(fSingleStepWidth)) + { + // default to 1 millimeter + fSingleStepWidth = 100.0; + } + + // use the length of the full animation path and the number of steps + // to get the full path time + const double fFullPathLength(fFrameLength + fTextLength); + const double fNumberOfSteps(fFullPathLength / fSingleStepWidth); + double fTimeFullPath(fNumberOfSteps * fAnimationDelay); + + if(fTimeFullPath < fAnimationDelay) + { + fTimeFullPath = fAnimationDelay; + } + + switch(eAniKind) + { + case SdrTextAniKind::Scroll : + { + impCreateScrollTiming(rSet, rAnimList, bForward, fTimeFullPath, fAnimationDelay); + break; + } + case SdrTextAniKind::Alternate : + { + double fRelativeTextLength(fTextLength / (fFrameLength + fTextLength)); + impCreateAlternateTiming(rSet, rAnimList, fRelativeTextLength, bForward, fTimeFullPath, fAnimationDelay); + break; + } + case SdrTextAniKind::Slide : + { + impCreateSlideTiming(rSet, rAnimList, bForward, fTimeFullPath, fAnimationDelay); + break; + } + default : break; // SdrTextAniKind::NONE, SdrTextAniKind::Blink + } +} + +void SdrTextObj::impHandleChainingEventsDuringDecomposition(SdrOutliner &rOutliner) const +{ + if (GetTextChain()->GetNilChainingEvent(this)) + return; + + GetTextChain()->SetNilChainingEvent(this, true); + + TextChainFlow aTxtChainFlow(const_cast(this)); + bool bIsOverflow; + +#ifdef DBG_UTIL + // Some debug output + size_t nObjCount(getSdrPageFromSdrObject()->GetObjCount()); + for (size_t i = 0; i < nObjCount; i++) + { + SdrTextObj* pCurObj(DynCastSdrTextObj(getSdrPageFromSdrObject()->GetObj(i))); + if(pCurObj == this) + { + SAL_INFO("svx.chaining", "Working on TextBox " << i); + break; + } + } +#endif + + aTxtChainFlow.CheckForFlowEvents(&rOutliner); + + if (aTxtChainFlow.IsUnderflow() && !IsInEditMode()) + { + // underflow-induced overflow + aTxtChainFlow.ExecuteUnderflow(&rOutliner); + bIsOverflow = aTxtChainFlow.IsOverflow(); + } else { + // standard overflow (no underflow before) + bIsOverflow = aTxtChainFlow.IsOverflow(); + } + + if (bIsOverflow && !IsInEditMode()) { + // Initialize Chaining Outliner + SdrOutliner &rChainingOutl(getSdrModelFromSdrObject().GetChainingOutliner(this)); + ImpInitDrawOutliner( rChainingOutl ); + rChainingOutl.SetUpdateLayout(true); + // We must pass the chaining outliner otherwise we would mess up decomposition + aTxtChainFlow.ExecuteOverflow(&rOutliner, &rChainingOutl); + } + + GetTextChain()->SetNilChainingEvent(this, false); +} + +void SdrTextObj::impDecomposeChainedTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrChainedTextPrimitive2D& rSdrChainedTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + // decompose matrix to have position and size of text + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rSdrChainedTextPrimitive.getTextRangeTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // use B2DRange aAnchorTextRange for calculations + basegfx::B2DRange aAnchorTextRange(aTranslate); + aAnchorTextRange.expand(aTranslate + aScale); + + // prepare outliner + const SfxItemSet& rTextItemSet = rSdrChainedTextPrimitive.getSdrText()->GetItemSet(); + SolarMutexGuard aSolarGuard; + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + + SdrTextVertAdjust eVAdj = GetTextVerticalAdjust(rTextItemSet); + SdrTextHorzAdjust eHAdj = GetTextHorizontalAdjust(rTextItemSet); + const EEControlBits nOriginalControlWord(rOutliner.GetControlWord()); + const Size aNullSize; + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + rOutliner.SetControlWord(nOriginalControlWord|EEControlBits::AUTOPAGESIZE|EEControlBits::STRETCHING); + rOutliner.SetMinAutoPaperSize(aNullSize); + rOutliner.SetMaxAutoPaperSize(Size(1000000,1000000)); + + // add one to range sizes to get back to the old Rectangle and outliner measurements + const sal_uInt32 nAnchorTextWidth(FRound(aAnchorTextRange.getWidth() + 1)); + const sal_uInt32 nAnchorTextHeight(FRound(aAnchorTextRange.getHeight() + 1)); + + // Text + const OutlinerParaObject* pOutlinerParaObject = rSdrChainedTextPrimitive.getSdrText()->GetOutlinerParaObject(); + OSL_ENSURE(pOutlinerParaObject, "impDecomposeBlockTextPrimitive used with no OutlinerParaObject (!)"); + + const bool bVerticalWriting(pOutlinerParaObject->IsEffectivelyVertical()); + const bool bTopToBottom(pOutlinerParaObject->IsTopToBottom()); + const Size aAnchorTextSize(Size(nAnchorTextWidth, nAnchorTextHeight)); + + if(IsTextFrame()) + { + rOutliner.SetMaxAutoPaperSize(aAnchorTextSize); + } + + if(SDRTEXTHORZADJUST_BLOCK == eHAdj && !bVerticalWriting) + { + rOutliner.SetMinAutoPaperSize(Size(nAnchorTextWidth, 0)); + } + + if(SDRTEXTVERTADJUST_BLOCK == eVAdj && bVerticalWriting) + { + rOutliner.SetMinAutoPaperSize(Size(0, nAnchorTextHeight)); + } + + rOutliner.SetPaperSize(aNullSize); + rOutliner.SetUpdateLayout(true); + // Sets original text + rOutliner.SetText(*pOutlinerParaObject); + + /* Begin overflow/underflow handling */ + + impHandleChainingEventsDuringDecomposition(rOutliner); + + /* End overflow/underflow handling */ + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + // now get back the layouted text size from outliner + const Size aOutlinerTextSize(rOutliner.GetPaperSize()); + const basegfx::B2DVector aOutlinerScale(aOutlinerTextSize.Width(), aOutlinerTextSize.Height()); + basegfx::B2DVector aAdjustTranslate(0.0, 0.0); + + // correct horizontal translation using the now known text size + if(SDRTEXTHORZADJUST_CENTER == eHAdj || SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + const double fFree(aAnchorTextRange.getWidth() - aOutlinerScale.getX()); + + if(SDRTEXTHORZADJUST_CENTER == eHAdj) + { + aAdjustTranslate.setX(fFree / 2.0); + } + + if(SDRTEXTHORZADJUST_RIGHT == eHAdj) + { + aAdjustTranslate.setX(fFree); + } + } + + // correct vertical translation using the now known text size + if(SDRTEXTVERTADJUST_CENTER == eVAdj || SDRTEXTVERTADJUST_BOTTOM == eVAdj) + { + const double fFree(aAnchorTextRange.getHeight() - aOutlinerScale.getY()); + + if(SDRTEXTVERTADJUST_CENTER == eVAdj) + { + aAdjustTranslate.setY(fFree / 2.0); + } + + if(SDRTEXTVERTADJUST_BOTTOM == eVAdj) + { + aAdjustTranslate.setY(fFree); + } + } + + // prepare matrices to apply to newly created primitives. aNewTransformA + // will get coordinates in aOutlinerScale size and positive in X, Y. + basegfx::B2DHomMatrix aNewTransformA; + basegfx::B2DHomMatrix aNewTransformB; + + // translate relative to given primitive to get same rotation and shear + // as the master shape we are working on. For vertical, use the top-right + // corner + const double fStartInX(bVerticalWriting && bTopToBottom ? aAdjustTranslate.getX() + aOutlinerScale.getX() : aAdjustTranslate.getX()); + const double fStartInY(bVerticalWriting && !bTopToBottom ? aAdjustTranslate.getY() + aOutlinerScale.getY() : aAdjustTranslate.getY()); + aNewTransformA.translate(fStartInX, fStartInY); + + // mirroring. We are now in aAnchorTextRange sizes. When mirroring in X and Y, + // move the null point which was top left to bottom right. + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + aNewTransformB.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0); + + // in-between the translations of the single primitives will take place. Afterwards, + // the object's transformations need to be applied + aNewTransformB.shearX(fShearX); + aNewTransformB.rotate(fRotate); + aNewTransformB.translate(aTranslate.getX(), aTranslate.getY()); + + basegfx::B2DRange aClipRange; + + // now break up text primitives. + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeBlockTextPrimitive(aNewTransformA, aNewTransformB, aClipRange); + + // cleanup outliner + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + rOutliner.SetControlWord(nOriginalControlWord); + + rTarget = aConverter.extractPrimitive2DSequence(); +} + +// Direct decomposer for text visualization when you already have a prepared +// Outliner containing all the needed information +void SdrTextObj::impDecomposeBlockTextPrimitiveDirect( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + SdrOutliner& rOutliner, + const basegfx::B2DHomMatrix& rNewTransformA, + const basegfx::B2DHomMatrix& rNewTransformB, + const basegfx::B2DRange& rClipRange) +{ + impTextBreakupHandler aConverter(rOutliner); + aConverter.decomposeBlockTextPrimitive(rNewTransformA, rNewTransformB, rClipRange); + rTarget.append(aConverter.extractPrimitive2DSequence()); +} + +double SdrTextObj::GetCameraZRotation() const +{ + const css::uno::Any* pAny; + double fTextCameraZRotateAngle = 0.0; + const SfxItemSet& rSet = GetObjectItemSet(); + const SdrCustomShapeGeometryItem& rGeometryItem(rSet.Get(SDRATTR_CUSTOMSHAPE_GEOMETRY)); + + pAny = rGeometryItem.GetPropertyValueByName("TextCameraZRotateAngle"); + + if ( pAny ) + *pAny >>= fTextCameraZRotateAngle; + + return fTextCameraZRotateAngle; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotextpathdecomposition.cxx b/svx/source/svdraw/svdotextpathdecomposition.cxx new file mode 100644 index 0000000000..7537625b2a --- /dev/null +++ b/svx/source/svdraw/svdotextpathdecomposition.cxx @@ -0,0 +1,748 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// primitive decomposition helpers +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +// PathTextPortion helper + +namespace +{ + class impPathTextPortion + { + basegfx::B2DVector maOffset; + OUString maText; + sal_Int32 mnTextStart; + sal_Int32 mnTextLength; + sal_Int32 mnParagraph; + SvxFont maFont; + ::std::vector< double > maDblDXArray; // double DXArray, font size independent -> unit coordinate system + ::std::vector< sal_Bool > maKashidaArray; + lang::Locale maLocale; + + bool mbRTL : 1; + + public: + explicit impPathTextPortion(const DrawPortionInfo& rInfo) + : maOffset(rInfo.mrStartPos.X(), rInfo.mrStartPos.Y()), + maText(rInfo.maText), + mnTextStart(rInfo.mnTextStart), + mnTextLength(rInfo.mnTextLen), + mnParagraph(rInfo.mnPara), + maFont(rInfo.mrFont), + maKashidaArray(rInfo.mpKashidaArray.begin(), rInfo.mpKashidaArray.end()), + maLocale(rInfo.mpLocale ? *rInfo.mpLocale : lang::Locale()), + mbRTL(!rInfo.mrFont.IsVertical() && rInfo.IsRTL()) + { + if(mnTextLength && !rInfo.mpDXArray.empty()) + { + maDblDXArray.reserve(mnTextLength); + + for(sal_Int32 a=0; a < mnTextLength; a++) + { + maDblDXArray.push_back(static_cast(rInfo.mpDXArray[a])); + } + } + } + + // for ::std::sort + bool operator<(const impPathTextPortion& rComp) const + { + if(mnParagraph < rComp.mnParagraph) + { + return true; + } + + if(maOffset.getX() < rComp.maOffset.getX()) + { + return true; + } + + return (maOffset.getY() < rComp.maOffset.getY()); + } + + const OUString& getText() const { return maText; } + sal_Int32 getTextStart() const { return mnTextStart; } + sal_Int32 getTextLength() const { return mnTextLength; } + sal_Int32 getParagraph() const { return mnParagraph; } + const SvxFont& getFont() const { return maFont; } + bool isRTL() const { return mbRTL; } + const ::std::vector< double >& getDoubleDXArray() const { return maDblDXArray; } + const ::std::vector< sal_Bool >& getKashidaArray() const { return maKashidaArray; } + const lang::Locale& getLocale() const { return maLocale; } + + sal_Int32 getPortionIndex(sal_Int32 nIndex, sal_Int32 nLength) const + { + if(mbRTL) + { + return (mnTextStart + (mnTextLength - (nIndex + nLength))); + } + else + { + return (mnTextStart + nIndex); + } + } + + double getDisplayLength(sal_Int32 nIndex, sal_Int32 nLength) const + { + drawinglayer::primitive2d::TextLayouterDevice aTextLayouter; + double fRetval(0.0); + + if(maFont.IsVertical()) + { + fRetval = aTextLayouter.getTextHeight() * static_cast(nLength); + } + else + { + fRetval = aTextLayouter.getTextWidth(maText, getPortionIndex(nIndex, nLength), nLength); + } + + return fRetval; + } + }; +} // end of anonymous namespace + + +// TextBreakup helper + +namespace +{ + class impTextBreakupHandler + { + SdrOutliner& mrOutliner; + ::std::vector< impPathTextPortion > maPathTextPortions; + + DECL_LINK(decompositionPathTextPrimitive, DrawPortionInfo*, void ); + + public: + explicit impTextBreakupHandler(SdrOutliner& rOutliner) + : mrOutliner(rOutliner) + { + } + + const ::std::vector< impPathTextPortion >& decompositionPathTextPrimitive() + { + // strip portions to maPathTextPortions + mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decompositionPathTextPrimitive)); + mrOutliner.StripPortions(); + + if(!maPathTextPortions.empty()) + { + // sort portions by paragraph, x and y + ::std::sort(maPathTextPortions.begin(), maPathTextPortions.end()); + } + + return maPathTextPortions; + } + }; + + IMPL_LINK(impTextBreakupHandler, decompositionPathTextPrimitive, DrawPortionInfo*, pInfo, void) + { + maPathTextPortions.emplace_back(*pInfo); + } +} // end of anonymous namespace + + +// TextBreakup one poly and one paragraph helper + +namespace +{ + class impPolygonParagraphHandler + { + const drawinglayer::attribute::SdrFormTextAttribute maSdrFormTextAttribute; // FormText parameters + drawinglayer::primitive2d::Primitive2DContainer& mrDecomposition; // destination primitive list + drawinglayer::primitive2d::Primitive2DContainer& mrShadowDecomposition; // destination primitive list for shadow + uno::Reference mxBreak; // break iterator + + static double getParagraphTextLength(const ::std::vector< const impPathTextPortion* >& rTextPortions) + { + drawinglayer::primitive2d::TextLayouterDevice aTextLayouter; + double fRetval(0.0); + + for(const impPathTextPortion* pCandidate : rTextPortions) + { + if(pCandidate && pCandidate->getTextLength()) + { + aTextLayouter.setFont(pCandidate->getFont()); + fRetval += pCandidate->getDisplayLength(0, pCandidate->getTextLength()); + } + } + + return fRetval; + } + + sal_Int32 getNextGlyphLen(const impPathTextPortion* pCandidate, sal_Int32 nPosition, const lang::Locale& rFontLocale) + { + sal_Int32 nNextGlyphLen(1); + + if(mxBreak.is()) + { + sal_Int32 nDone(0); + nNextGlyphLen = mxBreak->nextCharacters(pCandidate->getText(), nPosition, + rFontLocale, i18n::CharacterIteratorMode::SKIPCELL, 1, nDone) - nPosition; + } + + return nNextGlyphLen; + } + + public: + impPolygonParagraphHandler( + drawinglayer::attribute::SdrFormTextAttribute aSdrFormTextAttribute, + drawinglayer::primitive2d::Primitive2DContainer& rDecomposition, + drawinglayer::primitive2d::Primitive2DContainer& rShadowDecomposition) + : maSdrFormTextAttribute(std::move(aSdrFormTextAttribute)), + mrDecomposition(rDecomposition), + mrShadowDecomposition(rShadowDecomposition) + { + // prepare BreakIterator + uno::Reference xContext = ::comphelper::getProcessComponentContext(); + mxBreak = i18n::BreakIterator::create(xContext); + } + + void HandlePair(const basegfx::B2DPolygon& rPolygonCandidate, const ::std::vector< const impPathTextPortion* >& rTextPortions) + { + // prepare polygon geometry, take into account as many parameters as possible + basegfx::B2DPolygon aPolygonCandidate(rPolygonCandidate); + const double fPolyLength(basegfx::utils::getLength(aPolygonCandidate)); + double fPolyEnd(fPolyLength); + double fPolyStart(0.0); + double fAutosizeScaleFactor(1.0); + bool bAutosizeScale(false); + + if(maSdrFormTextAttribute.getFormTextMirror()) + { + aPolygonCandidate.flip(); + } + + if(maSdrFormTextAttribute.getFormTextStart() + && (XFormTextAdjust::Left == maSdrFormTextAttribute.getFormTextAdjust() + || XFormTextAdjust::Right == maSdrFormTextAttribute.getFormTextAdjust())) + { + if(XFormTextAdjust::Left == maSdrFormTextAttribute.getFormTextAdjust()) + { + fPolyStart += maSdrFormTextAttribute.getFormTextStart(); + + if(fPolyStart > fPolyEnd) + { + fPolyStart = fPolyEnd; + } + } + else + { + fPolyEnd -= maSdrFormTextAttribute.getFormTextStart(); + + if(fPolyEnd < fPolyStart) + { + fPolyEnd = fPolyStart; + } + } + } + + if(XFormTextAdjust::Left != maSdrFormTextAttribute.getFormTextAdjust()) + { + // calculate total text length of this paragraph, some layout needs to be done + const double fParagraphTextLength(getParagraphTextLength(rTextPortions)); + + // check if text is too long for paragraph. If yes, handle as if left aligned (default), + // but still take care of XFormTextAdjust::AutoSize in that case + const bool bTextTooLong(fParagraphTextLength > (fPolyEnd - fPolyStart)); + + if(XFormTextAdjust::Right == maSdrFormTextAttribute.getFormTextAdjust()) + { + if(!bTextTooLong) + { + // if right aligned, add difference to polygon start + fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength); + } + } + else if(XFormTextAdjust::Center == maSdrFormTextAttribute.getFormTextAdjust()) + { + if(!bTextTooLong) + { + // if centered, add half of difference to polygon start + fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength) / 2.0; + } + } + else if(XFormTextAdjust::AutoSize == maSdrFormTextAttribute.getFormTextAdjust()) + { + // if scale, prepare scale factor between curve length and text length + if(0.0 != fParagraphTextLength) + { + fAutosizeScaleFactor = (fPolyEnd - fPolyStart) / fParagraphTextLength; + bAutosizeScale = true; + } + } + } + + // handle text portions for this paragraph + for(auto a = rTextPortions.begin(); a != rTextPortions.end() && fPolyStart < fPolyEnd; ++a) + { + const impPathTextPortion* pCandidate = *a; + basegfx::B2DVector aFontScaling; + + if(pCandidate && pCandidate->getTextLength()) + { + const drawinglayer::attribute::FontAttribute aCandidateFontAttribute( + drawinglayer::primitive2d::getFontAttributeFromVclFont( + aFontScaling, + pCandidate->getFont(), + pCandidate->isRTL(), + false)); + + drawinglayer::primitive2d::TextLayouterDevice aTextLayouter; + aTextLayouter.setFont(pCandidate->getFont()); + sal_Int32 nUsedTextLength(0); + + while(nUsedTextLength < pCandidate->getTextLength() && fPolyStart < fPolyEnd) + { + sal_Int32 nNextGlyphLen(getNextGlyphLen(pCandidate, pCandidate->getTextStart() + nUsedTextLength, pCandidate->getLocale())); + + // prepare portion length. Takes RTL sections into account. + double fPortionLength(pCandidate->getDisplayLength(nUsedTextLength, nNextGlyphLen)); + + if(bAutosizeScale) + { + // when autosize scaling, expand portion length + fPortionLength *= fAutosizeScaleFactor; + } + + // create transformation + basegfx::B2DHomMatrix aNewTransformA, aNewTransformB, aNewShadowTransform; + basegfx::B2DPoint aStartPos(basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart, fPolyLength)); + basegfx::B2DPoint aEndPos(aStartPos); + + // add font scaling + aNewTransformA.scale(aFontScaling.getX(), aFontScaling.getY()); + + // prepare scaling of text primitive + if(bAutosizeScale) + { + // when autosize scaling, expand text primitive scaling to it + aNewTransformA.scale(fAutosizeScaleFactor, fAutosizeScaleFactor); + } + + // eventually create shadow primitives from aDecomposition and add to rDecomposition + const bool bShadow(XFormTextShadow::NONE != maSdrFormTextAttribute.getFormTextShadow()); + + if(bShadow) + { + if(XFormTextShadow::Normal == maSdrFormTextAttribute.getFormTextShadow()) + { + aNewShadowTransform.translate( + maSdrFormTextAttribute.getFormTextShdwXVal(), + -maSdrFormTextAttribute.getFormTextShdwYVal()); + } + else // XFormTextShadow::Slant + { + double fScaleValue(maSdrFormTextAttribute.getFormTextShdwYVal() / 100.0); + double fShearValue(-basegfx::deg2rad<10>(maSdrFormTextAttribute.getFormTextShdwXVal())); + + aNewShadowTransform.scale(1.0, fScaleValue); + aNewShadowTransform.shearX(sin(fShearValue)); + aNewShadowTransform.scale(1.0, cos(fShearValue)); + } + } + + switch(maSdrFormTextAttribute.getFormTextStyle()) + { + case XFormTextStyle::Rotate : + { + aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength); + const basegfx::B2DVector aDirection(aEndPos - aStartPos); + aNewTransformB.rotate(atan2(aDirection.getY(), aDirection.getX())); + aNewTransformB.translate(aStartPos.getX(), aStartPos.getY()); + + break; + } + case XFormTextStyle::Upright : + { + aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY()); + + break; + } + case XFormTextStyle::SlantX : + { + aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength); + const basegfx::B2DVector aDirection(aEndPos - aStartPos); + const double fShearValue(atan2(aDirection.getY(), aDirection.getX())); + const double fSin(sin(fShearValue)); + const double fCos(cos(fShearValue)); + + aNewTransformB.shearX(-fSin); + + // Scale may lead to objects without height since fCos == 0.0 is possible. + // Renderers need to handle that, it's not a forbidden value and does not + // need to be avoided + aNewTransformB.scale(1.0, fCos); + aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY()); + + break; + } + case XFormTextStyle::SlantY : + { + aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength); + const basegfx::B2DVector aDirection(aEndPos - aStartPos); + const double fShearValue(atan2(aDirection.getY(), aDirection.getX())); + const double fCos(cos(fShearValue)); + const double fTan(tan(fShearValue)); + + // shear to 'stand' on the curve + aNewTransformB.shearY(fTan); + + // scale in X to make as tight as needed. As with XFT_SLANT_X, this may + // lead to primitives without width which the renderers will handle + aNewTransformA.scale(fCos, 1.0); + + aNewTransformB.translate(aStartPos.getX(), aStartPos.getY()); + + break; + } + default : break; // XFormTextStyle::NONE + } + + // distance from path? + if(maSdrFormTextAttribute.getFormTextDistance()) + { + if(aEndPos.equal(aStartPos)) + { + aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength); + } + + // use back vector (aStartPos - aEndPos) here to get mirrored perpendicular as in old stuff + const basegfx::B2DVector aPerpendicular( + basegfx::getNormalizedPerpendicular(aStartPos - aEndPos) * + maSdrFormTextAttribute.getFormTextDistance()); + aNewTransformB.translate(aPerpendicular.getX(), aPerpendicular.getY()); + } + + if(!pCandidate->getText().isEmpty() && nNextGlyphLen) + { + const sal_Int32 nPortionIndex(pCandidate->getPortionIndex(nUsedTextLength, nNextGlyphLen)); + ::std::vector< double > aNewDXArray; + + if(nNextGlyphLen > 1 && !pCandidate->getDoubleDXArray().empty()) + { + // copy DXArray for portion + aNewDXArray.insert( + aNewDXArray.begin(), + pCandidate->getDoubleDXArray().begin() + nPortionIndex, + pCandidate->getDoubleDXArray().begin() + (nPortionIndex + nNextGlyphLen)); + + if(nPortionIndex > 0) + { + // adapt to portion start + double fDXOffset= *(pCandidate->getDoubleDXArray().begin() + (nPortionIndex - 1)); + ::std::transform( + aNewDXArray.begin(), aNewDXArray.end(), + aNewDXArray.begin(), [fDXOffset](double x) { return x - fDXOffset; }); + } + + if(bAutosizeScale) + { + // when autosize scaling, adapt to DXArray, too + ::std::transform( + aNewDXArray.begin(), aNewDXArray.end(), + aNewDXArray.begin(), [fAutosizeScaleFactor](double x) { return x * fAutosizeScaleFactor; }); + } + } + + if(bShadow) + { + // shadow primitive creation + const Color aShadowColor(maSdrFormTextAttribute.getFormTextShdwColor()); + const basegfx::BColor aRGBShadowColor(aShadowColor.getBColor()); + + mrShadowDecomposition.push_back( + new drawinglayer::primitive2d::TextSimplePortionPrimitive2D( + aNewTransformB * aNewShadowTransform * aNewTransformA, + pCandidate->getText(), + nPortionIndex, + nNextGlyphLen, + std::vector(aNewDXArray), + std::vector(pCandidate->getKashidaArray()), + aCandidateFontAttribute, + pCandidate->getLocale(), + aRGBShadowColor) ); + } + + { + // primitive creation + const Color aColor(pCandidate->getFont().GetColor()); + const basegfx::BColor aRGBColor(aColor.getBColor()); + + mrDecomposition.push_back( + new drawinglayer::primitive2d::TextSimplePortionPrimitive2D( + aNewTransformB * aNewTransformA, + pCandidate->getText(), + nPortionIndex, + nNextGlyphLen, + std::move(aNewDXArray), + std::vector(pCandidate->getKashidaArray()), + aCandidateFontAttribute, + pCandidate->getLocale(), + aRGBColor) ); + } + } + + // consume from portion + nUsedTextLength += nNextGlyphLen; + + // consume from polygon + fPolyStart += fPortionLength; + } + } + } + } + }; +} // end of anonymous namespace + + +// primitive decomposition helpers + +namespace +{ + void impAddPolygonStrokePrimitives( + const basegfx::B2DPolyPolygonVector& rB2DPolyPolyVector, + const basegfx::B2DHomMatrix& rTransform, + const drawinglayer::attribute::LineAttribute& rLineAttribute, + const drawinglayer::attribute::StrokeAttribute& rStrokeAttribute, + drawinglayer::primitive2d::Primitive2DContainer& rTarget) + { + for(const auto& rB2DPolyPolygon : rB2DPolyPolyVector) + { + // prepare PolyPolygons + basegfx::B2DPolyPolygon aB2DPolyPolygon = rB2DPolyPolygon; + aB2DPolyPolygon.transform(rTransform); + + for(auto const& rPolygon : std::as_const(aB2DPolyPolygon)) + { + // create one primitive per polygon + rTarget.push_back( + new drawinglayer::primitive2d::PolygonStrokePrimitive2D( + rPolygon, rLineAttribute, rStrokeAttribute) ); + } + } + } + + drawinglayer::primitive2d::Primitive2DContainer impAddPathTextOutlines( + const drawinglayer::primitive2d::Primitive2DContainer& rSource, + const drawinglayer::attribute::SdrFormTextOutlineAttribute& rOutlineAttribute) + { + drawinglayer::primitive2d::Primitive2DContainer aNewPrimitives; + + for(const drawinglayer::primitive2d::Primitive2DReference& a : rSource) + { + const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pTextCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(a.get()); + + if(pTextCandidate) + { + basegfx::B2DPolyPolygonVector aB2DPolyPolyVector; + basegfx::B2DHomMatrix aPolygonTransform; + + // get text outlines and their object transformation + pTextCandidate->getTextOutlinesAndTransformation(aB2DPolyPolyVector, aPolygonTransform); + + if(!aB2DPolyPolyVector.empty()) + { + // create stroke primitives + drawinglayer::primitive2d::Primitive2DContainer aStrokePrimitives; + impAddPolygonStrokePrimitives( + aB2DPolyPolyVector, + aPolygonTransform, + rOutlineAttribute.getLineAttribute(), + rOutlineAttribute.getStrokeAttribute(), + aStrokePrimitives); + const sal_uInt32 nStrokeCount(aStrokePrimitives.size()); + + if(nStrokeCount) + { + if(rOutlineAttribute.getTransparence()) + { + // create UnifiedTransparencePrimitive2D + aNewPrimitives.push_back( + new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( + std::move(aStrokePrimitives), + static_cast(rOutlineAttribute.getTransparence()) / 100.0) ); + } + else + { + // add polygons to rDecomposition as polygonStrokePrimitives + aNewPrimitives.append( std::move(aStrokePrimitives) ); + } + } + } + } + } + + return aNewPrimitives; + } +} // end of anonymous namespace + + +// primitive decomposition + +void SdrTextObj::impDecomposePathTextPrimitive( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, + const drawinglayer::primitive2d::SdrPathTextPrimitive2D& rSdrPathTextPrimitive, + const drawinglayer::geometry::ViewInformation2D& aViewInformation) const +{ + drawinglayer::primitive2d::Primitive2DContainer aRetvalA; + drawinglayer::primitive2d::Primitive2DContainer aRetvalB; + + // prepare outliner + SdrOutliner& rOutliner = ImpGetDrawOutliner(); + rOutliner.SetUpdateLayout(true); + rOutliner.Clear(); + rOutliner.SetPaperSize(Size(LONG_MAX,LONG_MAX)); + rOutliner.SetText(rSdrPathTextPrimitive.getOutlinerParaObject()); + + // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition + rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage())); + + // now break up to text portions + impTextBreakupHandler aConverter(rOutliner); + const ::std::vector< impPathTextPortion > rPathTextPortions = aConverter.decompositionPathTextPrimitive(); + + if(!rPathTextPortions.empty()) + { + // get FormText and polygon values + const drawinglayer::attribute::SdrFormTextAttribute& rFormTextAttribute = rSdrPathTextPrimitive.getSdrFormTextAttribute(); + const basegfx::B2DPolyPolygon& rPathPolyPolygon(rSdrPathTextPrimitive.getPathPolyPolygon()); + + // get loop count + sal_uInt32 nLoopCount(rPathPolyPolygon.count()); + + if(o3tl::make_unsigned(rOutliner.GetParagraphCount()) < nLoopCount) + { + nLoopCount = rOutliner.GetParagraphCount(); + } + + if(nLoopCount) + { + // prepare common decomposition stuff + drawinglayer::primitive2d::Primitive2DContainer aRegularDecomposition; + drawinglayer::primitive2d::Primitive2DContainer aShadowDecomposition; + impPolygonParagraphHandler aPolygonParagraphHandler( + rFormTextAttribute, + aRegularDecomposition, + aShadowDecomposition); + sal_uInt32 a; + + for(a = 0; a < nLoopCount; a++) + { + // filter text portions for this paragraph + ::std::vector< const impPathTextPortion* > aParagraphTextPortions; + + for(const auto & rCandidate : rPathTextPortions) + { + if(static_cast(rCandidate.getParagraph()) == a) + { + aParagraphTextPortions.push_back(&rCandidate); + } + } + + // handle data pair polygon/ParagraphTextPortions + if(!aParagraphTextPortions.empty()) + { + aPolygonParagraphHandler.HandlePair(rPathPolyPolygon.getB2DPolygon(a), aParagraphTextPortions); + } + } + + const sal_uInt32 nShadowCount(aShadowDecomposition.size()); + const sal_uInt32 nRegularCount(aRegularDecomposition.size()); + + if(nShadowCount) + { + // add shadow primitives to decomposition + + // if necessary, add shadow outlines + if(rFormTextAttribute.getFormTextOutline() + && !rFormTextAttribute.getShadowOutline().isDefault()) + { + aRetvalA = aShadowDecomposition; + const drawinglayer::primitive2d::Primitive2DContainer aOutlines( + impAddPathTextOutlines( + aShadowDecomposition, + rFormTextAttribute.getShadowOutline())); + + aRetvalA.append(aOutlines); + } + else + aRetvalA = std::move(aShadowDecomposition); + } + + if(nRegularCount) + { + // add normal primitives to decomposition + + // if necessary, add outlines + if(rFormTextAttribute.getFormTextOutline() + && !rFormTextAttribute.getOutline().isDefault()) + { + aRetvalB = aRegularDecomposition; + const drawinglayer::primitive2d::Primitive2DContainer aOutlines( + impAddPathTextOutlines( + aRegularDecomposition, + rFormTextAttribute.getOutline())); + + aRetvalB.append(aOutlines); + } + else + aRetvalB = std::move(aRegularDecomposition); + } + } + } + + // clean up outliner + rOutliner.SetDrawPortionHdl(Link()); + rOutliner.Clear(); + rOutliner.setVisualizedPage(nullptr); + + // concatenate all results + rTarget.append(std::move(aRetvalA)); + rTarget.append(std::move(aRetvalB)); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxat.cxx b/svx/source/svdraw/svdotxat.cxx new file mode 100644 index 0000000000..4957a4fe98 --- /dev/null +++ b/svx/source/svdraw/svdotxat.cxx @@ -0,0 +1,458 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include + +namespace { +// The style family which is appended to the style names is padded to this many characters. +const short PADDING_LENGTH_FOR_STYLE_FAMILY = 5; +// this character will be used to pad the style families when they are appended to the style names +const char PADDING_CHARACTER_FOR_STYLE_FAMILY = ' '; +} + +bool SdrTextObj::AdjustTextFrameWidthAndHeight( tools::Rectangle& rR, bool bHgt, bool bWdt ) const +{ + if (!mbTextFrame) + // Not a text frame. Bail out. + return false; + + if (rR.IsEmpty()) + // Empty rectangle. + return false; + + bool bFitToSize = IsFitToSize(); + if (bFitToSize) + return false; + + bool bWdtGrow = bWdt && IsAutoGrowWidth(); + bool bHgtGrow = bHgt && IsAutoGrowHeight(); + if (!bWdtGrow && !bHgtGrow) + // Not supposed to auto-adjust width or height. + return false; + + SdrTextAniKind eAniKind = GetTextAniKind(); + SdrTextAniDirection eAniDir = GetTextAniDirection(); + + bool bScroll = eAniKind == SdrTextAniKind::Scroll || eAniKind == SdrTextAniKind::Alternate || eAniKind == SdrTextAniKind::Slide; + bool bHScroll = bScroll && (eAniDir == SdrTextAniDirection::Left || eAniDir == SdrTextAniDirection::Right); + bool bVScroll = bScroll && (eAniDir == SdrTextAniDirection::Up || eAniDir == SdrTextAniDirection::Down); + + tools::Rectangle aOldRect = rR; + tools::Long nHgt = 0, nMinHgt = 0, nMaxHgt = 0; + tools::Long nWdt = 0, nMinWdt = 0, nMaxWdt = 0; + + Size aNewSize = rR.GetSize(); + aNewSize.AdjustWidth( -1 ); aNewSize.AdjustHeight( -1 ); + + Size aMaxSiz(100000, 100000); + Size aTmpSiz(getSdrModelFromSdrObject().GetMaxObjSize()); + + if (aTmpSiz.Width()) + aMaxSiz.setWidth( aTmpSiz.Width() ); + if (aTmpSiz.Height()) + aMaxSiz.setHeight( aTmpSiz.Height() ); + + if (bWdtGrow) + { + nMinWdt = GetMinTextFrameWidth(); + nMaxWdt = GetMaxTextFrameWidth(); + if (nMaxWdt == 0 || nMaxWdt > aMaxSiz.Width()) + nMaxWdt = aMaxSiz.Width(); + if (nMinWdt <= 0) + nMinWdt = 1; + + aNewSize.setWidth( nMaxWdt ); + } + + if (bHgtGrow) + { + nMinHgt = GetMinTextFrameHeight(); + nMaxHgt = GetMaxTextFrameHeight(); + if (nMaxHgt == 0 || nMaxHgt > aMaxSiz.Height()) + nMaxHgt = aMaxSiz.Height(); + if (nMinHgt <= 0) + nMinHgt = 1; + + aNewSize.setHeight( nMaxHgt ); + } + + tools::Long nHDist = GetTextLeftDistance() + GetTextRightDistance(); + tools::Long nVDist = GetTextUpperDistance() + GetTextLowerDistance(); + aNewSize.AdjustWidth( -nHDist ); + aNewSize.AdjustHeight( -nVDist ); + + if (aNewSize.Width() < 2) + aNewSize.setWidth( 2 ); + if (aNewSize.Height() < 2) + aNewSize.setHeight( 2 ); + + if (!IsInEditMode()) + { + if (bHScroll) + aNewSize.setWidth( 0x0FFFFFFF ); // don't break ticker text + if (bVScroll) + aNewSize.setHeight( 0x0FFFFFFF ); + } + + if (mpEditingOutliner) + { + mpEditingOutliner->SetMaxAutoPaperSize(aNewSize); + if (bWdtGrow) + { + Size aSiz2(mpEditingOutliner->CalcTextSize()); + nWdt = aSiz2.Width() + 1; // a little tolerance + if (bHgtGrow) + nHgt = aSiz2.Height() + 1; // a little tolerance + } + else + { + nHgt = mpEditingOutliner->GetTextHeight() + 1; // a little tolerance + } + } + else + { + Outliner& rOutliner = ImpGetDrawOutliner(); + rOutliner.SetPaperSize(aNewSize); + rOutliner.SetUpdateLayout(true); + // TODO: add the optimization with bPortionInfoChecked etc. here + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if (pOutlinerParaObject) + { + rOutliner.SetText(*pOutlinerParaObject); + rOutliner.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + } + + if (bWdtGrow) + { + Size aSiz2(rOutliner.CalcTextSize()); + nWdt = aSiz2.Width() + 1; // a little tolerance + if (bHgtGrow) + nHgt = aSiz2.Height() + 1; // a little tolerance + } + else + { + nHgt = rOutliner.GetTextHeight() + 1; // a little tolerance + } + rOutliner.Clear(); + } + + if (nWdt < nMinWdt) + nWdt = nMinWdt; + if (nWdt > nMaxWdt) + nWdt = nMaxWdt; + nWdt += nHDist; + if (nWdt < 1) + nWdt = 1; // nHDist may be negative + if (nHgt < nMinHgt) + nHgt = nMinHgt; + if (nHgt > nMaxHgt) + nHgt = nMaxHgt; + nHgt += nVDist; + if (nHgt < 1) + nHgt = 1; // nVDist may be negative + tools::Long nWdtGrow = nWdt - (rR.Right() - rR.Left()); + tools::Long nHgtGrow = nHgt - (rR.Bottom() - rR.Top()); + + if (nWdtGrow == 0) + bWdtGrow = false; + if (nHgtGrow == 0) + bHgtGrow = false; + + if (!bWdtGrow && !bHgtGrow) + return false; + + if (bWdtGrow) + { + SdrTextHorzAdjust eHAdj = GetTextHorizontalAdjust(); + + if (eHAdj == SDRTEXTHORZADJUST_LEFT) + rR.AdjustRight(nWdtGrow ); + else if (eHAdj == SDRTEXTHORZADJUST_RIGHT) + rR.AdjustLeft( -nWdtGrow ); + else + { + tools::Long nWdtGrow2 = nWdtGrow / 2; + rR.AdjustLeft( -nWdtGrow2 ); + rR.SetRight( rR.Left() + nWdt ); + } + } + + if (bHgtGrow) + { + SdrTextVertAdjust eVAdj = GetTextVerticalAdjust(); + + if (eVAdj == SDRTEXTVERTADJUST_TOP) + rR.AdjustBottom(nHgtGrow ); + else if (eVAdj == SDRTEXTVERTADJUST_BOTTOM) + rR.AdjustTop( -nHgtGrow ); + else + { + tools::Long nHgtGrow2 = nHgtGrow / 2; + rR.AdjustTop( -nHgtGrow2 ); + rR.SetBottom( rR.Top() + nHgt ); + } + } + + if (maGeo.m_nRotationAngle) + { + // Object is rotated. + Point aD1(rR.TopLeft()); + aD1 -= aOldRect.TopLeft(); + Point aD2(aD1); + RotatePoint(aD2, Point(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + aD2 -= aD1; + rR.Move(aD2.X(), aD2.Y()); + } + + return true; +} + +bool SdrTextObj::NbcAdjustTextFrameWidthAndHeight(bool bHgt, bool bWdt) +{ + tools::Rectangle aRectangle(getRectangle()); + bool bRet = AdjustTextFrameWidthAndHeight(aRectangle, bHgt, bWdt); + setRectangle(aRectangle); + if (bRet) + { + SetBoundAndSnapRectsDirty(); + if (auto pRectObj = dynamic_cast(this)) { // this is a hack + pRectObj->SetXPolyDirty(); + } + if (auto pCaptionObj = dynamic_cast(this)) { // this is a hack + pCaptionObj->ImpRecalcTail(); + } + } + return bRet; +} + +bool SdrTextObj::AdjustTextFrameWidthAndHeight() +{ + tools::Rectangle aNewRect(getRectangle()); + bool bRet = AdjustTextFrameWidthAndHeight(aNewRect); + if (bRet) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + setRectangle(aNewRect); + SetBoundAndSnapRectsDirty(); + if (auto pRectObj = dynamic_cast(this)) { // this is a hack + pRectObj->SetXPolyDirty(); + } + bool bScPostIt = false; + if (auto pCaptionObj = dynamic_cast(this)) { // this is a hack + pCaptionObj->ImpRecalcTail(); + // tdf#114956, tdf#138549 use GetSpecialTextBoxShadow to recognize + // that this SdrCaption is for a ScPostit + bScPostIt = pCaptionObj->GetSpecialTextBoxShadow(); + } + + // to not slow down EditView visualization on Overlay (see + // TextEditOverlayObject) it is necessary to suppress the + // Invalidates for the deep repaint when the size of the + // TextFrame changed (AdjustTextFrameWidthAndHeight returned + // true). The ObjectChanges are valid, invalidate will be + // done on EndTextEdit anyways + const bool bSuppressChangeWhenEditOnOverlay( + IsInEditMode() && + GetTextEditOutliner() && + GetTextEditOutliner()->hasEditViewCallbacks()); + + if (!bSuppressChangeWhenEditOnOverlay || bScPostIt) + { + SetChanged(); + BroadcastObjectChange(); + } + + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } + return bRet; +} + +void SdrTextObj::ImpSetTextStyleSheetListeners() +{ + SfxStyleSheetBasePool* pStylePool(getSdrModelFromSdrObject().GetStyleSheetPool()); + if (pStylePool==nullptr) + return; + + std::vector aStyleNames; + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if (pOutlinerParaObject!=nullptr) + { + // First, we collect all stylesheets contained in the ParaObject in + // the container aStyles. The Family is always appended to the name + // of the stylesheet. + const EditTextObject& rTextObj=pOutlinerParaObject->GetTextObject(); + OUString aStyleName; + SfxStyleFamily eStyleFam; + sal_Int32 nParaCnt=rTextObj.GetParagraphCount(); + + + for(sal_Int32 nParaNum(0); nParaNum < nParaCnt; nParaNum++) + { + rTextObj.GetStyleSheet(nParaNum, aStyleName, eStyleFam); + + if (!aStyleName.isEmpty()) + { + AppendFamilyToStyleName(aStyleName, eStyleFam); + + bool bFnd(false); + sal_uInt32 nNum(aStyleNames.size()); + + while(!bFnd && nNum > 0) + { + // we don't want duplicate stylesheets + nNum--; + bFnd = aStyleName == aStyleNames[nNum]; + } + + if(!bFnd) + { + aStyleNames.push_back(aStyleName); + } + } + } + } + + // now convert the strings in the vector from names to StyleSheet* + o3tl::sorted_vector aStyleSheets; + while (!aStyleNames.empty()) { + OUString aName = aStyleNames.back(); + aStyleNames.pop_back(); + + SfxStyleFamily eFam = ReadFamilyFromStyleName(aName); + SfxStyleSheetBase* pStyleBase = pStylePool->Find(aName,eFam); + SfxStyleSheet* pStyle = dynamic_cast( pStyleBase ); + if (pStyle!=nullptr && pStyle!=GetStyleSheet()) { + aStyleSheets.insert(pStyle); + } + } + // now remove all superfluous stylesheets + sal_uInt16 nNum=GetBroadcasterCount(); + while (nNum>0) { + nNum--; + SfxBroadcaster* pBroadcast=GetBroadcasterJOE(nNum); + SfxStyleSheet* pStyle=dynamic_cast( pBroadcast ); + if (pStyle!=nullptr && pStyle!=GetStyleSheet()) { // special case for stylesheet of the object + if (aStyleSheets.find(pStyle)==aStyleSheets.end()) { + EndListening(*pStyle); + } + } + } + // and finally, merge all stylesheets that are contained in aStyles with previous broadcasters + for(SfxStyleSheet* pStyle : aStyleSheets) { + // let StartListening see for itself if there's already a listener registered + StartListening(*pStyle, DuplicateHandling::Prevent); + } +} + +/** iterates over the paragraphs of a given SdrObject and removes all + hard set character attributes with the which ids contained in the + given vector +*/ +void SdrTextObj::RemoveOutlinerCharacterAttribs( const std::vector& rCharWhichIds ) +{ + sal_Int32 nText = getTextCount(); + + while( --nText >= 0 ) + { + SdrText* pText = getText( nText ); + OutlinerParaObject* pOutlinerParaObject = pText ? pText->GetOutlinerParaObject() : nullptr; + + if(pOutlinerParaObject) + { + Outliner* pOutliner = nullptr; + + if( mpEditingOutliner || (pText == getActiveText()) ) + pOutliner = mpEditingOutliner; + + if(!pOutliner) + { + pOutliner = &ImpGetDrawOutliner(); + pOutliner->SetText(*pOutlinerParaObject); + } + + ESelection aSelAll( 0, 0, EE_PARA_ALL, EE_TEXTPOS_ALL ); + for( const auto& rWhichId : rCharWhichIds ) + { + pOutliner->RemoveAttribs( aSelAll, false, rWhichId ); + } + + if(!mpEditingOutliner || (pText != getActiveText()) ) + { + const sal_Int32 nParaCount = pOutliner->GetParagraphCount(); + std::optional pTemp = pOutliner->CreateParaObject(0, nParaCount); + pOutliner->Clear(); + NbcSetOutlinerParaObjectForText(std::move(pTemp), pText); + } + } + } +} + +bool SdrTextObj::HasText() const +{ + if (mpEditingOutliner) + return HasTextImpl(mpEditingOutliner); + + OutlinerParaObject* pOPO = GetOutlinerParaObject(); + + bool bHasText = false; + if( pOPO ) + { + const EditTextObject& rETO = pOPO->GetTextObject(); + sal_Int32 nParaCount = rETO.GetParagraphCount(); + + if( nParaCount > 0 ) + bHasText = (nParaCount > 1) || (!rETO.GetText( 0 ).isEmpty()); + } + + return bHasText; +} + +void SdrTextObj::AppendFamilyToStyleName(OUString& styleName, SfxStyleFamily family) +{ + OUStringBuffer aFam = OUString::number(static_cast(family)); + comphelper::string::padToLength(aFam, PADDING_LENGTH_FOR_STYLE_FAMILY , PADDING_CHARACTER_FOR_STYLE_FAMILY); + + styleName += "|" + aFam; +} + +SfxStyleFamily SdrTextObj::ReadFamilyFromStyleName(std::u16string_view styleName) +{ + std::u16string_view familyString = styleName.substr(styleName.size() - PADDING_LENGTH_FOR_STYLE_FAMILY); + familyString = comphelper::string::stripEnd(familyString, PADDING_CHARACTER_FOR_STYLE_FAMILY); + sal_uInt16 nFam = static_cast(o3tl::toInt32(familyString)); + assert(nFam != 0); + return static_cast(nFam); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxdr.cxx b/svx/source/svdraw/svdotxdr.cxx new file mode 100644 index 0000000000..b758b75fe5 --- /dev/null +++ b/svx/source/svdraw/svdotxdr.cxx @@ -0,0 +1,253 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +sal_uInt32 SdrTextObj::GetHdlCount() const +{ + return 8; +} + +void SdrTextObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + for(sal_uInt32 nHdlNum=0; nHdlNum<8; ++nHdlNum) + { + Point aPnt; + SdrHdlKind eKind = SdrHdlKind::UpperLeft; + auto aRectangle = getRectangle(); + switch (nHdlNum) { + case 0: aPnt = aRectangle.TopLeft(); eKind=SdrHdlKind::UpperLeft; break; + case 1: aPnt = aRectangle.TopCenter(); eKind=SdrHdlKind::Upper; break; + case 2: aPnt = aRectangle.TopRight(); eKind=SdrHdlKind::UpperRight; break; + case 3: aPnt = aRectangle.LeftCenter(); eKind=SdrHdlKind::Left ; break; + case 4: aPnt = aRectangle.RightCenter(); eKind=SdrHdlKind::Right; break; + case 5: aPnt = aRectangle.BottomLeft(); eKind=SdrHdlKind::LowerLeft; break; + case 6: aPnt = aRectangle.BottomCenter(); eKind=SdrHdlKind::Lower; break; + case 7: aPnt = aRectangle.BottomRight(); eKind=SdrHdlKind::LowerRight; break; + } + if (maGeo.m_nShearAngle) + ShearPoint(aPnt, aRectangle.TopLeft(), maGeo.mfTanShearAngle); + if (maGeo.m_nRotationAngle) + RotatePoint(aPnt, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + std::unique_ptr pH(new SdrHdl(aPnt,eKind)); + pH->SetObj(const_cast(this)); + pH->SetRotationAngle(maGeo.m_nRotationAngle); + rHdlList.AddHdl(std::move(pH)); + } +} + + +bool SdrTextObj::hasSpecialDrag() const +{ + return true; +} + +tools::Rectangle SdrTextObj::ImpDragCalcRect(const SdrDragStat& rDrag) const +{ + tools::Rectangle aTmpRect(getRectangle()); + const SdrHdl* pHdl=rDrag.GetHdl(); + SdrHdlKind eHdl=pHdl==nullptr ? SdrHdlKind::Move : pHdl->GetKind(); + bool bEcke=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::LowerLeft || eHdl==SdrHdlKind::LowerRight); + bool bOrtho=rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho(); + bool bBigOrtho=bEcke && bOrtho && rDrag.GetView()->IsBigOrtho(); + Point aPos(rDrag.GetNow()); + // Unrotate: + if (maGeo.m_nRotationAngle) RotatePoint(aPos,aTmpRect.TopLeft(),-maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + // Unshear: + if (maGeo.m_nShearAngle) ShearPoint(aPos,aTmpRect.TopLeft(),-maGeo.mfTanShearAngle); + + bool bLft=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::Left || eHdl==SdrHdlKind::LowerLeft); + bool bRgt=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Right || eHdl==SdrHdlKind::LowerRight); + bool bTop=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Upper || eHdl==SdrHdlKind::UpperLeft); + bool bBtm=(eHdl==SdrHdlKind::LowerRight || eHdl==SdrHdlKind::Lower || eHdl==SdrHdlKind::LowerLeft); + if (bLft) aTmpRect.SetLeft(aPos.X() ); + if (bRgt) aTmpRect.SetRight(aPos.X() ); + if (bTop) aTmpRect.SetTop(aPos.Y() ); + if (bBtm) aTmpRect.SetBottom(aPos.Y() ); + if (bOrtho) { // Ortho + tools::Long nWdt0=getRectangle().Right() - getRectangle().Left(); + tools::Long nHgt0=getRectangle().Bottom() - getRectangle().Top(); + tools::Long nXMul=aTmpRect.Right() -aTmpRect.Left(); + tools::Long nYMul=aTmpRect.Bottom()-aTmpRect.Top(); + tools::Long nXDiv=nWdt0; + tools::Long nYDiv=nHgt0; + bool bXNeg=(nXMul<0)!=(nXDiv<0); + bool bYNeg=(nYMul<0)!=(nYDiv<0); + nXMul=std::abs(nXMul); + nYMul=std::abs(nYMul); + nXDiv=std::abs(nXDiv); + nYDiv=std::abs(nYDiv); + Fraction aXFact(nXMul,nXDiv); // fractions for canceling + Fraction aYFact(nYMul,nYDiv); // and for comparing + nXMul=aXFact.GetNumerator(); + nYMul=aYFact.GetNumerator(); + nXDiv=aXFact.GetDenominator(); + nYDiv=aYFact.GetDenominator(); + if (bEcke) { // corner point handles + bool bUseX=(aXFact(this) == nullptr) // not justifying when in CustomShapes, to be able to detect if a shape has to be mirrored + ImpJustifyRect(aTmpRect); + return aTmpRect; +} + + +// drag + +bool SdrTextObj::applySpecialDrag(SdrDragStat& rDrag) +{ + tools::Rectangle aNewRect(ImpDragCalcRect(rDrag)); + + if(aNewRect.TopLeft() != getRectangle().TopLeft() && (maGeo.m_nRotationAngle || maGeo.m_nShearAngle)) + { + Point aNewPos(aNewRect.TopLeft()); + + if (maGeo.m_nShearAngle) + ShearPoint(aNewPos, getRectangle().TopLeft(), maGeo.mfTanShearAngle); + + if (maGeo.m_nRotationAngle) + RotatePoint(aNewPos, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); + + aNewRect.SetPos(aNewPos); + } + + if (aNewRect != getRectangle()) + { + NbcSetLogicRect(aNewRect); + } + + return true; +} + +OUString SdrTextObj::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const +{ + return ImpGetDescriptionStr(STR_DragRectResize); +} + + +// Create + +bool SdrTextObj::BegCreate(SdrDragStat& rStat) +{ + rStat.SetOrtho4Possible(); + tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow()); + aRect1.Normalize(); + rStat.SetActionRect(aRect1); + setRectangle(aRect1); + return true; +} + +bool SdrTextObj::MovCreate(SdrDragStat& rStat) +{ + tools::Rectangle aRect1; + rStat.TakeCreateRect(aRect1); + ImpJustifyRect(aRect1); + rStat.SetActionRect(aRect1); + setRectangle(aRect1); // for ObjName + SetBoundRectDirty(); + m_bSnapRectDirty=true; + if (auto pRectObj = dynamic_cast(this)) { + pRectObj->SetXPolyDirty(); + } + return true; +} + +bool SdrTextObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + tools::Rectangle aRectangle(getRectangle()); + rStat.TakeCreateRect(aRectangle); + ImpJustifyRect(aRectangle); + setRectangle(aRectangle); + + AdaptTextMinSize(); + + SetBoundAndSnapRectsDirty(); + if (auto pRectObj = dynamic_cast(this)) { + pRectObj->SetXPolyDirty(); + } + return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2); +} + +void SdrTextObj::BrkCreate(SdrDragStat& /*rStat*/) +{ +} + +bool SdrTextObj::BckCreate(SdrDragStat& /*rStat*/) +{ + return true; +} + +basegfx::B2DPolyPolygon SdrTextObj::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + tools::Rectangle aRect1; + rDrag.TakeCreateRect(aRect1); + aRect1.Normalize(); + + basegfx::B2DPolyPolygon aRetval; + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aRect1); + aRetval.append(basegfx::utils::createPolygonFromRect(aRange)); + return aRetval; +} + +PointerStyle SdrTextObj::GetCreatePointer() const +{ + if (IsTextFrame()) return PointerStyle::DrawText; + return PointerStyle::Cross; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxed.cxx b/svx/source/svdraw/svdotxed.cxx new file mode 100644 index 0000000000..120bf26b17 --- /dev/null +++ b/svx/source/svdraw/svdotxed.cxx @@ -0,0 +1,360 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +bool SdrTextObj::HasTextEdit() const +{ + // linked text objects may be changed (no automatic reload) + return true; +} + +bool SdrTextObj::BegTextEdit(SdrOutliner& rOutl) +{ + if (mpEditingOutliner!=nullptr) return false; // Textedit might already run in another View! + mpEditingOutliner=&rOutl; + + mbInEditMode = true; + + OutlinerMode nOutlinerMode = OutlinerMode::OutlineObject; + if ( !IsOutlText() ) + nOutlinerMode = OutlinerMode::TextObject; + rOutl.Init( nOutlinerMode ); + rOutl.SetRefDevice(getSdrModelFromSdrObject().GetRefDevice()); + + bool bFitToSize(IsFitToSize()); + bool bContourFrame=IsContourTextFrame(); + ImpSetTextEditParams(); + + if (!bContourFrame) { + EEControlBits nStat=rOutl.GetControlWord(); + nStat|=EEControlBits::AUTOPAGESIZE; + if (bFitToSize || IsAutoFit()) + nStat|=EEControlBits::STRETCHING; + else + nStat&=~EEControlBits::STRETCHING; + rOutl.SetControlWord(nStat); + } + + // disable AUTOPAGESIZE if IsChainable (might be required for overflow check) + if ( IsChainable() ) { + EEControlBits nStat1=rOutl.GetControlWord(); + nStat1 &=~EEControlBits::AUTOPAGESIZE; + rOutl.SetControlWord(nStat1); + } + + + OutlinerParaObject* pOutlinerParaObject = GetOutlinerParaObject(); + if(pOutlinerParaObject!=nullptr) + { + rOutl.SetText(*GetOutlinerParaObject()); + rOutl.SetFixedCellHeight(GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue()); + } + + // if necessary, set frame attributes for the first (new) paragraph of the + // outliner + if( !HasTextImpl( &rOutl ) ) + { + // Outliner has no text so we must set some + // empty text so the outliner initialise itself + rOutl.SetText( "", rOutl.GetParagraph( 0 ) ); + + if(GetStyleSheet()) + rOutl.SetStyleSheet( 0, GetStyleSheet()); + + // When setting the "hard" attributes for first paragraph, the Parent + // pOutlAttr (i. e. the template) has to be removed temporarily. Else, + // at SetParaAttribs(), all attributes contained in the parent become + // attributed hard to the paragraph. + const SfxItemSet& rSet = GetObjectItemSet(); + SfxItemSetFixed aFilteredSet(*rSet.GetPool()); + aFilteredSet.Put(rSet); + rOutl.SetParaAttribs(0, aFilteredSet); + } + if (bFitToSize) + { + tools::Rectangle aAnchorRect; + tools::Rectangle aTextRect; + TakeTextRect(rOutl, aTextRect, false, + &aAnchorRect); + Fraction aFitXCorrection(1,1); + ImpSetCharStretching(rOutl,aTextRect.GetSize(),aAnchorRect.GetSize(),aFitXCorrection); + } + else if (IsAutoFit()) + { + ImpAutoFitText(rOutl); + } + + if(pOutlinerParaObject) + { + if (maGeo.m_nRotationAngle || IsFontwork()) + { + // only repaint here, no real objectchange + BroadcastObjectChange(); + } + } + + rOutl.UpdateFields(); + rOutl.ClearModifyFlag(); + + return true; +} + +void SdrTextObj::TakeTextEditArea(Size* pPaperMin, Size* pPaperMax, tools::Rectangle* pViewInit, tools::Rectangle* pViewMin) const +{ + bool bFitToSize(IsFitToSize()); + Size aPaperMin,aPaperMax; + tools::Rectangle aViewInit; + TakeTextAnchorRect(aViewInit); + if (maGeo.m_nRotationAngle) { + Point aCenter(aViewInit.Center()); + aCenter-=aViewInit.TopLeft(); + Point aCenter0(aCenter); + RotatePoint(aCenter,Point(),maGeo.mfSinRotationAngle,maGeo.mfCosRotationAngle); + aCenter-=aCenter0; + aViewInit.Move(aCenter.X(),aCenter.Y()); + } + Size aAnkSiz(aViewInit.GetSize()); + aAnkSiz.AdjustWidth( -1 ); aAnkSiz.AdjustHeight( -1 ); // because GetSize() adds 1 + Size aMaxSiz(1000000,1000000); + Size aTmpSiz(getSdrModelFromSdrObject().GetMaxObjSize()); + if (aTmpSiz.Width()!=0) aMaxSiz.setWidth(aTmpSiz.Width() ); + if (aTmpSiz.Height()!=0) aMaxSiz.setHeight(aTmpSiz.Height() ); + + // Done earlier since used in else tree below + SdrTextHorzAdjust eHAdj(GetTextHorizontalAdjust()); + SdrTextVertAdjust eVAdj(GetTextVerticalAdjust()); + + if(IsTextFrame()) + { + tools::Long nMinWdt=GetMinTextFrameWidth(); + tools::Long nMinHgt=GetMinTextFrameHeight(); + tools::Long nMaxWdt=GetMaxTextFrameWidth(); + tools::Long nMaxHgt=GetMaxTextFrameHeight(); + if (nMinWdt<1) nMinWdt=1; + if (nMinHgt<1) nMinHgt=1; + if (!bFitToSize) { + if (nMaxWdt==0 || nMaxWdt>aMaxSiz.Width()) nMaxWdt=aMaxSiz.Width(); + if (nMaxHgt==0 || nMaxHgt>aMaxSiz.Height()) nMaxHgt=aMaxSiz.Height(); + + if (!IsAutoGrowWidth() ) + { + nMinWdt = aAnkSiz.Width(); + nMaxWdt = nMinWdt; + } + + if (!IsAutoGrowHeight()) + { + nMinHgt = aAnkSiz.Height(); + nMaxHgt = nMinHgt; + } + + SdrTextAniKind eAniKind=GetTextAniKind(); + SdrTextAniDirection eAniDirection=GetTextAniDirection(); + + bool bInEditMode = IsInEditMode(); + + if (!bInEditMode && (eAniKind==SdrTextAniKind::Scroll || eAniKind==SdrTextAniKind::Alternate || eAniKind==SdrTextAniKind::Slide)) + { + // ticker text uses an unlimited paper size + if (eAniDirection==SdrTextAniDirection::Left || eAniDirection==SdrTextAniDirection::Right) nMaxWdt=1000000; + if (eAniDirection==SdrTextAniDirection::Up || eAniDirection==SdrTextAniDirection::Down) nMaxHgt=1000000; + } + + bool bChainedFrame = IsChainable(); + // Might be required for overflow check working: do limit height to frame if box is chainable. + if (!bChainedFrame) { + // #i119885# Do not limit/force height to geometrical frame (vice versa for vertical writing) + if(IsVerticalWriting()) + { + nMaxWdt = 1000000; + } + else + { + nMaxHgt = 1000000; + } + } + + aPaperMax.setWidth(nMaxWdt ); + aPaperMax.setHeight(nMaxHgt ); + } + else + { + aPaperMax=aMaxSiz; + } + aPaperMin.setWidth(nMinWdt ); + aPaperMin.setHeight(nMinHgt ); + } + else + { + // aPaperMin needs to be set to object's size if full width is activated + // for hor or ver writing respectively + if((SDRTEXTHORZADJUST_BLOCK == eHAdj && !IsVerticalWriting()) + || (SDRTEXTVERTADJUST_BLOCK == eVAdj && IsVerticalWriting())) + { + aPaperMin = aAnkSiz; + } + + aPaperMax=aMaxSiz; + } + + if (pViewMin!=nullptr) { + *pViewMin=aViewInit; + + tools::Long nXFree=aAnkSiz.Width()-aPaperMin.Width(); + if (eHAdj==SDRTEXTHORZADJUST_LEFT) pViewMin->AdjustRight( -nXFree ); + else if (eHAdj==SDRTEXTHORZADJUST_RIGHT) pViewMin->AdjustLeft(nXFree ); + else { pViewMin->AdjustLeft(nXFree/2 ); pViewMin->SetRight(pViewMin->Left()+aPaperMin.Width() ); } + + tools::Long nYFree=aAnkSiz.Height()-aPaperMin.Height(); + if (eVAdj==SDRTEXTVERTADJUST_TOP) pViewMin->AdjustBottom( -nYFree ); + else if (eVAdj==SDRTEXTVERTADJUST_BOTTOM) pViewMin->AdjustTop(nYFree ); + else { pViewMin->AdjustTop(nYFree/2 ); pViewMin->SetBottom(pViewMin->Top()+aPaperMin.Height() ); } + } + + // PaperSize should grow automatically in most cases + if(IsVerticalWriting()) + aPaperMin.setWidth( 0 ); + else + aPaperMin.setHeight( 0 ); + + if(eHAdj!=SDRTEXTHORZADJUST_BLOCK || bFitToSize) { + aPaperMin.setWidth(0 ); + } + + // For complete vertical adjustment support, set paper min height to 0, here. + if(SDRTEXTVERTADJUST_BLOCK != eVAdj || bFitToSize) + { + aPaperMin.setHeight( 0 ); + } + + if (pPaperMin!=nullptr) *pPaperMin=aPaperMin; + if (pPaperMax!=nullptr) *pPaperMax=aPaperMax; + if (pViewInit!=nullptr) *pViewInit=aViewInit; +} + +void SdrTextObj::EndTextEdit(SdrOutliner& rOutl) +{ + if(rOutl.IsModified()) + { + + // to make the gray field background vanish again + rOutl.UpdateFields(); + + std::optional pNewText = rOutl.CreateParaObject( 0, rOutl.GetParagraphCount() ); + + // need to end edit mode early since SetOutlinerParaObject already + // uses GetCurrentBoundRect() which needs to take the text into account + // to work correct + mbInEditMode = false; + + // We don't want broadcasting if we are merely trying to move to next box (this prevents infinite loops) + if (IsChainable() && GetTextChain()->GetSwitchingToNextBox(this)) { + GetTextChain()->SetSwitchingToNextBox(this, false); + if( getActiveText() ) + { + getActiveText()->SetOutlinerParaObject( std::move(pNewText) ); + } + } else { // If we are not doing in-chaining switching just set the ParaObject + SetOutlinerParaObject(std::move(pNewText)); + } + } + + /* Chaining-related code */ + rOutl.ClearOverflowingParaNum(); + + mpEditingOutliner = nullptr; + rOutl.Clear(); + EEControlBits nStat = rOutl.GetControlWord(); + nStat &= ~EEControlBits::AUTOPAGESIZE; + rOutl.SetControlWord(nStat); + + mbInEditMode = false; +} + +EEAnchorMode SdrTextObj::GetOutlinerViewAnchorMode() const +{ + SdrTextHorzAdjust eH=GetTextHorizontalAdjust(); + SdrTextVertAdjust eV=GetTextVerticalAdjust(); + EEAnchorMode eRet=EEAnchorMode::TopLeft; + if (IsContourTextFrame()) return eRet; + if (eH==SDRTEXTHORZADJUST_LEFT) { + if (eV==SDRTEXTVERTADJUST_TOP) { + eRet=EEAnchorMode::TopLeft; + } else if (eV==SDRTEXTVERTADJUST_BOTTOM) { + eRet=EEAnchorMode::BottomLeft; + } else { + eRet=EEAnchorMode::VCenterLeft; + } + } else if (eH==SDRTEXTHORZADJUST_RIGHT) { + if (eV==SDRTEXTVERTADJUST_TOP) { + eRet=EEAnchorMode::TopRight; + } else if (eV==SDRTEXTVERTADJUST_BOTTOM) { + eRet=EEAnchorMode::BottomRight; + } else { + eRet=EEAnchorMode::VCenterRight; + } + } else { + if (eV==SDRTEXTVERTADJUST_TOP) { + eRet=EEAnchorMode::TopHCenter; + } else if (eV==SDRTEXTVERTADJUST_BOTTOM) { + eRet=EEAnchorMode::BottomHCenter; + } else { + eRet=EEAnchorMode::VCenterHCenter; + } + } + return eRet; +} + +void SdrTextObj::ImpSetTextEditParams() const +{ + if (mpEditingOutliner==nullptr) + return; + + bool bUpdBuf=mpEditingOutliner->SetUpdateLayout(false); + Size aPaperMin; + Size aPaperMax; + tools::Rectangle aEditArea; + TakeTextEditArea(&aPaperMin,&aPaperMax,&aEditArea,nullptr); + bool bContourFrame=IsContourTextFrame(); + mpEditingOutliner->SetMinAutoPaperSize(aPaperMin); + mpEditingOutliner->SetMaxAutoPaperSize(aPaperMax); + mpEditingOutliner->SetPaperSize(Size()); + mpEditingOutliner->SetTextColumns(GetTextColumnsNumber(), GetTextColumnsSpacing()); + if (bContourFrame) { + tools::Rectangle aAnchorRect; + TakeTextAnchorRect(aAnchorRect); + ImpSetContourPolygon(*mpEditingOutliner,aAnchorRect, true); + } + if (bUpdBuf) mpEditingOutliner->SetUpdateLayout(true); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxfl.cxx b/svx/source/svdraw/svdotxfl.cxx new file mode 100644 index 0000000000..6c61d7c824 --- /dev/null +++ b/svx/source/svdraw/svdotxfl.cxx @@ -0,0 +1,28 @@ +/* -*- 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 + +bool SdrTextObj::CalcFieldValue(const SvxFieldItem& /*rField*/, sal_Int32 /*nPara*/, sal_uInt16 /*nPos*/, + bool /*bEdit*/, std::optional& /*rpTxtColor*/, std::optional& /*rpFldColor*/, std::optional& /*rpFldLineStyle*/, OUString& /*rRet*/) const +{ + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxln.cxx b/svx/source/svdraw/svdotxln.cxx new file mode 100644 index 0000000000..44a55fdb4e --- /dev/null +++ b/svx/source/svdraw/svdotxln.cxx @@ -0,0 +1,279 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class ImpSdrObjTextLink: public ::sfx2::SvBaseLink +{ + SdrTextObj* pSdrObj; + +public: + explicit ImpSdrObjTextLink( SdrTextObj* pObj1 ) + : ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SIMPLE_FILE ), + pSdrObj( pObj1 ) + {} + + virtual void Closed() override; + virtual ::sfx2::SvBaseLink::UpdateResult DataChanged( + const OUString& rMimeType, const css::uno::Any & rValue ) override; +}; + +void ImpSdrObjTextLink::Closed() +{ + if (pSdrObj ) + { + // set pLink of the object to NULL, because we are destroying the link instance now + ImpSdrObjTextLinkUserData* pData=pSdrObj->GetLinkUserData(); + if (pData!=nullptr) pData->mpLink = nullptr; + pSdrObj->ReleaseTextLink(); + } + SvBaseLink::Closed(); +} + + +::sfx2::SvBaseLink::UpdateResult ImpSdrObjTextLink::DataChanged( + const OUString& /*rMimeType*/, const css::uno::Any & /*rValue */) +{ + bool bForceReload = false; + SdrModel* pModel(pSdrObj ? &pSdrObj->getSdrModelFromSdrObject() : nullptr); + sfx2::LinkManager* pLinkManager(pModel ? pModel->GetLinkManager() : nullptr); + + if( pLinkManager ) + { + ImpSdrObjTextLinkUserData* pData=pSdrObj->GetLinkUserData(); + if( pData ) + { + OUString aFile; + OUString aFilter; + sfx2::LinkManager::GetDisplayNames( this, nullptr,&aFile, nullptr, &aFilter ); + + if( pData->maFileName != aFile || + pData->maFilterName != aFilter ) + { + pData->maFileName = aFile; + pData->maFilterName = aFilter; + pSdrObj->SetChanged(); + bForceReload = true; + } + } + } + if (pSdrObj ) + pSdrObj->ReloadLinkedText( bForceReload ); + + return SUCCESS; +} + + +ImpSdrObjTextLinkUserData::ImpSdrObjTextLinkUserData(): + SdrObjUserData(SdrInventor::Default,SDRUSERDATA_OBJTEXTLINK), + maFileDate0( DateTime::EMPTY ), + meCharSet(RTL_TEXTENCODING_DONTKNOW) +{ +} + +ImpSdrObjTextLinkUserData::~ImpSdrObjTextLinkUserData() +{ +} + +std::unique_ptr ImpSdrObjTextLinkUserData::Clone(SdrObject* ) const +{ + ImpSdrObjTextLinkUserData* pData = new ImpSdrObjTextLinkUserData; + pData->maFileName = maFileName; + pData->maFilterName = maFilterName; + pData->maFileDate0 = maFileDate0; + pData->meCharSet = meCharSet; + pData->mpLink = nullptr; + return std::unique_ptr(pData); +} + + +void SdrTextObj::SetTextLink(const OUString& rFileName, const OUString& rFilterName) +{ + rtl_TextEncoding eCharSet = osl_getThreadTextEncoding(); + + ImpSdrObjTextLinkUserData* pData=GetLinkUserData(); + if (pData!=nullptr) { + ReleaseTextLink(); + } + pData=new ImpSdrObjTextLinkUserData; + pData->maFileName = rFileName; + pData->maFilterName = rFilterName; + pData->meCharSet = eCharSet; + AppendUserData(std::unique_ptr(pData)); + ImpRegisterLink(); +} + +void SdrTextObj::ReleaseTextLink() +{ + ImpDeregisterLink(); + sal_uInt16 nCount=GetUserDataCount(); + for (sal_uInt16 nNum=nCount; nNum>0;) { + nNum--; + SdrObjUserData* pData=GetUserData(nNum); + if (pData->GetInventor()==SdrInventor::Default && pData->GetId()==SDRUSERDATA_OBJTEXTLINK) { + DeleteUserData(nNum); + } + } +} + +bool SdrTextObj::ReloadLinkedText( bool bForceLoad) +{ + ImpSdrObjTextLinkUserData* pData = GetLinkUserData(); + bool bRet = true; + + if( pData ) + { + DateTime aFileDT( DateTime::EMPTY ); + bool bExists = true; + + try + { + INetURLObject aURL( pData->maFileName ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + ::ucbhelper::Content aCnt( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), css::uno::Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() ); + css::uno::Any aAny( aCnt.getPropertyValue("DateModified") ); + css::util::DateTime aDateTime; + + aAny >>= aDateTime; + ::utl::typeConvert( aDateTime, aFileDT ); + } + catch( ... ) + { + bExists = false; + } + + if( bExists ) + { + bool bLoad = false; + if( bForceLoad ) + bLoad = true; + else + bLoad = ( aFileDT > pData->maFileDate0 ); + + if( bLoad ) + { + bRet = LoadText( pData->maFileName, pData->meCharSet ); + } + + pData->maFileDate0 = aFileDT; + } + } + + return bRet; +} + +bool SdrTextObj::LoadText(const OUString& rFileName, rtl_TextEncoding eCharSet) +{ + INetURLObject aFileURL( rFileName ); + bool bRet = false; + + if( aFileURL.GetProtocol() == INetProtocol::NotValid ) + { + OUString aFileURLStr; + + if( osl::FileBase::getFileURLFromSystemPath( rFileName, aFileURLStr ) == osl::FileBase::E_None ) + aFileURL = INetURLObject( aFileURLStr ); + else + aFileURL.SetSmartURL( rFileName ); + } + + DBG_ASSERT( aFileURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + std::unique_ptr pIStm(::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ )); + + if( pIStm ) + { + pIStm->SetStreamCharSet(GetSOLoadTextEncoding(eCharSet)); + + char cRTF[5]; + cRTF[4] = 0; + pIStm->ReadBytes(cRTF, 5); + + bool bRTF = cRTF[0] == '{' && cRTF[1] == '\\' && cRTF[2] == 'r' && cRTF[3] == 't' && cRTF[4] == 'f'; + + pIStm->Seek(0); + + if( !pIStm->GetError() ) + { + SetText( *pIStm, aFileURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), bRTF ? EETextFormat::Rtf : EETextFormat::Text ); + bRet = true; + } + } + + return bRet; +} + +ImpSdrObjTextLinkUserData* SdrTextObj::GetLinkUserData() const +{ + sal_uInt16 nCount=GetUserDataCount(); + for (sal_uInt16 nNum=nCount; nNum>0;) { + nNum--; + SdrObjUserData * pData=GetUserData(nNum); + if (pData->GetInventor() == SdrInventor::Default + && pData->GetId() == SDRUSERDATA_OBJTEXTLINK) + { + return static_cast(pData); + } + } + return nullptr; +} + +void SdrTextObj::ImpRegisterLink() +{ + ImpSdrObjTextLinkUserData* pData=GetLinkUserData(); + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + if (pLinkManager!=nullptr && pData!=nullptr && pData->mpLink==nullptr) { // don't register twice + pData->mpLink = new ImpSdrObjTextLink(this); + pLinkManager->InsertFileLink(*pData->mpLink,sfx2::SvBaseLinkObjectType::ClientFile,pData->maFileName, + !pData->maFilterName.isEmpty() ? + &pData->maFilterName : nullptr); + } +} + +void SdrTextObj::ImpDeregisterLink() +{ + ImpSdrObjTextLinkUserData* pData=GetLinkUserData(); + if (!pData) + return; + sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager()); + if (pLinkManager!=nullptr && pData->mpLink!=nullptr) { // don't register twice + // when doing Remove, *pLink is deleted implicitly + pLinkManager->Remove( pData->mpLink.get() ); + pData->mpLink=nullptr; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdotxtr.cxx b/svx/source/svdraw/svdotxtr.cxx new file mode 100644 index 0000000000..fbe6b0b357 --- /dev/null +++ b/svx/source/svdraw/svdotxtr.cxx @@ -0,0 +1,498 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +void SdrTextObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + if (maGeo.m_nRotationAngle || maGeo.m_nShearAngle) + { + // Either the rotation or shear angle exists. + tools::Rectangle aSR0(GetSnapRect()); + tools::Long nWdt0=aSR0.Right()-aSR0.Left(); + tools::Long nHgt0=aSR0.Bottom()-aSR0.Top(); + tools::Long nWdt1=rRect.Right()-rRect.Left(); + tools::Long nHgt1=rRect.Bottom()-rRect.Top(); + SdrTextObj::NbcResize(maSnapRect.TopLeft(),Fraction(nWdt1,nWdt0),Fraction(nHgt1,nHgt0)); + SdrTextObj::NbcMove(Size(rRect.Left()-aSR0.Left(),rRect.Top()-aSR0.Top())); + } + else + { + // No rotation or shear. + + setRectangle(rRect); + ImpJustifyRect(maRectangle); + + AdaptTextMinSize(); + + ImpCheckShear(); + SetBoundAndSnapRectsDirty(); + } +} + +const tools::Rectangle& SdrTextObj::GetLogicRect() const +{ + return getRectangle(); +} + +void SdrTextObj::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + setRectangle(rRect); + ImpJustifyRect(maRectangle); + + AdaptTextMinSize(); + + SetBoundAndSnapRectsDirty(); +} + +Degree100 SdrTextObj::GetRotateAngle() const +{ + return maGeo.m_nRotationAngle; +} + +Degree100 SdrTextObj::GetShearAngle(bool /*bVertical*/) const +{ + return maGeo.m_nShearAngle; +} + +void SdrTextObj::NbcMove(const Size& rSize) +{ + moveRectangle(rSize.Width(), rSize.Height()); + moveOutRectangle(rSize.Width(), rSize.Height()); + maSnapRect.Move(rSize); + SetBoundAndSnapRectsDirty(true); +} + +void SdrTextObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + bool bNotSheared=maGeo.m_nShearAngle==0_deg100; + bool bRotate90=bNotSheared && maGeo.m_nRotationAngle.get() % 9000 ==0; + bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0); + bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0); + if (bXMirr || bYMirr) { + Point aRef1(GetSnapRect().Center()); + if (bXMirr) { + Point aRef2(aRef1); + aRef2.AdjustY( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + if (bYMirr) { + Point aRef2(aRef1); + aRef2.AdjustX( 1 ); + NbcMirrorGluePoints(aRef1,aRef2); + } + } + + if (maGeo.m_nRotationAngle==0_deg100 && maGeo.m_nShearAngle==0_deg100) { + auto aRectangle = getRectangle(); + ResizeRect(aRectangle, rRef, xFact, yFact); + setRectangle(aRectangle); + if (bYMirr) + { + maRectangle.Normalize(); + moveRectangle(aRectangle.Right() - aRectangle.Left(), aRectangle.Bottom() - aRectangle.Top()); + maGeo.m_nRotationAngle=18000_deg100; + maGeo.RecalcSinCos(); + } + } + else + { + tools::Polygon aPol(Rect2Poly(getRectangle(), maGeo)); + + for(sal_uInt16 a(0); a < aPol.GetSize(); a++) + { + ResizePoint(aPol[a], rRef, xFact, yFact); + } + + if(bXMirr != bYMirr) + { + // turn polygon and move it a little + tools::Polygon aPol0(aPol); + + aPol[0] = aPol0[1]; + aPol[1] = aPol0[0]; + aPol[2] = aPol0[3]; + aPol[3] = aPol0[2]; + aPol[4] = aPol0[1]; + } + tools::Rectangle aRectangle = svx::polygonToRectangle(aPol, maGeo); + setRectangle(aRectangle); + } + + if (bRotate90) { + bool bRota90=maGeo.m_nRotationAngle.get() % 9000 ==0; + if (!bRota90) { // there's seems to be a rounding error occurring: correct it + Degree100 a=NormAngle36000(maGeo.m_nRotationAngle); + if (a<4500_deg100) a=0_deg100; + else if (a<13500_deg100) a=9000_deg100; + else if (a<22500_deg100) a=18000_deg100; + else if (a<31500_deg100) a=27000_deg100; + else a=0_deg100; + maGeo.m_nRotationAngle=a; + maGeo.RecalcSinCos(); + } + if (bNotSheared!=(maGeo.m_nShearAngle==0_deg100)) { // correct a rounding error occurring with Shear + maGeo.m_nShearAngle=0_deg100; + maGeo.RecalcTan(); + } + } + + ImpJustifyRect(maRectangle); + + AdaptTextMinSize(); + + if(mbTextFrame && !getSdrModelFromSdrObject().IsPasteResize()) + { + NbcAdjustTextFrameWidthAndHeight(); + } + + ImpCheckShear(); + SetBoundAndSnapRectsDirty(); +} + +void SdrTextObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + SetGlueReallyAbsolute(true); + tools::Long dx = getRectangle().Right() - getRectangle().Left(); + tools::Long dy = getRectangle().Bottom() - getRectangle().Top(); + Point aPoint1(getRectangle().TopLeft()); + RotatePoint(aPoint1, rRef, sn, cs); + Point aPoint2(aPoint1.X() + dx, aPoint1.Y() + dy); + tools::Rectangle aRectangle(aPoint1, aPoint2); + setRectangle(aRectangle); + + if (maGeo.m_nRotationAngle==0_deg100) { + maGeo.m_nRotationAngle=NormAngle36000(nAngle); + maGeo.mfSinRotationAngle=sn; + maGeo.mfCosRotationAngle=cs; + } else { + maGeo.m_nRotationAngle=NormAngle36000(maGeo.m_nRotationAngle+nAngle); + maGeo.RecalcSinCos(); + } + SetBoundAndSnapRectsDirty(); + NbcRotateGluePoints(rRef,nAngle,sn,cs); + SetGlueReallyAbsolute(false); +} + +void SdrTextObj::NbcShear(const Point& rRef, Degree100 /*nAngle*/, double tn, bool bVShear) +{ + SetGlueReallyAbsolute(true); + + // when this is a SdrPathObj, aRect may be uninitialized + tools::Polygon aPol(Rect2Poly(getRectangle().IsEmpty() ? GetSnapRect() : getRectangle(), maGeo)); + + sal_uInt16 nPointCount=aPol.GetSize(); + for (sal_uInt16 i=0; i SdrTextObj::ImpConvertContainedTextToSdrPathObjs(bool bToPoly) const +{ + rtl::Reference pRetval; + + if(!ImpCanConvTextToCurve()) + { + // suppress HelpTexts from PresObj's + return nullptr; + } + + // create an extractor with neutral ViewInformation + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + drawinglayer::processor2d::TextAsPolygonExtractor2D aExtractor(aViewInformation2D); + + // extract text as polygons + GetViewContact().getViewIndependentPrimitive2DContainer(aExtractor); + + // get results + const drawinglayer::processor2d::TextAsPolygonDataNodeVector& rResult = aExtractor.getTarget(); + const sal_uInt32 nResultCount(rResult.size()); + + if(nResultCount) + { + // prepare own target + rtl::Reference pGroup = new SdrObjGroup(getSdrModelFromSdrObject()); + SdrObjList* pObjectList = pGroup->GetSubList(); + + // process results + for(sal_uInt32 a(0); a < nResultCount; a++) + { + const drawinglayer::processor2d::TextAsPolygonDataNode& rCandidate = rResult[a]; + basegfx::B2DPolyPolygon aPolyPolygon(rCandidate.getB2DPolyPolygon()); + + if(aPolyPolygon.count()) + { + // take care of wanted polygon type + if(bToPoly) + { + if(aPolyPolygon.areControlPointsUsed()) + { + aPolyPolygon = basegfx::utils::adaptiveSubdivideByAngle(aPolyPolygon); + } + } + else + { + if(!aPolyPolygon.areControlPointsUsed()) + { + aPolyPolygon = basegfx::utils::expandToCurve(aPolyPolygon); + } + } + + // create ItemSet with object attributes + SfxItemSet aAttributeSet(GetObjectItemSet()); + rtl::Reference pPathObj; + + // always clear objectshadow; this is included in the extraction + aAttributeSet.Put(makeSdrShadowItem(false)); + + if(rCandidate.getIsFilled()) + { + // set needed items + aAttributeSet.Put(XFillColorItem(OUString(), Color(rCandidate.getBColor()))); + aAttributeSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + aAttributeSet.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + + // create filled SdrPathObj + pPathObj = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathFill, + aPolyPolygon); + } + else + { + // set needed items + aAttributeSet.Put(XLineColorItem(OUString(), Color(rCandidate.getBColor()))); + aAttributeSet.Put(XLineStyleItem(drawing::LineStyle_SOLID)); + aAttributeSet.Put(XLineWidthItem(0)); + aAttributeSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + + // create line SdrPathObj + pPathObj = new SdrPathObj( + getSdrModelFromSdrObject(), + SdrObjKind::PathLine, + std::move(aPolyPolygon)); + } + + // copy basic information from original + pPathObj->ImpSetAnchorPos(GetAnchorPos()); + pPathObj->NbcSetLayer(GetLayer()); + pPathObj->NbcSetStyleSheet(GetStyleSheet(), true); + + // apply prepared ItemSet and add to target + pPathObj->SetMergedItemSet(aAttributeSet); + pObjectList->InsertObject(pPathObj.get()); + } + } + + // postprocess; if no result and/or only one object, simplify + if(!pObjectList->GetObjCount()) + { + pGroup.clear(); + } + else if(1 == pObjectList->GetObjCount()) + { + pRetval = pObjectList->RemoveObject(0); + pGroup.clear(); + } + else + { + pRetval = pGroup; + } + } + + return pRetval; +} + + +rtl::Reference SdrTextObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const +{ + if(bAddText) + { + return ImpConvertContainedTextToSdrPathObjs(!bBezier); + } + + return nullptr; +} + +bool SdrTextObj::ImpCanConvTextToCurve() const +{ + return !IsOutlText() && !utl::ConfigManager::IsFuzzing(); +} + +rtl::Reference SdrTextObj::ImpConvertMakeObj(const basegfx::B2DPolyPolygon& rPolyPolygon, bool bClosed, bool bBezier) const +{ + SdrObjKind ePathKind = bClosed ? SdrObjKind::PathFill : SdrObjKind::PathLine; + basegfx::B2DPolyPolygon aB2DPolyPolygon(rPolyPolygon); + + // #i37011# + if(!bBezier) + { + aB2DPolyPolygon = basegfx::utils::adaptiveSubdivideByAngle(aB2DPolyPolygon); + ePathKind = bClosed ? SdrObjKind::Polygon : SdrObjKind::PolyLine; + } + + rtl::Reference pPathObj(new SdrPathObj( + getSdrModelFromSdrObject(), + ePathKind, + std::move(aB2DPolyPolygon))); + + if(bBezier) + { + // create bezier curves + pPathObj->SetPathPoly(basegfx::utils::expandToCurve(pPathObj->GetPathPoly())); + } + + pPathObj->ImpSetAnchorPos(m_aAnchor); + pPathObj->NbcSetLayer(GetLayer()); + sdr::properties::ItemChangeBroadcaster aC(*pPathObj); + pPathObj->ClearMergedItem(); + pPathObj->SetMergedItemSet(GetObjectItemSet()); + pPathObj->GetProperties().BroadcastItemChange(aC); + pPathObj->NbcSetStyleSheet(GetStyleSheet(), true); + + return pPathObj; +} + +rtl::Reference SdrTextObj::ImpConvertAddText(rtl::Reference pObj, bool bBezier) const +{ + if(!ImpCanConvTextToCurve()) + { + return pObj; + } + + rtl::Reference pText = ImpConvertContainedTextToSdrPathObjs(!bBezier); + + if(!pText) + { + return pObj; + } + + if(!pObj) + { + return pText; + } + + if(pText->IsGroupObject()) + { + // is already group object, add partial shape in front + SdrObjList* pOL=pText->GetSubList(); + pOL->InsertObject(pObj.get(),0); + + return pText; + } + else + { + // not yet a group, create one and add partial and new shapes + rtl::Reference pGrp(new SdrObjGroup(getSdrModelFromSdrObject())); + SdrObjList* pOL=pGrp->GetSubList(); + pOL->InsertObject(pObj.get()); + pOL->InsertObject(pText.get()); + + return pGrp; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdouno.cxx b/svx/source/svdraw/svdouno.cxx new file mode 100644 index 0000000000..970fa60d37 --- /dev/null +++ b/svx/source/svdraw/svdouno.cxx @@ -0,0 +1,497 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; +using namespace sdr::contact; + + +class SdrControlEventListenerImpl : public ::cppu::WeakImplHelper< css::lang::XEventListener > +{ +protected: + SdrUnoObj* pObj; + +public: + explicit SdrControlEventListenerImpl(SdrUnoObj* _pObj) + : pObj(_pObj) + {} + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + void StopListening(const uno::Reference< lang::XComponent >& xComp); + void StartListening(const uno::Reference< lang::XComponent >& xComp); +}; + +// XEventListener +void SAL_CALL SdrControlEventListenerImpl::disposing( const css::lang::EventObject& /*Source*/) +{ + if (pObj) + { + pObj->xUnoControlModel = nullptr; + } +} + +void SdrControlEventListenerImpl::StopListening(const uno::Reference< lang::XComponent >& xComp) +{ + if (xComp.is()) + xComp->removeEventListener(this); +} + +void SdrControlEventListenerImpl::StartListening(const uno::Reference< lang::XComponent >& xComp) +{ + if (xComp.is()) + xComp->addEventListener(this); +} + + +struct SdrUnoObjDataHolder +{ + mutable ::rtl::Reference< SdrControlEventListenerImpl > + pEventListener; +}; + + +namespace +{ + void lcl_ensureControlVisibility( SdrView const * _pView, const SdrUnoObj* _pObject, bool _bVisible ) + { + OSL_PRECOND( _pObject, "lcl_ensureControlVisibility: no object -> no survival!" ); + + SdrPageView* pPageView = _pView ? _pView->GetSdrPageView() : nullptr; + DBG_ASSERT( pPageView, "lcl_ensureControlVisibility: no view found!" ); + if ( !pPageView ) + return; + + ViewContact& rUnoControlContact( _pObject->GetViewContact() ); + + for ( sal_uInt32 i = 0; i < pPageView->PageWindowCount(); ++i ) + { + SdrPageWindow* pPageWindow = pPageView->GetPageWindow( i ); + DBG_ASSERT( pPageWindow, "lcl_ensureControlVisibility: invalid PageViewWindow!" ); + if ( !pPageWindow ) + continue; + + if ( !pPageWindow->HasObjectContact() ) + continue; + + ObjectContact& rPageViewContact( pPageWindow->GetObjectContact() ); + const ViewObjectContact& rViewObjectContact( rUnoControlContact.GetViewObjectContact( rPageViewContact ) ); + const ViewObjectContactOfUnoControl* pUnoControlContact = dynamic_cast< const ViewObjectContactOfUnoControl* >( &rViewObjectContact ); + DBG_ASSERT( pUnoControlContact, "lcl_ensureControlVisibility: wrong ViewObjectContact type!" ); + if ( !pUnoControlContact ) + continue; + + pUnoControlContact->ensureControlVisibility( _bVisible ); + } + } +} + +SdrUnoObj::SdrUnoObj( + SdrModel& rSdrModel, + const OUString& rModelName) +: SdrRectObj(rSdrModel), + m_pImpl( new SdrUnoObjDataHolder ) +{ + osl_atomic_increment(&m_refCount); // prevent deletion during creation + m_bIsUnoObj = true; + + m_pImpl->pEventListener = new SdrControlEventListenerImpl(this); + + // only an owner may create independently + if (!rModelName.isEmpty()) + CreateUnoControlModel(rModelName); + osl_atomic_decrement(&m_refCount); +} + +SdrUnoObj::SdrUnoObj( SdrModel& rSdrModel, SdrUnoObj const & rSource) +: SdrRectObj(rSdrModel, rSource), + m_pImpl( new SdrUnoObjDataHolder ) +{ + m_bIsUnoObj = true; + + m_pImpl->pEventListener = new SdrControlEventListenerImpl(this); + + aUnoControlModelTypeName = rSource.aUnoControlModelTypeName; + aUnoControlTypeName = rSource.aUnoControlTypeName; + + // copy the uno control model + const uno::Reference< awt::XControlModel > xSourceControlModel = rSource.GetUnoControlModel(); + if ( xSourceControlModel.is() ) + { + try + { + uno::Reference< util::XCloneable > xClone( xSourceControlModel, uno::UNO_QUERY_THROW ); + xUnoControlModel.set( xClone->createClone(), uno::UNO_QUERY_THROW ); + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + // get service name of the control from the control model + uno::Reference< beans::XPropertySet > xSet(xUnoControlModel, uno::UNO_QUERY); + if (xSet.is()) + { + uno::Any aValue( xSet->getPropertyValue("DefaultControl") ); + OUString aStr; + + if( aValue >>= aStr ) + aUnoControlTypeName = aStr; + } + + uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY); + if (xComp.is()) + m_pImpl->pEventListener->StartListening(xComp); +} + +SdrUnoObj::SdrUnoObj( + SdrModel& rSdrModel, + const OUString& rModelName, + const uno::Reference< lang::XMultiServiceFactory >& rxSFac) +: SdrRectObj(rSdrModel), + m_pImpl( new SdrUnoObjDataHolder ) +{ + m_bIsUnoObj = true; + + m_pImpl->pEventListener = new SdrControlEventListenerImpl(this); + + // only an owner may create independently + if (!rModelName.isEmpty()) + CreateUnoControlModel(rModelName,rxSFac); +} + +SdrUnoObj::~SdrUnoObj() +{ + try + { + // clean up the control model + uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY); + if (xComp.is()) + { + // is the control model owned by its environment? + uno::Reference< container::XChild > xContent(xUnoControlModel, uno::UNO_QUERY); + if (xContent.is() && !xContent->getParent().is()) + xComp->dispose(); + else + m_pImpl->pEventListener->StopListening(xComp); + } + } + catch( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "SdrUnoObj::~SdrUnoObj" ); + } +} + +void SdrUnoObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + rInfo.bRotateFreeAllowed = false; + rInfo.bRotate90Allowed = false; + rInfo.bMirrorFreeAllowed = false; + rInfo.bMirror45Allowed = false; + rInfo.bMirror90Allowed = false; + rInfo.bTransparenceAllowed = false; + rInfo.bShearAllowed = false; + rInfo.bEdgeRadiusAllowed = false; + rInfo.bNoOrthoDesired = false; + rInfo.bCanConvToPath = false; + rInfo.bCanConvToPoly = false; + rInfo.bCanConvToPathLineToArea = false; + rInfo.bCanConvToPolyLineToArea = false; + rInfo.bCanConvToContour = false; +} + +SdrObjKind SdrUnoObj::GetObjIdentifier() const +{ + return SdrObjKind::UNO; +} + +void SdrUnoObj::SetContextWritingMode( const sal_Int16 _nContextWritingMode ) +{ + try + { + uno::Reference< beans::XPropertySet > xModelProperties( GetUnoControlModel(), uno::UNO_QUERY_THROW ); + xModelProperties->setPropertyValue( "ContextWritingMode", uno::Any( _nContextWritingMode ) ); + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } +} + +OUString SdrUnoObj::TakeObjNameSingul() const +{ + OUString sName(SvxResId(STR_ObjNameSingulUno)); + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrUnoObj::TakeObjNamePlural() const +{ + return SvxResId(STR_ObjNamePluralUno); +} + +rtl::Reference SdrUnoObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrUnoObj(rTargetModel, *this); +} + +void SdrUnoObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + SdrRectObj::NbcResize(rRef,xFact,yFact); + + if (maGeo.m_nShearAngle==0_deg100 && maGeo.m_nRotationAngle==0_deg100) + return; + + // small correctors + if (maGeo.m_nRotationAngle>=9000_deg100 && maGeo.m_nRotationAngle<27000_deg100) + { + moveRectangle(getRectangle().Left() - getRectangle().Right(), getRectangle().Top() - getRectangle().Bottom()); + } + + maGeo.m_nRotationAngle = 0_deg100; + maGeo.m_nShearAngle = 0_deg100; + maGeo.mfSinRotationAngle = 0.0; + maGeo.mfCosRotationAngle = 1.0; + maGeo.mfTanShearAngle = 0.0; + SetBoundAndSnapRectsDirty(); +} + + +bool SdrUnoObj::hasSpecialDrag() const +{ + // no special drag; we have no rounding rect and + // do want frame handles + return false; +} + +void SdrUnoObj::NbcSetLayer( SdrLayerID _nLayer ) +{ + if ( GetLayer() == _nLayer ) + { // redundant call -> not interested in doing anything here + SdrRectObj::NbcSetLayer( _nLayer ); + return; + } + + // we need some special handling here in case we're moved from an invisible layer + // to a visible one, or vice versa + // (relative to a layer. Remember that the visibility of a layer is a view attribute + // - the same layer can be visible in one view, and invisible in another view, at the + // same time) + + // collect all views in which our old layer is visible + o3tl::sorted_vector< SdrView* > aPreviouslyVisible; + + { + SdrViewIter::ForAllViews(this, + [&aPreviouslyVisible] (SdrView* pView) + { + aPreviouslyVisible.insert( pView ); + return false; + }); + } + + SdrRectObj::NbcSetLayer( _nLayer ); + + // collect all views in which our new layer is visible + o3tl::sorted_vector< SdrView* > aNewlyVisible; + + SdrViewIter::ForAllViews( this, + [&aPreviouslyVisible, &aNewlyVisible] (SdrView* pView) + { + if ( aPreviouslyVisible.erase(pView) == 0 ) + { + // in pView, we were visible _before_ the layer change, and are + // _not_ visible after the layer change + // => remember this view, as our visibility there changed + aNewlyVisible.insert( pView ); + } + }); + + // now aPreviouslyVisible contains all views where we became invisible + for (const auto& rpView : aPreviouslyVisible) + { + lcl_ensureControlVisibility( rpView, this, false ); + } + + // and aNewlyVisible all views where we became visible + for (const auto& rpView : aNewlyVisible) + { + lcl_ensureControlVisibility( rpView, this, true ); + } +} + +void SdrUnoObj::CreateUnoControlModel(const OUString& rModelName) +{ + DBG_ASSERT(!xUnoControlModel.is(), "model already exists"); + + aUnoControlModelTypeName = rModelName; + + uno::Reference< awt::XControlModel > xModel; + uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() ); + if (!aUnoControlModelTypeName.isEmpty() ) + { + xModel.set(xContext->getServiceManager()->createInstanceWithContext( + aUnoControlModelTypeName, xContext), uno::UNO_QUERY); + + if (xModel.is()) + SetChanged(); + } + + SetUnoControlModel(xModel); +} + +void SdrUnoObj::CreateUnoControlModel(const OUString& rModelName, + const uno::Reference< lang::XMultiServiceFactory >& rxSFac) +{ + DBG_ASSERT(!xUnoControlModel.is(), "model already exists"); + + aUnoControlModelTypeName = rModelName; + + uno::Reference< awt::XControlModel > xModel; + if (!aUnoControlModelTypeName.isEmpty() && rxSFac.is() ) + { + xModel.set(rxSFac->createInstance(aUnoControlModelTypeName), uno::UNO_QUERY); + + if (xModel.is()) + SetChanged(); + } + + SetUnoControlModel(xModel); +} + +void SdrUnoObj::SetUnoControlModel( const uno::Reference< awt::XControlModel >& xModel) +{ + if (xUnoControlModel.is()) + { + uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY); + if (xComp.is()) + m_pImpl->pEventListener->StopListening(xComp); + } + + xUnoControlModel = xModel; + + // control model has to contain service name of the control + if (xUnoControlModel.is()) + { + uno::Reference< beans::XPropertySet > xSet(xUnoControlModel, uno::UNO_QUERY); + if (xSet.is()) + { + uno::Any aValue( xSet->getPropertyValue("DefaultControl") ); + OUString aStr; + if( aValue >>= aStr ) + aUnoControlTypeName = aStr; + } + + uno::Reference< lang::XComponent > xComp(xUnoControlModel, uno::UNO_QUERY); + if (xComp.is()) + m_pImpl->pEventListener->StartListening(xComp); + } + + // invalidate all ViewObject contacts + ViewContactOfUnoControl* pVC = nullptr; + if ( impl_getViewContact( pVC ) ) + { + // flushViewObjectContacts() removes all existing VOCs for the local DrawHierarchy. This + // is always allowed since they will be re-created on demand (and with the changed model) + GetViewContact().flushViewObjectContacts(); + } +} + + +uno::Reference< awt::XControl > SdrUnoObj::GetUnoControl(const SdrView& _rView, const OutputDevice& _rOut) const +{ + uno::Reference< awt::XControl > xControl; + + SdrPageView* pPageView = _rView.GetSdrPageView(); + OSL_ENSURE( pPageView && getSdrPageFromSdrObject() == pPageView->GetPage(), "SdrUnoObj::GetUnoControl: This object is not displayed in that particular view!" ); + if ( !pPageView || getSdrPageFromSdrObject() != pPageView->GetPage() ) + return nullptr; + + SdrPageWindow* pPageWindow = pPageView->FindPageWindow( _rOut ); + OSL_ENSURE( pPageWindow, "SdrUnoObj::GetUnoControl: did not find my SdrPageWindow!" ); + if ( !pPageWindow ) + return nullptr; + + ViewObjectContact& rViewObjectContact( GetViewContact().GetViewObjectContact( pPageWindow->GetObjectContact() ) ); + ViewObjectContactOfUnoControl* pUnoContact = dynamic_cast< ViewObjectContactOfUnoControl* >( &rViewObjectContact ); + OSL_ENSURE( pUnoContact, "SdrUnoObj::GetUnoControl: wrong contact type!" ); + if ( pUnoContact ) + xControl = pUnoContact->getControl(); + + return xControl; +} + + +uno::Reference< awt::XControl > SdrUnoObj::GetTemporaryControlForWindow( + const vcl::Window& _rWindow, uno::Reference< awt::XControlContainer >& _inout_ControlContainer ) const +{ + uno::Reference< awt::XControl > xControl; + + ViewContactOfUnoControl* pVC = nullptr; + if ( impl_getViewContact( pVC ) ) + xControl = pVC->getTemporaryControlForWindow( _rWindow, _inout_ControlContainer ); + + return xControl; +} + + +bool SdrUnoObj::impl_getViewContact( ViewContactOfUnoControl*& _out_rpContact ) const +{ + ViewContact& rViewContact( GetViewContact() ); + _out_rpContact = dynamic_cast< ViewContactOfUnoControl* >( &rViewContact ); + DBG_ASSERT( _out_rpContact, "SdrUnoObj::impl_getViewContact: could not find my ViewContact!" ); + return ( _out_rpContact != nullptr ); +} + + +std::unique_ptr SdrUnoObj::CreateObjectSpecificViewContact() +{ + return std::make_unique( *this ); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoutl.cxx b/svx/source/svdraw/svdoutl.cxx new file mode 100644 index 0000000000..02bb89e38b --- /dev/null +++ b/svx/source/svdraw/svdoutl.cxx @@ -0,0 +1,120 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include + + +SdrOutliner::SdrOutliner( SfxItemPool* pItemPool, OutlinerMode nMode ) +: Outliner( pItemPool, nMode ), + mpVisualizedPage(nullptr) +{ +} + + +SdrOutliner::~SdrOutliner() +{ +} + + +void SdrOutliner::SetTextObj( const SdrTextObj* pObj ) +{ + if( pObj && pObj != mxWeakTextObj.get().get() ) + { + SetUpdateLayout(false); + OutlinerMode nOutlinerMode2 = OutlinerMode::OutlineObject; + if ( !pObj->IsOutlText() ) + nOutlinerMode2 = OutlinerMode::TextObject; + Init( nOutlinerMode2 ); + + setGlobalScale(100.0, 100.0, 100.0, 100.0); + + EEControlBits nStat = GetControlWord(); + nStat &= ~EEControlBits( EEControlBits::STRETCHING | EEControlBits::AUTOPAGESIZE ); + SetControlWord(nStat); + + Size aMaxSize( 100000,100000 ); + SetMinAutoPaperSize( Size() ); + SetMaxAutoPaperSize( aMaxSize ); + SetPaperSize( aMaxSize ); + SetTextColumns(pObj->GetTextColumnsNumber(), pObj->GetTextColumnsSpacing()); + ClearPolygon(); + } + + mxWeakTextObj = const_cast< SdrTextObj* >(pObj); +} + +void SdrOutliner::SetTextObjNoInit( const SdrTextObj* pObj ) +{ + mxWeakTextObj = const_cast< SdrTextObj* >(pObj); +} + +OUString SdrOutliner::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, + std::optional& rpTxtColor, std::optional& rpFldColor, + std::optional& rpFldLineStyle) +{ + bool bOk = false; + OUString aRet; + + if(auto pTextObj = mxWeakTextObj.get()) + bOk = pTextObj->CalcFieldValue(rField, nPara, nPos, false, rpTxtColor, rpFldColor, rpFldLineStyle, aRet); + + if (!bOk) + aRet = Outliner::CalcFieldValue(rField, nPara, nPos, rpTxtColor, rpFldColor, rpFldLineStyle); + + return aRet; +} + +const SdrTextObj* SdrOutliner::GetTextObj() const +{ + return mxWeakTextObj.get().get(); +} + +bool SdrOutliner::hasEditViewCallbacks() const +{ + for (size_t a(0); a < GetViewCount(); a++) + { + OutlinerView* pOutlinerView = GetView(a); + + if (pOutlinerView && pOutlinerView->GetEditView().getEditViewCallbacks()) + { + return true; + } + } + + return false; +} + +std::optional SdrOutliner::GetCompatFlag(SdrCompatibilityFlag eFlag) const +{ + if( mpVisualizedPage ) + { + return {mpVisualizedPage->getSdrModelFromSdrPage().GetCompatibilityFlag(eFlag)}; + } + return {}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdoutlinercache.cxx b/svx/source/svdraw/svdoutlinercache.cxx new file mode 100644 index 0000000000..0fc6fc9730 --- /dev/null +++ b/svx/source/svdraw/svdoutlinercache.cxx @@ -0,0 +1,95 @@ +/* -*- 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 +#include +#include +#include + +SdrOutlinerCache::SdrOutlinerCache( SdrModel* pModel ) +: mpModel( pModel ) +{ +} + +std::unique_ptr SdrOutlinerCache::createOutliner( OutlinerMode nOutlinerMode ) +{ + std::unique_ptr pOutliner; + + if( (OutlinerMode::OutlineObject == nOutlinerMode) && !maModeOutline.empty() ) + { + pOutliner = std::move(maModeOutline.back()); + maModeOutline.pop_back(); + } + else if( (OutlinerMode::TextObject == nOutlinerMode) && !maModeText.empty() ) + { + pOutliner = std::move(maModeText.back()); + maModeText.pop_back(); + } + else + { + pOutliner = SdrMakeOutliner(nOutlinerMode, *mpModel); + Outliner& aDrawOutliner = mpModel->GetDrawOutliner(); + pOutliner->SetCalcFieldValueHdl( aDrawOutliner.GetCalcFieldValueHdl() ); + maActiveOutliners.insert(pOutliner.get()); + } + + return pOutliner; +} + +SdrOutlinerCache::~SdrOutlinerCache() +{ +} + +void SdrOutlinerCache::disposeOutliner( std::unique_ptr pOutliner ) +{ + if( !pOutliner ) + return; + + OutlinerMode nOutlMode = pOutliner->GetOutlinerMode(); + + if( OutlinerMode::OutlineObject == nOutlMode ) + { + pOutliner->Clear(); + pOutliner->SetVertical( false ); + + // Deregister on outliner, might be reused from outliner cache + pOutliner->SetNotifyHdl( Link() ); + maModeOutline.emplace_back(std::move(pOutliner)); + } + else if( OutlinerMode::TextObject == nOutlMode ) + { + pOutliner->Clear(); + pOutliner->SetVertical( false ); + + // Deregister on outliner, might be reused from outliner cache + pOutliner->SetNotifyHdl( Link() ); + maModeText.emplace_back(std::move(pOutliner)); + } + else + { + maActiveOutliners.erase(pOutliner.get()); + } +} + +std::vector< SdrOutliner* > SdrOutlinerCache::GetActiveOutliners() const +{ + return std::vector< SdrOutliner* >(maActiveOutliners.begin(), maActiveOutliners.end()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdovirt.cxx b/svx/source/svdraw/svdovirt.cxx new file mode 100644 index 0000000000..b1fe6f5cb9 --- /dev/null +++ b/svx/source/svdraw/svdovirt.cxx @@ -0,0 +1,586 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include + +sdr::properties::BaseProperties& SdrVirtObj::GetProperties() const +{ + return mxRefObj->GetProperties(); +} + + +std::unique_ptr SdrVirtObj::CreateObjectSpecificProperties() +{ + return std::make_unique(*this); +} + +// #i27224# +std::unique_ptr SdrVirtObj::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +SdrVirtObj::SdrVirtObj( + SdrModel& rSdrModel, + SdrObject& rNewObj) +: SdrObject(rSdrModel), + mxRefObj(&rNewObj) +{ + m_bVirtObj=true; // this is only a virtual object + mxRefObj->AddReference(*this); + m_bClosedObj = mxRefObj->IsClosedObj(); +} + +SdrVirtObj::SdrVirtObj( + SdrModel& rSdrModel, SdrVirtObj const & rSource) +: SdrObject(rSdrModel, rSource), + mxRefObj(rSource.mxRefObj) +{ + m_bVirtObj=true; // this is only a virtual object + m_bClosedObj = mxRefObj->IsClosedObj(); + + mxRefObj->AddReference(*this); + + aSnapRect = rSource.aSnapRect; + m_aAnchor = rSource.m_aAnchor; +} + +SdrVirtObj::~SdrVirtObj() +{ + mxRefObj->DelReference(*this); +} + +const SdrObject& SdrVirtObj::GetReferencedObj() const +{ + return *mxRefObj; +} + +SdrObject& SdrVirtObj::ReferencedObj() +{ + return *mxRefObj; +} + +void SdrVirtObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/) +{ + m_bClosedObj = mxRefObj->IsClosedObj(); + SetBoundAndSnapRectsDirty(); // TODO: Optimize this. + + // Only a repaint here, rRefObj may have changed and broadcasts + ActionChanged(); +} + +void SdrVirtObj::NbcSetAnchorPos(const Point& rAnchorPos) +{ + m_aAnchor=rAnchorPos; +} + +void SdrVirtObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const +{ + mxRefObj->TakeObjInfo(rInfo); +} + +SdrInventor SdrVirtObj::GetObjInventor() const +{ + return mxRefObj->GetObjInventor(); +} + +SdrObjKind SdrVirtObj::GetObjIdentifier() const +{ + return mxRefObj->GetObjIdentifier(); +} + +SdrObjList* SdrVirtObj::GetSubList() const +{ + return mxRefObj->GetSubList(); +} + +void SdrVirtObj::SetName(const OUString& rStr, const bool bSetChanged) +{ + return mxRefObj->SetName(rStr, bSetChanged); +} + +const OUString & SdrVirtObj::GetName() const +{ + return mxRefObj->GetName(); +} + +void SdrVirtObj::SetTitle(const OUString& rStr) +{ + return mxRefObj->SetTitle(rStr); +} + +OUString SdrVirtObj::GetTitle() const +{ + return mxRefObj->GetTitle(); +} + +void SdrVirtObj::SetDescription(const OUString& rStr) +{ + return mxRefObj->SetDescription(rStr); +} + +OUString SdrVirtObj::GetDescription() const +{ + return mxRefObj->GetDescription(); +} + +void SdrVirtObj::SetDecorative(bool const isDecorative) +{ + return mxRefObj->SetDecorative(isDecorative); +} + +bool SdrVirtObj::IsDecorative() const +{ + return mxRefObj->IsDecorative(); +} + +const tools::Rectangle& SdrVirtObj::GetCurrentBoundRect() const +{ + auto aRectangle = mxRefObj->GetCurrentBoundRect(); // TODO: Optimize this. + aRectangle += m_aAnchor; + setOutRectangleConst(aRectangle); + return getOutRectangle(); +} + +const tools::Rectangle& SdrVirtObj::GetLastBoundRect() const +{ + auto aRectangle = mxRefObj->GetLastBoundRect(); // TODO: Optimize this. + aRectangle += m_aAnchor; + setOutRectangleConst(aRectangle); + return getOutRectangle(); +} + +void SdrVirtObj::RecalcBoundRect() +{ + tools::Rectangle aRectangle = mxRefObj->GetCurrentBoundRect(); + aRectangle += m_aAnchor; + setOutRectangle(aRectangle); +} + +rtl::Reference SdrVirtObj::CloneSdrObject(SdrModel& rTargetModel) const +{ + return new SdrVirtObj(rTargetModel, *this); + // TTTT not sure if the above works - how could SdrObjFactory::MakeNewObject + // create an object with correct rRefObj (?) OTOH VirtObj probably needs not + // to be cloned ever - only used in Writer for multiple instances e.g. Header/Footer + // return new SdrVirtObj( + // getSdrModelFromSdrObject(), + // rRefObj); // only a further reference +} + +OUString SdrVirtObj::TakeObjNameSingul() const +{ + OUString sName = "[" + mxRefObj->TakeObjNameSingul() + "]"; + + OUString aName(GetName()); + if (!aName.isEmpty()) + sName += " '" + aName + "'"; + + return sName; +} + +OUString SdrVirtObj::TakeObjNamePlural() const +{ + return "[" + mxRefObj->TakeObjNamePlural() + "]"; +} + +bool SdrVirtObj::HasLimitedRotation() const +{ + // RotGrfFlyFrame: If true, this SdrObject supports only limited rotation + return mxRefObj->HasLimitedRotation(); +} + +basegfx::B2DPolyPolygon SdrVirtObj::TakeXorPoly() const +{ + basegfx::B2DPolyPolygon aPolyPolygon(mxRefObj->TakeXorPoly()); + + if(m_aAnchor.X() || m_aAnchor.Y()) + { + aPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(m_aAnchor.X(), m_aAnchor.Y())); + } + + return aPolyPolygon; +} + + +sal_uInt32 SdrVirtObj::GetHdlCount() const +{ + return mxRefObj->GetHdlCount(); +} + +void SdrVirtObj::AddToHdlList(SdrHdlList& rHdlList) const +{ + SdrHdlList tempList(nullptr); + mxRefObj->AddToHdlList(tempList); + for (size_t i=0; iGetPos()+m_aAnchor); + pHdl->SetPos(aP); + } + tempList.MoveTo(rHdlList); +} + +void SdrVirtObj::AddToPlusHdlList(SdrHdlList& rHdlList, SdrHdl& rHdl) const +{ + SdrHdlList tempList(nullptr); + mxRefObj->AddToPlusHdlList(tempList, rHdl); + for (size_t i=0; iGetPos()+m_aAnchor); + pHdl->SetPos(aP); + } + tempList.MoveTo(rHdlList); +} + +bool SdrVirtObj::hasSpecialDrag() const +{ + return mxRefObj->hasSpecialDrag(); +} + +bool SdrVirtObj::supportsFullDrag() const +{ + return false; +} + +rtl::Reference SdrVirtObj::getFullDragClone() const +{ + SdrObject& rReferencedObject = const_cast(this)->ReferencedObj(); + return rtl::Reference(new SdrGrafObj( + getSdrModelFromSdrObject(), + SdrDragView::GetObjGraphic(rReferencedObject), + GetLogicRect())); +} + +bool SdrVirtObj::beginSpecialDrag(SdrDragStat& rDrag) const +{ + return mxRefObj->beginSpecialDrag(rDrag); +} + +bool SdrVirtObj::applySpecialDrag(SdrDragStat& rDrag) +{ + return mxRefObj->applySpecialDrag(rDrag); +} + +basegfx::B2DPolyPolygon SdrVirtObj::getSpecialDragPoly(const SdrDragStat& rDrag) const +{ + return mxRefObj->getSpecialDragPoly(rDrag); + // TODO: we don't handle offsets yet! +} + +OUString SdrVirtObj::getSpecialDragComment(const SdrDragStat& rDrag) const +{ + return mxRefObj->getSpecialDragComment(rDrag); +} + + +bool SdrVirtObj::BegCreate(SdrDragStat& rStat) +{ + return mxRefObj->BegCreate(rStat); +} + +bool SdrVirtObj::MovCreate(SdrDragStat& rStat) +{ + return mxRefObj->MovCreate(rStat); +} + +bool SdrVirtObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd) +{ + return mxRefObj->EndCreate(rStat,eCmd); +} + +bool SdrVirtObj::BckCreate(SdrDragStat& rStat) +{ + return mxRefObj->BckCreate(rStat); +} + +void SdrVirtObj::BrkCreate(SdrDragStat& rStat) +{ + mxRefObj->BrkCreate(rStat); +} + +basegfx::B2DPolyPolygon SdrVirtObj::TakeCreatePoly(const SdrDragStat& rDrag) const +{ + return mxRefObj->TakeCreatePoly(rDrag); + // TODO: we don't handle offsets yet! +} + + +void SdrVirtObj::NbcMove(const Size& rSiz) +{ + m_aAnchor.Move(rSiz); + SetBoundAndSnapRectsDirty(); +} + +void SdrVirtObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + mxRefObj->NbcResize(rRef-m_aAnchor,xFact,yFact); + SetBoundAndSnapRectsDirty(); +} + +void SdrVirtObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + mxRefObj->NbcRotate(rRef-m_aAnchor,nAngle,sn,cs); + SetBoundAndSnapRectsDirty(); +} + +void SdrVirtObj::NbcMirror(const Point& rRef1, const Point& rRef2) +{ + mxRefObj->NbcMirror(rRef1-m_aAnchor,rRef2-m_aAnchor); + SetBoundAndSnapRectsDirty(); +} + +void SdrVirtObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + mxRefObj->NbcShear(rRef-m_aAnchor,nAngle,tn,bVShear); + SetBoundAndSnapRectsDirty(); +} + + +void SdrVirtObj::Move(const Size& rSiz) +{ + if (!rSiz.IsEmpty()) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + NbcMove(rSiz); + SetChanged(); + BroadcastObjectChange(); + SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0); + } +} + +void SdrVirtObj::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative) +{ + if (xFact.GetNumerator()!=xFact.GetDenominator() || yFact.GetNumerator()!=yFact.GetDenominator()) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + mxRefObj->Resize(rRef-m_aAnchor,xFact,yFact, bUnsetRelative); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrVirtObj::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs) +{ + if (nAngle) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + mxRefObj->Rotate(rRef-m_aAnchor,nAngle,sn,cs); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + +void SdrVirtObj::Mirror(const Point& rRef1, const Point& rRef2) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + mxRefObj->Mirror(rRef1-m_aAnchor,rRef2-m_aAnchor); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrVirtObj::Shear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear) +{ + if (nAngle) { + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + mxRefObj->Shear(rRef-m_aAnchor,nAngle,tn,bVShear); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); + } +} + + +void SdrVirtObj::RecalcSnapRect() +{ + aSnapRect=mxRefObj->GetSnapRect(); + aSnapRect+=m_aAnchor; +} + +const tools::Rectangle& SdrVirtObj::GetSnapRect() const +{ + const_cast(this)->aSnapRect=mxRefObj->GetSnapRect(); + const_cast(this)->aSnapRect+=m_aAnchor; + return aSnapRect; +} + +void SdrVirtObj::SetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + tools::Rectangle aR(rRect); + aR-=m_aAnchor; + mxRefObj->SetSnapRect(aR); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrVirtObj::NbcSetSnapRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aR(rRect); + aR-=m_aAnchor; + SetBoundAndSnapRectsDirty(); + mxRefObj->NbcSetSnapRect(aR); +} + + +const tools::Rectangle& SdrVirtObj::GetLogicRect() const +{ + const_cast(this)->aSnapRect=mxRefObj->GetLogicRect(); // An abuse of aSnapRect! + const_cast(this)->aSnapRect+=m_aAnchor; // If there's trouble, we need another Rectangle Member (or a Heap). + return aSnapRect; +} + +void SdrVirtObj::SetLogicRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + tools::Rectangle aR(rRect); + aR-=m_aAnchor; + mxRefObj->SetLogicRect(aR); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + +void SdrVirtObj::NbcSetLogicRect(const tools::Rectangle& rRect) +{ + tools::Rectangle aR(rRect); + aR-=m_aAnchor; + SetBoundAndSnapRectsDirty(); + mxRefObj->NbcSetLogicRect(aR); +} + + +Degree100 SdrVirtObj::GetRotateAngle() const +{ + return mxRefObj->GetRotateAngle(); +} + +Degree100 SdrVirtObj::GetShearAngle(bool bVertical) const +{ + return mxRefObj->GetShearAngle(bVertical); +} + + +sal_uInt32 SdrVirtObj::GetSnapPointCount() const +{ + return mxRefObj->GetSnapPointCount(); +} + +Point SdrVirtObj::GetSnapPoint(sal_uInt32 i) const +{ + Point aP(mxRefObj->GetSnapPoint(i)); + aP+=m_aAnchor; + return aP; +} + +bool SdrVirtObj::IsPolyObj() const +{ + return mxRefObj->IsPolyObj(); +} + +sal_uInt32 SdrVirtObj::GetPointCount() const +{ + return mxRefObj->GetPointCount(); +} + +Point SdrVirtObj::GetPoint(sal_uInt32 i) const +{ + return mxRefObj->GetPoint(i) + m_aAnchor; +} + +void SdrVirtObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i) +{ + Point aP(rPnt); + aP-=m_aAnchor; + mxRefObj->SetPoint(aP,i); + SetBoundAndSnapRectsDirty(); +} + + +std::unique_ptr SdrVirtObj::NewGeoData() const +{ + return mxRefObj->NewGeoData(); +} + +void SdrVirtObj::SaveGeoData(SdrObjGeoData& rGeo) const +{ + mxRefObj->SaveGeoData(rGeo); +} + +void SdrVirtObj::RestoreGeoData(const SdrObjGeoData& rGeo) +{ + mxRefObj->RestoreGeoData(rGeo); + SetBoundAndSnapRectsDirty(); +} + + +std::unique_ptr SdrVirtObj::GetGeoData() const +{ + return mxRefObj->GetGeoData(); +} + +void SdrVirtObj::SetGeoData(const SdrObjGeoData& rGeo) +{ + tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect(); + mxRefObj->SetGeoData(rGeo); + SetBoundAndSnapRectsDirty(); + SendUserCall(SdrUserCallType::Resize,aBoundRect0); +} + + +void SdrVirtObj::NbcReformatText() +{ + mxRefObj->NbcReformatText(); +} + +bool SdrVirtObj::HasMacro() const +{ + return mxRefObj->HasMacro(); +} + +SdrObject* SdrVirtObj::CheckMacroHit(const SdrObjMacroHitRec& rRec) const +{ + return mxRefObj->CheckMacroHit(rRec); // TODO: positioning offset +} + +PointerStyle SdrVirtObj::GetMacroPointer(const SdrObjMacroHitRec& rRec) const +{ + return mxRefObj->GetMacroPointer(rRec); // TODO: positioning offset +} + +void SdrVirtObj::PaintMacro(OutputDevice& rOut, const tools::Rectangle& rDirtyRect, const SdrObjMacroHitRec& rRec) const +{ + mxRefObj->PaintMacro(rOut,rDirtyRect,rRec); // TODO: positioning offset +} + +bool SdrVirtObj::DoMacro(const SdrObjMacroHitRec& rRec) +{ + return mxRefObj->DoMacro(rRec); // TODO: positioning offset +} + +Point SdrVirtObj::GetOffset() const +{ + // #i73248# default offset of SdrVirtObj is aAnchor + return m_aAnchor; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdpage.cxx b/svx/source/svdraw/svdpage.cxx new file mode 100644 index 0000000000..adc8555bf1 --- /dev/null +++ b/svx/source/svdraw/svdpage.cxx @@ -0,0 +1,1877 @@ +/* -*- 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 +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace ::com::sun::star; + +////////////////////////////////////////////////////////////////////////////// + +SdrObjList::SdrObjList() +: mbObjOrdNumsDirty(false), + mbRectsDirty(false), + mbIsNavigationOrderDirty(false) +{ +} + +void SdrObjList::impClearSdrObjList(bool bBroadcast) +{ + SdrModel* pSdrModelFromRemovedSdrObject(nullptr); + + while(!maList.empty()) + { + // remove last object from list + rtl::Reference pObj(maList.back()); + RemoveObjectFromContainer(maList.size()-1); + + // flushViewObjectContacts() is done since SdrObject::Free is not guaranteed + // to delete the object and thus refresh visualisations + pObj->GetViewContact().flushViewObjectContacts(); + + if(bBroadcast) + { + if(nullptr == pSdrModelFromRemovedSdrObject) + { + pSdrModelFromRemovedSdrObject = &pObj->getSdrModelFromSdrObject(); + } + + // sent remove hint (after removal, see RemoveObject()) + // TTTT SdrPage not needed, can be accessed using SdrObject + SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj, getSdrPageFromSdrObjList()); + pObj->getSdrModelFromSdrObject().Broadcast(aHint); + } + pObj->setParentOfSdrObject(nullptr); + } + + if(bBroadcast && nullptr != pSdrModelFromRemovedSdrObject) + { + pSdrModelFromRemovedSdrObject->SetChanged(); + } +} + +void SdrObjList::ClearSdrObjList() +{ + // clear SdrObjects with broadcasting + impClearSdrObjList(true); +} + +SdrObjList::~SdrObjList() +{ + // Clear SdrObjects without broadcasting. + for (auto& rxObj : maList) + rxObj->setParentOfSdrObject(nullptr); +} + +SdrPage* SdrObjList::getSdrPageFromSdrObjList() const +{ + // default is no page and returns zero + return nullptr; +} + +SdrObject* SdrObjList::getSdrObjectFromSdrObjList() const +{ + // default is no SdrObject (SdrObjGroup) + return nullptr; +} + +void SdrObjList::CopyObjects(const SdrObjList& rSrcList) +{ + CloneList aCloneList; + + // clear SdrObjects with broadcasting + ClearSdrObjList(); + + mbObjOrdNumsDirty = false; + mbRectsDirty = false; +#ifdef DBG_UTIL + size_t nCloneErrCnt(0); +#endif + + if(nullptr == getSdrObjectFromSdrObjList() && nullptr == getSdrPageFromSdrObjList()) + { + OSL_ENSURE(false, "SdrObjList which is not part of SdrPage or SdrObject (!)"); + return; + } + + SdrModel& rTargetSdrModel(nullptr == getSdrObjectFromSdrObjList() + ? getSdrPageFromSdrObjList()->getSdrModelFromSdrPage() + : getSdrObjectFromSdrObjList()->getSdrModelFromSdrObject()); + + for (const rtl::Reference& pSO : rSrcList) + { + rtl::Reference pDO(pSO->CloneSdrObject(rTargetSdrModel)); + + if(pDO) + { + NbcInsertObject(pDO.get(), SAL_MAX_SIZE); + aCloneList.AddPair(pSO.get(), pDO.get()); + } +#ifdef DBG_UTIL + else + { + nCloneErrCnt++; + } +#endif + } + + // Wires up the connections + aCloneList.CopyConnections(); +#ifdef DBG_UTIL + if (nCloneErrCnt != 0) + { + OStringBuffer aStr("SdrObjList::operator=(): Error when cloning "); + + if(nCloneErrCnt == 1) + { + aStr.append("a drawing object."); + } + else + { + aStr.append(OString::number(static_cast(nCloneErrCnt)) + + " drawing objects."); + } + + OSL_FAIL(aStr.getStr()); + } +#endif +} + +void SdrObjList::RecalcObjOrdNums() +{ + size_t no=0; + for (const rtl::Reference& pObj : maList) + pObj->SetOrdNum(no++); + mbObjOrdNumsDirty=false; +} + +void SdrObjList::RecalcRects() +{ + maSdrObjListOutRect=tools::Rectangle(); + maSdrObjListSnapRect=maSdrObjListOutRect; + for (auto it = begin(), itEnd = end(); it != itEnd; ++it) { + SdrObject* pObj = it->get(); + if (it == begin()) { + maSdrObjListOutRect=pObj->GetCurrentBoundRect(); + maSdrObjListSnapRect=pObj->GetSnapRect(); + } else { + maSdrObjListOutRect.Union(pObj->GetCurrentBoundRect()); + maSdrObjListSnapRect.Union(pObj->GetSnapRect()); + } + } +} + +void SdrObjList::SetSdrObjListRectsDirty() +{ + mbRectsDirty=true; + SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList()); + + if(nullptr != pParentSdrObject) + { + pParentSdrObject->SetBoundAndSnapRectsDirty(); + } +} + +void SdrObjList::impChildInserted(SdrObject const & rChild) +{ + sdr::contact::ViewContact* pParent = rChild.GetViewContact().GetParentContact(); + + if(pParent) + { + pParent->ActionChildInserted(rChild.GetViewContact()); + } +} + +void SdrObjList::NbcInsertObject(SdrObject* pObj, size_t nPos) +{ + DBG_ASSERT(pObj!=nullptr,"SdrObjList::NbcInsertObject(NULL)"); + if (pObj==nullptr) + return; + + DBG_ASSERT(!pObj->IsInserted(),"The object already has the status Inserted."); + const size_t nCount = GetObjCount(); + if (nPos>nCount) nPos=nCount; + InsertObjectIntoContainer(*pObj,nPos); + + if (nPosSetOrdNum(nPos); + pObj->setParentOfSdrObject(this); + + // Inform the parent about change to allow invalidations at + // evtl. existing parent visualisations + impChildInserted(*pObj); + + if (!mbRectsDirty) { + mbRectsDirty = true; + } + pObj->InsertedStateChange(); // calls the UserCall (among others) +} + +void SdrObjList::InsertObjectThenMakeNameUnique(SdrObject* pObj) +{ + std::unordered_set aNameSet; + InsertObjectThenMakeNameUnique(pObj, aNameSet); +} + +void SdrObjList::InsertObjectThenMakeNameUnique(SdrObject* pObj, std::unordered_set& rNameSet, size_t nPos) +{ + InsertObject(pObj, nPos); + if (pObj->GetName().isEmpty()) + return; + + pObj->MakeNameUnique(rNameSet); + SdrObjList* pSdrObjList = pObj->GetSubList(); // group + if (pSdrObjList) + { + SdrObject* pListObj; + SdrObjListIter aIter(pSdrObjList, SdrIterMode::DeepWithGroups); + while (aIter.IsMore()) + { + pListObj = aIter.Next(); + pListObj->MakeNameUnique(rNameSet); + } + } +} + +void SdrObjList::InsertObject(SdrObject* pObj, size_t nPos) +{ + DBG_ASSERT(pObj!=nullptr,"SdrObjList::InsertObject(NULL)"); + + if(!pObj) + return; + + // if anchor is used, reset it before grouping + if(getSdrObjectFromSdrObjList()) + { + const Point& rAnchorPos = pObj->GetAnchorPos(); + if(rAnchorPos.X() || rAnchorPos.Y()) + pObj->NbcSetAnchorPos(Point()); + } + + // do insert to new group + NbcInsertObject(pObj, nPos); + + // In case the object is inserted into a group and doesn't overlap with + // the group's other members, it needs an own repaint. + SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList()); + + if(pParentSdrObject) + { + // only repaint here + pParentSdrObject->ActionChanged(); + } + + // TODO: We need a different broadcast here! + // Repaint from object number ... (heads-up: GroupObj) + if(pObj->getSdrPageFromSdrObject() && !pObj->getSdrModelFromSdrObject().isLocked()) + { + SdrHint aHint(SdrHintKind::ObjectInserted, *pObj); + pObj->getSdrModelFromSdrObject().Broadcast(aHint); + } + + pObj->getSdrModelFromSdrObject().SetChanged(); +} + +rtl::Reference SdrObjList::NbcRemoveObject(size_t nObjNum) +{ + if (nObjNum >= maList.size()) + { + OSL_ASSERT(nObjNum pObj=maList[nObjNum]; + RemoveObjectFromContainer(nObjNum); + + DBG_ASSERT(pObj!=nullptr,"Could not find object to remove."); + if (pObj!=nullptr) + { + // flushViewObjectContacts() clears the VOC's and those invalidate + pObj->GetViewContact().flushViewObjectContacts(); + + DBG_ASSERT(pObj->IsInserted(),"The object does not have the status Inserted."); + + // tdf#121022 Do first remove from SdrObjList - InsertedStateChange + // relies now on IsInserted which uses getParentSdrObjListFromSdrObject + pObj->setParentOfSdrObject(nullptr); + + // calls UserCall, among other + pObj->InsertedStateChange(); + + if (!mbObjOrdNumsDirty) + { + // optimizing for the case that the last object has to be removed + if (nObjNum+1!=nCount) { + mbObjOrdNumsDirty=true; + } + } + SetSdrObjListRectsDirty(); + } + return pObj; +} + +rtl::Reference SdrObjList::RemoveObject(size_t nObjNum) +{ + if (nObjNum >= maList.size()) + { + OSL_ASSERT(nObjNum pObj=maList[nObjNum]; + RemoveObjectFromContainer(nObjNum); + + DBG_ASSERT(pObj!=nullptr,"Object to remove not found."); + if(pObj) + { + // flushViewObjectContacts() clears the VOC's and those invalidate + pObj->GetViewContact().flushViewObjectContacts(); + DBG_ASSERT(pObj->IsInserted(),"The object does not have the status Inserted."); + + // TODO: We need a different broadcast here. + if (pObj->getSdrPageFromSdrObject()!=nullptr) + { + SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj); + pObj->getSdrModelFromSdrObject().Broadcast(aHint); + } + + pObj->getSdrModelFromSdrObject().SetChanged(); + + // tdf#121022 Do first remove from SdrObjList - InsertedStateChange + // relies now on IsInserted which uses getParentSdrObjListFromSdrObject + pObj->setParentOfSdrObject(nullptr); + + // calls, among other things, the UserCall + pObj->InsertedStateChange(); + + if (!mbObjOrdNumsDirty) + { + // optimization for the case that the last object is removed + if (nObjNum+1!=nCount) { + mbObjOrdNumsDirty=true; + } + } + + SetSdrObjListRectsDirty(); + SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList()); + + if(pParentSdrObject && !GetObjCount()) + { + // empty group created; it needs to be repainted since it's + // visualization changes + pParentSdrObject->ActionChanged(); + } + } + return pObj; +} + +rtl::Reference SdrObjList::ReplaceObject(SdrObject* pNewObj, size_t nObjNum) +{ + if (nObjNum >= maList.size()) + { + OSL_ASSERT(nObjNum pObj=maList[nObjNum]; + DBG_ASSERT(pObj!=nullptr,"SdrObjList::ReplaceObject: Could not find object to remove."); + if (pObj!=nullptr) { + DBG_ASSERT(pObj->IsInserted(),"SdrObjList::ReplaceObject: the object does not have status Inserted."); + + // TODO: We need a different broadcast here. + if (pObj->getSdrPageFromSdrObject()!=nullptr) + { + SdrHint aHint(SdrHintKind::ObjectRemoved, *pObj); + pObj->getSdrModelFromSdrObject().Broadcast(aHint); + } + + // Change parent and replace in SdrObjList + pObj->setParentOfSdrObject(nullptr); + ReplaceObjectInContainer(*pNewObj,nObjNum); + + // tdf#121022 InsertedStateChange uses the parent + // to detect if pObj is inserted or not, so have to call + // it *after* changing these settings, else an obviously wrong + // 'SdrUserCallType::Inserted' would be sent + pObj->InsertedStateChange(); + + // flushViewObjectContacts() clears the VOC's and those + // trigger the evtl. needed invalidate(s) + pObj->GetViewContact().flushViewObjectContacts(); + + // Setup data at new SdrObject - it already *is* inserted to + // the SdrObjList due to 'ReplaceObjectInContainer' above + pNewObj->SetOrdNum(nObjNum); + pNewObj->setParentOfSdrObject(this); + + // Inform the parent about change to allow invalidations at + // evtl. existing parent visualisations, but also react on + // newly inserted SdrObjects (as e.g. GraphCtrlUserCall does) + impChildInserted(*pNewObj); + + pNewObj->InsertedStateChange(); + + // TODO: We need a different broadcast here. + if (pNewObj->getSdrPageFromSdrObject()!=nullptr) { + SdrHint aHint(SdrHintKind::ObjectInserted, *pNewObj); + pNewObj->getSdrModelFromSdrObject().Broadcast(aHint); + } + + pNewObj->getSdrModelFromSdrObject().SetChanged(); + + SetSdrObjListRectsDirty(); + } + return pObj; +} + +SdrObject* SdrObjList::SetObjectOrdNum(size_t nOldObjNum, size_t nNewObjNum) +{ + if (nOldObjNum >= maList.size() || nNewObjNum >= maList.size()) + { + OSL_ASSERT(nOldObjNum pObj=maList[nOldObjNum]; + if (nOldObjNum==nNewObjNum) return pObj.get(); + DBG_ASSERT(pObj!=nullptr,"SdrObjList::SetObjectOrdNum: Object not found."); + if (pObj!=nullptr) { + DBG_ASSERT(pObj->IsInserted(),"SdrObjList::SetObjectOrdNum: the object does not have status Inserted."); + RemoveObjectFromContainer(nOldObjNum); + InsertObjectIntoContainer(*pObj,nNewObjNum); + + // No need to delete visualisation data since same object + // gets inserted again. Also a single ActionChanged is enough + pObj->ActionChanged(); + + pObj->SetOrdNum(nNewObjNum); + mbObjOrdNumsDirty=true; + + // TODO: We need a different broadcast here. + if (pObj->getSdrPageFromSdrObject()!=nullptr) + pObj->getSdrModelFromSdrObject().Broadcast(SdrHint(SdrHintKind::ObjectChange, *pObj)); + pObj->getSdrModelFromSdrObject().SetChanged(); + } + return pObj.get(); +} + +void SdrObjList::SetExistingObjectOrdNum(SdrObject* pObj, size_t nNewObjNum) +{ + assert(std::find(maList.begin(), maList.end(), pObj) != maList.end() && "This method requires that the child object already be inserted"); + assert(pObj->IsInserted() && "SdrObjList::SetObjectOrdNum: the object does not have status Inserted."); + + // I am deliberately bypassing getOrdNum() because I don't want to unnecessarily + // trigger RecalcObjOrdNums() + const sal_uInt32 nOldOrdNum = pObj->m_nOrdNum; + if (!mbObjOrdNumsDirty && nOldOrdNum == nNewObjNum) + return; + + // Update the navigation positions. + if (HasObjectNavigationOrder()) + { + unotools::WeakReference aReference (pObj); + auto iObject = ::std::find( + mxNavigationOrder->begin(), + mxNavigationOrder->end(), + aReference); + mxNavigationOrder->erase(iObject); + mbIsNavigationOrderDirty = true; + // The new object does not have a user defined position so append it + // to the list. + pObj->SetNavigationPosition(mxNavigationOrder->size()); + mxNavigationOrder->push_back(pObj); + } + if (nOldOrdNum < maList.size() && maList[nOldOrdNum] == pObj) + maList.erase(maList.begin()+nOldOrdNum); + else + { + auto it = std::find(maList.begin(), maList.end(), pObj); + maList.erase(it); + } + // Insert object into object list. Because the insert() method requires + // a valid iterator as insertion position, we have to use push_back() to + // insert at the end of the list. + if (nNewObjNum >= maList.size()) + maList.push_back(pObj); + else + maList.insert(maList.begin()+nNewObjNum, pObj); + + mbObjOrdNumsDirty=true; + + // No need to delete visualisation data since same object + // gets inserted again. Also a single ActionChanged is enough + pObj->ActionChanged(); + + pObj->SetOrdNum(nNewObjNum); + mbObjOrdNumsDirty=true; + + // TODO: We need a different broadcast here. + if (pObj->getSdrPageFromSdrObject()!=nullptr) + pObj->getSdrModelFromSdrObject().Broadcast(SdrHint(SdrHintKind::ObjectChange, *pObj)); + pObj->getSdrModelFromSdrObject().SetChanged(); +} + +void SdrObjList::sort( std::vector& sortOrder) +{ + // no negative indexes and indexes larger than maList size are allowed + auto it = std::find_if( sortOrder.begin(), sortOrder.end(), [this](const sal_Int32& rIt) + { return ( rIt < 0 || o3tl::make_unsigned(rIt) >= maList.size() ); } ); + if ( it != sortOrder.end()) + throw css::lang::IllegalArgumentException("negative index of shape", nullptr, 1); + + // no duplicates + std::vector aNoDuplicates(sortOrder.size(), false); + for (size_t i = 0; i < sortOrder.size(); ++i ) + { + size_t idx = static_cast( sortOrder[i] ); + + if ( aNoDuplicates[idx] ) + throw css::lang::IllegalArgumentException("duplicate index of shape", nullptr, 2); + + aNoDuplicates[idx] = true; + } + + // example sortOrder [2 0 1] + // example maList [T T S T T] ( T T = shape with textbox, S = just a shape ) + // (shapes at positions 0 and 2 have a textbox) + + std::deque> aNewList(maList.size()); + std::set aShapesWithTextbox; + std::vector aIncrements; + std::vector aDuplicates; + + if ( maList.size() > 1) + { + for (size_t i = 1; i< maList.size(); ++i) + { + // if this shape is a textbox, then look at its left neighbour + // (shape this textbox is in) + // and insert the number of textboxes to the left of it + if (maList[i]->IsTextBox()) + aShapesWithTextbox.insert( i - 1 - aShapesWithTextbox.size() ); + } + // example aShapesWithTextbox [0 2] + } + + if (aShapesWithTextbox.size() != maList.size() - sortOrder.size()) + { + throw lang::IllegalArgumentException("mismatch of no. of shapes", nullptr, 0); + } + + for (size_t i = 0; i< sortOrder.size(); ++i) + { + + if (aShapesWithTextbox.count(sortOrder[i]) > 0) + aDuplicates.push_back(sortOrder[i]); + + aDuplicates.push_back(sortOrder[i]); + + // example aDuplicates [2 2 0 0 1] + } + assert(aDuplicates.size() == maList.size()); + + aIncrements.push_back(0); + for (size_t i = 1; i< sortOrder.size(); ++i) + { + if (aShapesWithTextbox.count(i - 1)) + aIncrements.push_back(aIncrements[i-1] + 1 ); + else + aIncrements.push_back(aIncrements[i-1]); + + // example aIncrements [0 1 1] + } + assert(aIncrements.size() == sortOrder.size()); + + std::vector aNewSortOrder(maList.size()); + sal_Int32 nPrev = -1; + for (size_t i = 0; i< aDuplicates.size(); ++i) + { + if (nPrev != aDuplicates[i]) + aNewSortOrder[i] = aDuplicates[i] + aIncrements[aDuplicates[i]]; + else + aNewSortOrder[i] = aNewSortOrder[i-1] + 1; + + nPrev = aDuplicates[i]; + + // example aNewSortOrder [3 4 0 1 2] + } + assert(aNewSortOrder.size() == maList.size()); + +#ifndef NDEBUG + { + std::vector tmp(aNewSortOrder); + std::sort(tmp.begin(), tmp.end()); + for (size_t i = 0; i < tmp.size(); ++i) + { + assert(size_t(tmp[i]) == i); + } + } +#endif + + SdrModel & rModel(getSdrPageFromSdrObjList()->getSdrModelFromSdrPage()); + bool const isUndo(rModel.IsUndoEnabled()); + if (isUndo) + { + rModel.AddUndo(SdrUndoFactory::CreateUndoSort(*getSdrPageFromSdrObjList(), sortOrder)); + } + + for (size_t i = 0; i < aNewSortOrder.size(); ++i) + { + aNewList[i] = maList[ aNewSortOrder[i] ]; + aNewList[i]->SetOrdNum(i); + } + + std::swap(aNewList, maList); +} + +const tools::Rectangle& SdrObjList::GetAllObjSnapRect() const +{ + if (mbRectsDirty) { + const_cast(this)->RecalcRects(); + const_cast(this)->mbRectsDirty=false; + } + return maSdrObjListSnapRect; +} + +const tools::Rectangle& SdrObjList::GetAllObjBoundRect() const +{ + // #i106183# for deep group hierarchies like in chart2, the invalidates + // through the hierarchy are not correct; use a 2nd hint for the needed + // recalculation. Future versions will have no bool flag at all, but + // just maSdrObjListOutRect in empty state to represent an invalid state, thus + // it's a step in the right direction. + if (mbRectsDirty || maSdrObjListOutRect.IsEmpty()) + { + const_cast(this)->RecalcRects(); + const_cast(this)->mbRectsDirty=false; + } + return maSdrObjListOutRect; +} + +void SdrObjList::NbcReformatAllTextObjects() +{ + size_t nCount=GetObjCount(); + size_t nNum=0; + + while (nNumNbcReformatText(); + nCount=GetObjCount(); // ReformatText may delete an object + nNum++; + } + +} + +void SdrObjList::ReformatAllTextObjects() +{ + NbcReformatAllTextObjects(); +} + +/** steps over all available objects and reformats all + edge objects that are connected to other objects so that + they may reposition themselves. +*/ +void SdrObjList::ReformatAllEdgeObjects() +{ + ImplReformatAllEdgeObjects(*this); +} + +void SdrObjList::ImplReformatAllEdgeObjects(const SdrObjList& rObjList) +{ + // #i120437# go over whole hierarchy, not only over object level null (seen from grouping) + for(size_t nIdx(0), nCount(rObjList.GetObjCount()); nIdx < nCount; ++nIdx) + { + SdrObject* pSdrObject(rObjList.GetObjectForNavigationPosition(nIdx)); + const SdrObjList* pChildren(pSdrObject->getChildrenOfSdrObject()); + const bool bIsGroup(nullptr != pChildren); + if(!bIsGroup) + { + // Check IsVirtualObj because sometimes we get SwDrawVirtObj here + if (pSdrObject->GetObjIdentifier() == SdrObjKind::Edge + && !pSdrObject->IsVirtualObj()) + { + SdrEdgeObj* pSdrEdgeObj = static_cast< SdrEdgeObj* >(pSdrObject); + pSdrEdgeObj->Reformat(); + } + } + else + { + ImplReformatAllEdgeObjects(*pChildren); + } + } +} + +void SdrObjList::BurnInStyleSheetAttributes() +{ + for (const rtl::Reference& pObj : *this) + pObj->BurnInStyleSheetAttributes(); +} + +size_t SdrObjList::GetObjCount() const +{ + return maList.size(); +} + + +SdrObject* SdrObjList::GetObj(size_t nNum) const +{ + if (nNum < maList.size()) + return maList[nNum].get(); + + return nullptr; +} + +SdrObject* SdrObjList::GetObjByName(std::u16string_view sName) const +{ + for (const rtl::Reference& pObj : *this) + { + if (pObj->GetName() == sName) + return pObj.get(); + } + return nullptr; +} + + +bool SdrObjList::IsReadOnly() const +{ + bool bRet(false); + SdrObject* pParentSdrObject(getSdrObjectFromSdrObjList()); + + if(nullptr != pParentSdrObject) + { + SdrPage* pSdrPage(pParentSdrObject->getSdrPageFromSdrObject()); + + if(nullptr != pSdrPage) + { + bRet = pSdrPage->IsReadOnly(); + } + } + + return bRet; +} + +void SdrObjList::FlattenGroups() +{ + const size_t nObj = GetObjCount(); + for( size_t i = nObj; i>0; ) + UnGroupObj(--i); +} + +void SdrObjList::UnGroupObj( size_t nObjNum ) +{ + // if the given object is no group, this method is a noop + SdrObject* pUngroupObj = GetObj( nObjNum ); + if( pUngroupObj ) + { + SdrObjList* pSrcLst = pUngroupObj->GetSubList(); + if(pSrcLst) + if(auto pUngroupGroup = dynamic_cast( pUngroupObj)) + { + // ungroup recursively (has to be head recursion, + // otherwise our indices will get trashed when doing it in + // the loop) + pSrcLst->FlattenGroups(); + + // the position at which we insert the members of rUngroupGroup + size_t nInsertPos( pUngroupGroup->GetOrdNum() ); + + const size_t nCount = pSrcLst->GetObjCount(); + for( size_t i=0; i pObj = pSrcLst->RemoveObject(0); + InsertObject(pObj.get(), nInsertPos); + ++nInsertPos; + } + + RemoveObject(nInsertPos); + } + } +#ifdef DBG_UTIL + else + OSL_FAIL("SdrObjList::UnGroupObj: object index invalid"); +#endif +} + +bool SdrObjList::HasObjectNavigationOrder() const { return bool(mxNavigationOrder); } + +void SdrObjList::SetObjectNavigationPosition ( + SdrObject& rObject, + const sal_uInt32 nNewPosition) +{ + // When the navigation order container has not yet been created then + // create one now. It is initialized with the z-order taken from + // maList. + if (!mxNavigationOrder) + { + mxNavigationOrder.emplace(maList.begin(), maList.end()); + } + OSL_ASSERT(bool(mxNavigationOrder)); + OSL_ASSERT( mxNavigationOrder->size() == maList.size()); + + unotools::WeakReference aReference (&rObject); + + // Look up the object whose navigation position is to be changed. + auto iObject = ::std::find( + mxNavigationOrder->begin(), + mxNavigationOrder->end(), + aReference); + if (iObject == mxNavigationOrder->end()) + { + // The given object is not a member of the navigation order. + return; + } + + // Move the object to its new position. + const sal_uInt32 nOldPosition = ::std::distance(mxNavigationOrder->begin(), iObject); + if (nOldPosition == nNewPosition) + return; + + mxNavigationOrder->erase(iObject); + sal_uInt32 nInsertPosition (nNewPosition); + // Adapt insertion position for the just erased object. + if (nNewPosition >= nOldPosition) + nInsertPosition -= 1; + if (nInsertPosition >= mxNavigationOrder->size()) + mxNavigationOrder->push_back(aReference); + else + mxNavigationOrder->insert(mxNavigationOrder->begin()+nInsertPosition, aReference); + + mbIsNavigationOrderDirty = true; + + // The navigation order is written out to file so mark the model as modified. + rObject.getSdrModelFromSdrObject().SetChanged(); +} + + +SdrObject* SdrObjList::GetObjectForNavigationPosition (const sal_uInt32 nNavigationPosition) const +{ + if (HasObjectNavigationOrder()) + { + // There is a user defined navigation order. Make sure the object + // index is correct and look up the object in mxNavigationOrder. + if (nNavigationPosition >= mxNavigationOrder->size()) + { + OSL_ASSERT(nNavigationPosition < mxNavigationOrder->size()); + } + else + return (*mxNavigationOrder)[nNavigationPosition].get().get(); + } + else + { + // There is no user defined navigation order. Use the z-order + // instead. + if (nNavigationPosition >= maList.size()) + { + OSL_ASSERT(nNavigationPosition < maList.size()); + } + else + return maList[nNavigationPosition].get(); + } + return nullptr; +} + + +void SdrObjList::ClearObjectNavigationOrder() +{ + mxNavigationOrder.reset(); + mbIsNavigationOrderDirty = true; +} + + +bool SdrObjList::RecalcNavigationPositions() +{ + if (mbIsNavigationOrderDirty) + { + if (mxNavigationOrder) + { + mbIsNavigationOrderDirty = false; + + sal_uInt32 nIndex (0); + for (auto& rpObject : *mxNavigationOrder) + { + rpObject.get()->SetNavigationPosition(nIndex); + ++nIndex; + } + } + } + + return bool(mxNavigationOrder); +} + + +void SdrObjList::SetNavigationOrder (const uno::Reference& rxOrder) +{ + if (rxOrder.is()) + { + const sal_Int32 nCount = rxOrder->getCount(); + if (static_cast(nCount) != maList.size()) + return; + + if (!mxNavigationOrder) + mxNavigationOrder = std::vector>(nCount); + + for (sal_Int32 nIndex=0; nIndex xShape (rxOrder->getByIndex(nIndex), uno::UNO_QUERY); + SdrObject* pObject = SdrObject::getSdrObjectFromXShape(xShape); + if (pObject == nullptr) + break; + (*mxNavigationOrder)[nIndex] = pObject; + } + + mbIsNavigationOrderDirty = true; + } + else + { + ClearObjectNavigationOrder(); + } +} + + +void SdrObjList::InsertObjectIntoContainer ( + SdrObject& rObject, + const sal_uInt32 nInsertPosition) +{ + OSL_ASSERT(nInsertPosition<=maList.size()); + + // Update the navigation positions. + if (HasObjectNavigationOrder()) + { + // The new object does not have a user defined position so append it + // to the list. + rObject.SetNavigationPosition(mxNavigationOrder->size()); + mxNavigationOrder->push_back(&rObject); + } + + // Insert object into object list. Because the insert() method requires + // a valid iterator as insertion position, we have to use push_back() to + // insert at the end of the list. + if (nInsertPosition >= maList.size()) + maList.push_back(&rObject); + else + maList.insert(maList.begin()+nInsertPosition, &rObject); + mbObjOrdNumsDirty=true; +} + + +void SdrObjList::ReplaceObjectInContainer ( + SdrObject& rNewObject, + const sal_uInt32 nObjectPosition) +{ + if (nObjectPosition >= maList.size()) + { + OSL_ASSERT(nObjectPosition aReference (maList[nObjectPosition].get()); + auto iObject = ::std::find( + mxNavigationOrder->begin(), + mxNavigationOrder->end(), + aReference); + if (iObject != mxNavigationOrder->end()) + mxNavigationOrder->erase(iObject); + + mxNavigationOrder->push_back(&rNewObject); + + mbIsNavigationOrderDirty = true; + } + + maList[nObjectPosition] = &rNewObject; + mbObjOrdNumsDirty=true; +} + + +void SdrObjList::RemoveObjectFromContainer ( + const sal_uInt32 nObjectPosition) +{ + if (nObjectPosition >= maList.size()) + { + OSL_ASSERT(nObjectPosition aReference (maList[nObjectPosition]); + auto iObject = ::std::find( + mxNavigationOrder->begin(), + mxNavigationOrder->end(), + aReference); + if (iObject != mxNavigationOrder->end()) + mxNavigationOrder->erase(iObject); + mbIsNavigationOrderDirty = true; + } + + maList.erase(maList.begin()+nObjectPosition); + mbObjOrdNumsDirty=true; +} + +void SdrObjList::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrObjList")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("symbol"), "%s", BAD_CAST(typeid(*this).name())); + + for (const rtl::Reference& pObject : *this) + pObject->dumpAsXml(pWriter); + + (void)xmlTextWriterEndElement(pWriter); +} + + +void SdrPageGridFrameList::Clear() +{ + sal_uInt16 nCount=GetCount(); + for (sal_uInt16 i=0; i SdrPage::CreateObjectSpecificViewContact() +{ + return std::make_unique(*this); +} + +const sdr::contact::ViewContact& SdrPage::GetViewContact() const +{ + if (!mpViewContact) + const_cast(this)->mpViewContact = + const_cast(this)->CreateObjectSpecificViewContact(); + + return *mpViewContact; +} + +sdr::contact::ViewContact& SdrPage::GetViewContact() +{ + if (!mpViewContact) + mpViewContact = CreateObjectSpecificViewContact(); + + return *mpViewContact; +} + +void SdrPageProperties::ImpRemoveStyleSheet() +{ + if(mpStyleSheet) + { + EndListening(*mpStyleSheet); + maProperties.SetParent(nullptr); + mpStyleSheet = nullptr; + } +} + +void SdrPageProperties::ImpAddStyleSheet(SfxStyleSheet& rNewStyleSheet) +{ + if(mpStyleSheet != &rNewStyleSheet) + { + ImpRemoveStyleSheet(); + mpStyleSheet = &rNewStyleSheet; + StartListening(rNewStyleSheet); + maProperties.SetParent(&rNewStyleSheet.GetItemSet()); + } +} + +static void ImpPageChange(SdrPage& rSdrPage) +{ + rSdrPage.ActionChanged(); + rSdrPage.getSdrModelFromSdrPage().SetChanged(); + SdrHint aHint(SdrHintKind::PageOrderChange, &rSdrPage); + rSdrPage.getSdrModelFromSdrPage().Broadcast(aHint); +} + +SdrPageProperties::SdrPageProperties(SdrPage& rSdrPage) + : mpSdrPage(&rSdrPage) + , mpStyleSheet(nullptr) + , maProperties( + mpSdrPage->getSdrModelFromSdrPage().GetItemPool(), + svl::Items) +{ + if (!rSdrPage.IsMasterPage()) + { + maProperties.Put(XFillStyleItem(drawing::FillStyle_NONE)); + } +} + +SdrPageProperties::~SdrPageProperties() +{ + ImpRemoveStyleSheet(); +} + +void SdrPageProperties::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint) +{ + switch(rHint.GetId()) + { + case SfxHintId::DataChanged : + { + // notify change, broadcast + ImpPageChange(*mpSdrPage); + break; + } + case SfxHintId::Dying : + { + // Style needs to be forgotten + ImpRemoveStyleSheet(); + break; + } + default: break; + } +} + +bool SdrPageProperties::isUsedByModel() const +{ + assert(mpSdrPage); + return mpSdrPage->IsInserted(); +} + + +void SdrPageProperties::PutItemSet(const SfxItemSet& rSet) +{ + OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)"); + maProperties.Put(rSet); + ImpPageChange(*mpSdrPage); +} + +void SdrPageProperties::PutItem(const SfxPoolItem& rItem) +{ + OSL_ENSURE(!mpSdrPage->IsMasterPage(), "Item set at MasterPage Attributes (!)"); + maProperties.Put(rItem); + ImpPageChange(*mpSdrPage); +} + +void SdrPageProperties::ClearItem(const sal_uInt16 nWhich) +{ + maProperties.ClearItem(nWhich); + ImpPageChange(*mpSdrPage); +} + +void SdrPageProperties::SetStyleSheet(SfxStyleSheet* pStyleSheet) +{ + if(pStyleSheet) + { + ImpAddStyleSheet(*pStyleSheet); + } + else + { + ImpRemoveStyleSheet(); + } + + ImpPageChange(*mpSdrPage); +} + +void SdrPageProperties::setTheme(std::shared_ptr const& pTheme) +{ + if (!mpSdrPage) + return; + + // Only set the theme on a master page, else set it on the model + + if (mpSdrPage->IsMasterPage()) + { + if (mpTheme != pTheme) + mpTheme = pTheme; + } + else + { + mpSdrPage->getSdrModelFromSdrPage().setTheme(pTheme); + } +} + +std::shared_ptr const& SdrPageProperties::getTheme() const +{ + // if set - page theme has priority + if (mpTheme) + return mpTheme; + // else the model theme + else if (mpSdrPage) + return mpSdrPage->getSdrModelFromSdrPage().getTheme(); + // else return empty shared_ptr + return mpTheme; +} + +void SdrPageProperties::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPageProperties")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this); + + if (mpTheme) + { + mpTheme->dumpAsXml(pWriter); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +SdrPage::SdrPage(SdrModel& rModel, bool bMasterPage) +: mrSdrModelFromSdrPage(rModel), + mnWidth(10), + mnHeight(10), + mnBorderLeft(0), + mnBorderUpper(0), + mnBorderRight(0), + mnBorderLower(0), + mpLayerAdmin(new SdrLayerAdmin(&rModel.GetLayerAdmin())), + m_nPageNum(0), + mbMaster(bMasterPage), + mbInserted(false), + mbObjectsNotPersistent(false), + mbPageBorderOnlyLeftRight(false) +{ + mpSdrPageProperties.reset(new SdrPageProperties(*this)); +} + +SdrPage::~SdrPage() +{ + if( mxUnoPage.is() ) try + { + uno::Reference< lang::XComponent > xPageComponent( mxUnoPage, uno::UNO_QUERY_THROW ); + mxUnoPage.clear(); + xPageComponent->dispose(); + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // tell all the registered PageUsers that the page is in destruction + // This causes some (all?) PageUsers to remove themselves from the list + // of page users. Therefore we have to use a copy of the list for the + // iteration. + sdr::PageUserVector aListCopy (maPageUsers.begin(), maPageUsers.end()); + for(sdr::PageUser* pPageUser : aListCopy) + { + DBG_ASSERT(pPageUser, "SdrPage::~SdrPage: corrupt PageUser list (!)"); + pPageUser->PageInDestruction(*this); + } + + // Clear the vector. This means that user do not need to call RemovePageUser() + // when they get called from PageInDestruction(). + maPageUsers.clear(); + + mpLayerAdmin.reset(); + + TRG_ClearMasterPage(); + + mpViewContact.reset(); + mpSdrPageProperties.reset(); +} + +void SdrPage::lateInit(const SdrPage& rSrcPage) +{ + assert(!mpViewContact); + assert(!mxUnoPage.is()); + + // copy all the local parameters to make this instance + // a valid copy of source page before copying and inserting + // the contained objects + mbMaster = rSrcPage.mbMaster; + mbPageBorderOnlyLeftRight = rSrcPage.mbPageBorderOnlyLeftRight; + mnWidth = rSrcPage.mnWidth; + mnHeight = rSrcPage.mnHeight; + mnBorderLeft = rSrcPage.mnBorderLeft; + mnBorderUpper = rSrcPage.mnBorderUpper; + mnBorderRight = rSrcPage.mnBorderRight; + mnBorderLower = rSrcPage.mnBorderLower; + mbBackgroundFullSize = rSrcPage.mbBackgroundFullSize; + m_nPageNum = rSrcPage.m_nPageNum; + + if(rSrcPage.TRG_HasMasterPage()) + { + TRG_SetMasterPage(rSrcPage.TRG_GetMasterPage()); + TRG_SetMasterPageVisibleLayers(rSrcPage.TRG_GetMasterPageVisibleLayers()); + } + else + { + TRG_ClearMasterPage(); + } + + mbObjectsNotPersistent = rSrcPage.mbObjectsNotPersistent; + + { + mpSdrPageProperties.reset(new SdrPageProperties(*this)); + + if(!IsMasterPage()) + { + mpSdrPageProperties->PutItemSet(rSrcPage.getSdrPageProperties().GetItemSet()); + } + + mpSdrPageProperties->SetStyleSheet(rSrcPage.getSdrPageProperties().GetStyleSheet()); + } + + // Now copy the contained objects + if(0 != rSrcPage.GetObjCount()) + { + CopyObjects(rSrcPage); + } +} + +rtl::Reference SdrPage::CloneSdrPage(SdrModel& rTargetModel) const +{ + rtl::Reference pClonedPage(new SdrPage(rTargetModel)); + pClonedPage->lateInit(*this); + return pClonedPage; +} + +void SdrPage::SetSize(const Size& aSiz) +{ + bool bChanged(false); + + if(aSiz.Width() != mnWidth) + { + mnWidth = aSiz.Width(); + bChanged = true; + } + + if(aSiz.Height() != mnHeight) + { + mnHeight = aSiz.Height(); + bChanged = true; + } + + if(bChanged) + { + SetChanged(); + } +} + +Size SdrPage::GetSize() const +{ + return Size(mnWidth,mnHeight); +} + +tools::Long SdrPage::GetWidth() const +{ + return mnWidth; +} + +void SdrPage::SetOrientation(Orientation eOri) +{ + // square: handle like portrait format + Size aSiz(GetSize()); + if (aSiz.Width()!=aSiz.Height()) { + if ((eOri==Orientation::Portrait) == (aSiz.Width()>aSiz.Height())) { + // coverity[swapped_arguments : FALSE] - this is in the correct order + SetSize(Size(aSiz.Height(),aSiz.Width())); + } + } +} + +Orientation SdrPage::GetOrientation() const +{ + // square: handle like portrait format + Orientation eRet=Orientation::Portrait; + Size aSiz(GetSize()); + if (aSiz.Width()>aSiz.Height()) eRet=Orientation::Landscape; + return eRet; +} + +tools::Long SdrPage::GetHeight() const +{ + return mnHeight; +} + +void SdrPage::SetBorder(sal_Int32 nLft, sal_Int32 nUpp, sal_Int32 nRgt, sal_Int32 nLwr) +{ + bool bChanged(false); + + if(mnBorderLeft != nLft) + { + mnBorderLeft = nLft; + bChanged = true; + } + + if(mnBorderUpper != nUpp) + { + mnBorderUpper = nUpp; + bChanged = true; + } + + if(mnBorderRight != nRgt) + { + mnBorderRight = nRgt; + bChanged = true; + } + + if(mnBorderLower != nLwr) + { + mnBorderLower = nLwr; + bChanged = true; + } + + if(bChanged) + { + SetChanged(); + } +} + +void SdrPage::SetLeftBorder(sal_Int32 nBorder) +{ + if(mnBorderLeft != nBorder) + { + mnBorderLeft = nBorder; + SetChanged(); + } +} + +void SdrPage::SetUpperBorder(sal_Int32 nBorder) +{ + if(mnBorderUpper != nBorder) + { + mnBorderUpper = nBorder; + SetChanged(); + } +} + +void SdrPage::SetRightBorder(sal_Int32 nBorder) +{ + if(mnBorderRight != nBorder) + { + mnBorderRight=nBorder; + SetChanged(); + } +} + +void SdrPage::SetLowerBorder(sal_Int32 nBorder) +{ + if(mnBorderLower != nBorder) + { + mnBorderLower=nBorder; + SetChanged(); + } +} + +sal_Int32 SdrPage::GetLeftBorder() const +{ + return mnBorderLeft; +} + +sal_Int32 SdrPage::GetUpperBorder() const +{ + return mnBorderUpper; +} + +sal_Int32 SdrPage::GetRightBorder() const +{ + return mnBorderRight; +} + +sal_Int32 SdrPage::GetLowerBorder() const +{ + return mnBorderLower; +} + +void SdrPage::SetBackgroundFullSize(bool const bIn) +{ + if (bIn != mbBackgroundFullSize) + { + mbBackgroundFullSize = bIn; + SetChanged(); + } +} + +bool SdrPage::IsBackgroundFullSize() const +{ + return mbBackgroundFullSize; +} + +// #i68775# React on PageNum changes (from Model in most cases) +void SdrPage::SetPageNum(sal_uInt16 nNew) +{ + if(nNew != m_nPageNum) + { + // change + m_nPageNum = nNew; + + // notify visualisations, also notifies e.g. buffered MasterPages + ActionChanged(); + } +} + +sal_uInt16 SdrPage::GetPageNum() const +{ + if (!mbInserted) + return 0; + + if (mbMaster) { + if (getSdrModelFromSdrPage().IsMPgNumsDirty()) + getSdrModelFromSdrPage().RecalcPageNums(true); + } else { + if (getSdrModelFromSdrPage().IsPagNumsDirty()) + getSdrModelFromSdrPage().RecalcPageNums(false); + } + return m_nPageNum; +} + +void SdrPage::SetChanged() +{ + // For test purposes, use the new ViewContact for change + // notification now. + ActionChanged(); + getSdrModelFromSdrPage().SetChanged(); +} + +SdrPage* SdrPage::getSdrPageFromSdrObjList() const +{ + return const_cast< SdrPage* >(this); +} + +// MasterPage interface + +void SdrPage::TRG_SetMasterPage(SdrPage& rNew) +{ + if(mpMasterPageDescriptor && &(mpMasterPageDescriptor->GetUsedPage()) == &rNew) + return; + + if(mpMasterPageDescriptor) + TRG_ClearMasterPage(); + + mpMasterPageDescriptor.reset(new sdr::MasterPageDescriptor(*this, rNew)); + GetViewContact().ActionChanged(); +} + +void SdrPage::TRG_ClearMasterPage() +{ + if(mpMasterPageDescriptor) + { + SetChanged(); + + // the flushViewObjectContacts() will do needed invalidates by deleting the involved VOCs + mpMasterPageDescriptor->GetUsedPage().GetViewContact().flushViewObjectContacts(); + + mpMasterPageDescriptor.reset(); + } +} + +SdrPage& SdrPage::TRG_GetMasterPage() const +{ + DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPage(): No MasterPage available. Use TRG_HasMasterPage() before access (!)"); + return mpMasterPageDescriptor->GetUsedPage(); +} + +const SdrLayerIDSet& SdrPage::TRG_GetMasterPageVisibleLayers() const +{ + DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)"); + return mpMasterPageDescriptor->GetVisibleLayers(); +} + +void SdrPage::TRG_SetMasterPageVisibleLayers(const SdrLayerIDSet& rNew) +{ + DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_SetMasterPageVisibleLayers(): No MasterPage available. Use TRG_HasMasterPage() before access (!)"); + mpMasterPageDescriptor->SetVisibleLayers(rNew); +} + +sdr::contact::ViewContact& SdrPage::TRG_GetMasterPageDescriptorViewContact() const +{ + DBG_ASSERT(mpMasterPageDescriptor != nullptr, "TRG_GetMasterPageDescriptorViewContact(): No MasterPage available. Use TRG_HasMasterPage() before access (!)"); + return mpMasterPageDescriptor->GetViewContact(); +} + +// used from SdrModel::RemoveMasterPage +void SdrPage::TRG_ImpMasterPageRemoved(const SdrPage& rRemovedPage) +{ + if(TRG_HasMasterPage()) + { + if(&TRG_GetMasterPage() == &rRemovedPage) + { + TRG_ClearMasterPage(); + } + } +} + +void SdrPage::MakePageObjectsNamesUnique() +{ + std::unordered_set aNameSet; + for (const rtl::Reference& pObj : *this) + { + if (!pObj->GetName().isEmpty()) + { + pObj->MakeNameUnique(aNameSet); + SdrObjList* pSdrObjList = pObj->GetSubList(); // group + if (pSdrObjList) + { + SdrObject* pListObj; + SdrObjListIter aIter(pSdrObjList, SdrIterMode::DeepWithGroups); + while (aIter.IsMore()) + { + pListObj = aIter.Next(); + pListObj->MakeNameUnique(aNameSet); + } + } + } + } +} + +const SdrPageGridFrameList* SdrPage::GetGridFrameList(const SdrPageView* /*pPV*/, const tools::Rectangle* /*pRect*/) const +{ + return nullptr; +} + +const SdrLayerAdmin& SdrPage::GetLayerAdmin() const +{ + return *mpLayerAdmin; +} + +SdrLayerAdmin& SdrPage::GetLayerAdmin() +{ + return *mpLayerAdmin; +} + +OUString SdrPage::GetLayoutName() const +{ + return OUString(); +} + +void SdrPage::SetInserted( bool bIns ) +{ + if( mbInserted == bIns ) + return; + + mbInserted = bIns; + + // #i120437# go over whole hierarchy, not only over object level null (seen from grouping) + SdrObjListIter aIter(this, SdrIterMode::DeepNoGroups); + + while ( aIter.IsMore() ) + { + SdrObject* pObj = aIter.Next(); + if ( auto pOleObj = dynamic_cast(pObj) ) + { + if( mbInserted ) + pOleObj->Connect(); + else + pOleObj->Disconnect(); + } + } +} + +void SdrPage::SetUnoPage(uno::Reference const& xNewPage) +{ + mxUnoPage = xNewPage; +} + +uno::Reference< uno::XInterface > const & SdrPage::getUnoPage() +{ + if( !mxUnoPage.is() ) + { + // create one + mxUnoPage = createUnoPage(); + } + + return mxUnoPage; +} + +uno::Reference< uno::XInterface > SdrPage::createUnoPage() +{ + return cppu::getXWeak(new SvxDrawPage(this)); +} + +SfxStyleSheet* SdrPage::GetTextStyleSheetForObject( SdrObject* pObj ) const +{ + return pObj->GetStyleSheet(); +} + +/** returns an averaged background color of this page */ +// #i75566# GetBackgroundColor -> GetPageBackgroundColor and bScreenDisplay hint value +Color SdrPage::GetPageBackgroundColor( SdrPageView const * pView, bool bScreenDisplay ) const +{ + Color aColor; + + if(bScreenDisplay && (!pView || pView->GetApplicationDocumentColor() == COL_AUTO)) + { + svtools::ColorConfig aColorConfig; + aColor = aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor; + } + else + { + aColor = pView->GetApplicationDocumentColor(); + } + + const SfxItemSet* pBackgroundFill = &getSdrPageProperties().GetItemSet(); + + if(!IsMasterPage() && TRG_HasMasterPage()) + { + if(drawing::FillStyle_NONE == pBackgroundFill->Get(XATTR_FILLSTYLE).GetValue()) + { + pBackgroundFill = &TRG_GetMasterPage().getSdrPageProperties().GetItemSet(); + } + } + + if (auto oColor = GetDraftFillColor(*pBackgroundFill)) + aColor = *oColor; + + return aColor; +} + +/** *deprecated, use GetBackgroundColor with SdrPageView */ +Color SdrPage::GetPageBackgroundColor() const +// #i75566# GetBackgroundColor -> GetPageBackgroundColor +{ + return GetPageBackgroundColor( nullptr ); +} + +/** this method returns true if the object from the ViewObjectContact should + be visible on this page while rendering. + bEdit selects if visibility test is for an editing view or a final render, + like printing. +*/ +bool SdrPage::checkVisibility( + const sdr::contact::ViewObjectContact& /*rOriginal*/, + const sdr::contact::DisplayInfo& /*rDisplayInfo*/, + bool /*bEdit*/) +{ + // this will be handled in the application if needed + return true; +} + +void SdrPage::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrPage")); + SdrObjList::dumpAsXml(pWriter); + + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("width")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%s", + BAD_CAST(OString::number(mnWidth).getStr())); + (void)xmlTextWriterEndElement(pWriter); + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("height")); + (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%s", + BAD_CAST(OString::number(mnHeight).getStr())); + (void)xmlTextWriterEndElement(pWriter); + + if (mpSdrPageProperties) + { + mpSdrPageProperties->dumpAsXml(pWriter); + } + + (void)xmlTextWriterEndElement(pWriter); +} + +// DrawContact support: Methods for handling Page changes +void SdrPage::ActionChanged() +{ + // Do necessary ViewContact actions + GetViewContact().ActionChanged(); + + // #i48535# also handle MasterPage change + if(TRG_HasMasterPage()) + { + TRG_GetMasterPageDescriptorViewContact().ActionChanged(); + } +} + +SdrPageProperties& SdrPage::getSdrPageProperties() +{ + return *mpSdrPageProperties; +} + +const SdrPageProperties& SdrPage::getSdrPageProperties() const +{ + return *mpSdrPageProperties; +} + +const SdrPageProperties* SdrPage::getCorrectSdrPageProperties() const +{ + if(mpMasterPageDescriptor) + { + return mpMasterPageDescriptor->getCorrectSdrPageProperties(); + } + else + { + return &getSdrPageProperties(); + } +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdpagv.cxx b/svx/source/svdraw/svdpagv.cxx new file mode 100644 index 0000000000..86210865e7 --- /dev/null +++ b/svx/source/svdraw/svdpagv.cxx @@ -0,0 +1,895 @@ +/* -*- 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 +#include +#include + +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +// interface to SdrPageWindow + +SdrPageWindow* SdrPageView::FindPageWindow(const SdrPaintWindow& rPaintWindow) const +{ + for(auto & a : maPageWindows) + { + if(&(a->GetPaintWindow()) == &rPaintWindow) + { + return a.get(); + } + } + + return nullptr; +} + +const SdrPageWindow* SdrPageView::FindPatchedPageWindow( const OutputDevice& _rOutDev ) const +{ + for ( auto const & pPageWindow : maPageWindows ) + { + const SdrPaintWindow& rPaintWindow( pPageWindow->GetOriginalPaintWindow() ? *pPageWindow->GetOriginalPaintWindow() : pPageWindow->GetPaintWindow() ); + if ( &rPaintWindow.GetOutputDevice() == &_rOutDev ) + { + return pPageWindow.get(); + } + } + + return nullptr; +} + +SdrPageWindow* SdrPageView::FindPageWindow(const OutputDevice& rOutDev) const +{ + for ( auto const & pPageWindow : maPageWindows ) + { + if(&(pPageWindow->GetPaintWindow().GetOutputDevice()) == &rOutDev) + { + return pPageWindow.get(); + } + } + + return nullptr; +} + +SdrPageWindow* SdrPageView::GetPageWindow(sal_uInt32 nIndex) const +{ + return maPageWindows[nIndex].get(); +} + +SdrPageView::SdrPageView(SdrPage* pPage1, SdrView& rNewView) +: mrView(rNewView), + // col_auto color lets the view takes the default SvxColorConfig entry + maDocumentColor( COL_AUTO ), + maBackgroundColor( COL_AUTO ), // #i48367# also react on autocolor + mpPreparedPageWindow(nullptr) // #i72752# +{ + mpPage = pPage1; + + if(mpPage) + { + maPageOrigin.setX(mpPage->GetLeftBorder() ); + maPageOrigin.setY(mpPage->GetUpperBorder() ); + } + // For example, in the case of charts, there is a LayerAdmin, but it has no valid values. Therefore + // a solution like pLayerAdmin->getVisibleLayersODF(aLayerVisi) is not possible. So use the + // generic SetAll() for now. + aLayerVisi.SetAll(); + aLayerPrn.SetAll(); + + mbHasMarked = false; + mbVisible = false; + pCurrentList = nullptr; + pCurrentGroup = nullptr; + SetCurrentGroupAndList(nullptr, mpPage); + + for(sal_uInt32 a(0); a < rNewView.PaintWindowCount(); a++) + { + AddPaintWindowToPageView(*rNewView.GetPaintWindow(a)); + } +} + +SdrPageView::~SdrPageView() +{ +} + +void SdrPageView::AddPaintWindowToPageView(SdrPaintWindow& rPaintWindow) +{ + if(!FindPageWindow(rPaintWindow)) + { + maPageWindows.emplace_back(new SdrPageWindow(*this, rPaintWindow)); + } +} + +void SdrPageView::RemovePaintWindowFromPageView(SdrPaintWindow& rPaintWindow) +{ + auto it = std::find_if(maPageWindows.begin(), maPageWindows.end(), + [&rPaintWindow](const std::unique_ptr& rpWindow) { + return &(rpWindow->GetPaintWindow()) == &rPaintWindow; + }); + if (it != maPageWindows.end()) + maPageWindows.erase(it); +} + +css::uno::Reference< css::awt::XControlContainer > SdrPageView::GetControlContainer( const OutputDevice& _rDevice ) const +{ + css::uno::Reference< css::awt::XControlContainer > xReturn; + const SdrPageWindow* pCandidate = FindPatchedPageWindow( _rDevice ); + + if ( pCandidate ) + xReturn = pCandidate->GetControlContainer(); + + return xReturn; +} + +void SdrPageView::ModelHasChanged() +{ + if (GetCurrentGroup()!=nullptr) CheckCurrentGroup(); +} + +bool SdrPageView::IsReadOnly() const +{ + return (nullptr == GetPage() || GetView().GetModel().IsReadOnly() || GetPage()->IsReadOnly() || GetObjList()->IsReadOnly()); +} + +void SdrPageView::Show() +{ + if(!IsVisible()) + { + mbVisible = true; + + for(sal_uInt32 a(0); a < GetView().PaintWindowCount(); a++) + { + AddPaintWindowToPageView(*GetView().GetPaintWindow(a)); + } + } +} + +void SdrPageView::Hide() +{ + if(IsVisible()) + { + if (!comphelper::LibreOfficeKit::isActive()) + { + InvalidateAllWin(); + } + mbVisible = false; + maPageWindows.clear(); + } +} + +tools::Rectangle SdrPageView::GetPageRect() const +{ + if (GetPage()==nullptr) return tools::Rectangle(); + return tools::Rectangle(Point(),Size(GetPage()->GetWidth()+1,GetPage()->GetHeight()+1)); +} + +void SdrPageView::InvalidateAllWin() +{ + if(IsVisible() && GetPage()) + { + tools::Rectangle aRect(Point(0,0),Size(GetPage()->GetWidth()+1,GetPage()->GetHeight()+1)); + aRect.Union(GetPage()->GetAllObjBoundRect()); + GetView().InvalidateAllWin(aRect); + } +} + + +void SdrPageView::PrePaint() +{ + const sal_uInt32 nCount(PageWindowCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + SdrPageWindow* pCandidate = GetPageWindow(a); + + if(pCandidate) + { + pCandidate->PrePaint(); + } + } +} + +void SdrPageView::CompleteRedraw( + SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector ) +{ + if(!GetPage()) + return; + + SdrPageWindow* pPageWindow = FindPageWindow(rPaintWindow); + std::unique_ptr pTempPageWindow; + + if(!pPageWindow) + { + // create temp PageWindow + pTempPageWindow.reset(new SdrPageWindow(*this, rPaintWindow)); + pPageWindow = pTempPageWindow.get(); + } + + // do the redraw + pPageWindow->PrepareRedraw(rReg); + pPageWindow->RedrawAll(pRedirector); +} + + +// #i74769# use SdrPaintWindow directly + +void SdrPageView::setPreparedPageWindow(SdrPageWindow* pKnownTarget) +{ + // #i72752# remember prepared SdrPageWindow + mpPreparedPageWindow = pKnownTarget; +} + +void SdrPageView::DrawLayer(SdrLayerID nID, OutputDevice* pGivenTarget, + sdr::contact::ViewObjectContactRedirector* pRedirector, + const tools::Rectangle& rRect, basegfx::B2IRectangle const*const pPageFrame) +{ + if(!GetPage()) + return; + + if(pGivenTarget) + { + SdrPageWindow* pKnownTarget = FindPageWindow(*pGivenTarget); + + if(pKnownTarget) + { + // paint known target + pKnownTarget->RedrawLayer(&nID, pRedirector, pPageFrame); + } + else + { + // #i72752# DrawLayer() uses an OutputDevice different from BeginDrawLayer. This happens + // e.g. when SW paints a single text line in text edit mode. Try to use it + SdrPageWindow* pPreparedTarget = mpPreparedPageWindow; + + if(pPreparedTarget) + { + // if we have a prepared target, do not use a new SdrPageWindow since this + // works but is expensive. Just use a temporary PaintWindow + SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget); + + // Copy existing paint region to use the same as prepared in BeginDrawLayer + SdrPaintWindow& rExistingPaintWindow = pPreparedTarget->GetPaintWindow(); + const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion(); + bool bUseRect(false); + if (!rRect.IsEmpty()) + { + vcl::Region r(rExistingRegion); + r.Intersect(rRect); + // fdo#74435: FIXME: visibility check broken if empty + if (!r.IsEmpty()) + bUseRect = true; + } + if (!bUseRect) + aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion); + else + aTemporaryPaintWindow.SetRedrawRegion(vcl::Region(rRect)); + + // patch the ExistingPageWindow + auto pPreviousWindow = pPreparedTarget->patchPaintWindow(aTemporaryPaintWindow); + // unpatch window when leaving the scope + const ::comphelper::ScopeGuard aGuard( + [&pPreviousWindow, &pPreparedTarget]() { pPreparedTarget->unpatchPaintWindow(pPreviousWindow); } ); + // redraw the layer + pPreparedTarget->RedrawLayer(&nID, pRedirector, pPageFrame); + } + else + { + OSL_FAIL("SdrPageView::DrawLayer: Creating temporary SdrPageWindow (ObjectContact), this should never be needed (!)"); + + // None of the known OutputDevices is the target of this paint, use + // a temporary SdrPageWindow for this Redraw. + SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget); + SdrPageWindow aTemporaryPageWindow(*this, aTemporaryPaintWindow); + + // #i72752# + // Copy existing paint region if other PageWindows exist, this was created by + // PrepareRedraw() from BeginDrawLayer(). Needs to be used e.g. when suddenly SW + // paints into an unknown device other than the view was created for (e.g. VirtualDevice) + if(PageWindowCount()) + { + SdrPageWindow* pExistingPageWindow = GetPageWindow(0); + SdrPaintWindow& rExistingPaintWindow = pExistingPageWindow->GetPaintWindow(); + const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion(); + aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion); + } + + aTemporaryPageWindow.RedrawLayer(&nID, pRedirector, nullptr); + } + } + } + else + { + // paint in all known windows + for(sal_uInt32 a(0); a < PageWindowCount(); a++) + { + SdrPageWindow* pTarget = GetPageWindow(a); + pTarget->RedrawLayer(&nID, pRedirector, nullptr); + } + } +} + +void SdrPageView::SetDesignMode( bool _bDesignMode ) const +{ + for ( sal_uInt32 i = 0; i < PageWindowCount(); ++i ) + { + const SdrPageWindow& rPageViewWindow = *GetPageWindow(i); + rPageViewWindow.SetDesignMode( _bDesignMode ); + } +} + + +void SdrPageView::DrawPageViewGrid(OutputDevice& rOut, const tools::Rectangle& rRect, Color aColor) +{ + if (GetPage()==nullptr) + return; + + tools::Long nx1=GetView().maGridBig.Width(); + tools::Long nx2=GetView().maGridFin.Width(); + tools::Long ny1=GetView().maGridBig.Height(); + tools::Long ny2=GetView().maGridFin.Height(); + + if (nx1==0) nx1=nx2; + if (nx2==0) nx2=nx1; + if (ny1==0) ny1=ny2; + if (ny2==0) ny2=ny1; + if (nx1==0) { nx1=ny1; nx2=ny2; } + if (ny1==0) { ny1=nx1; ny2=nx2; } + if (nx1<0) nx1=-nx1; + if (nx2<0) nx2=-nx2; + if (ny1<0) ny1=-ny1; + if (ny2<0) ny2=-ny2; + + if (nx1==0) + return; + + // no more global output size, use window size instead to decide grid sizes + tools::Long nScreenWdt = rOut.GetOutputSizePixel().Width(); + + tools::Long nMinDotPix=2; + tools::Long nMinLinPix=4; + + if (nScreenWdt>=1600) + { + nMinDotPix=4; + nMinLinPix=8; + } + else if (nScreenWdt>=1024) + { + nMinDotPix=3; + nMinLinPix=6; + } + else + { // e. g. 640x480 + nMinDotPix=2; + nMinLinPix=4; + } + Size aMinDotDist(rOut.PixelToLogic(Size(nMinDotPix,nMinDotPix))); + Size aMinLinDist(rOut.PixelToLogic(Size(nMinLinPix,nMinLinPix))); + bool bHoriSolid=nx2 nx1*=2.5 + if (nTgl==2) nx1*=2; + + nVal0=a; + nTgl++; if (nTgl>=3) nTgl=0; + } + nTgl=0; + nVal0=ny1; + while (ny1 ny1*=2.5 + if (nTgl==2) ny1*=2; + + nVal0=a; + nTgl++; + + if (nTgl>=3) nTgl=0; + } + + bool bHoriFine=nx2GetWidth() < 0) // ScDrawPage of RTL sheet + { + x1 = GetPage()->GetWidth() + GetPage()->GetLeftBorder() + 1; + x2 = - GetPage()->GetRightBorder() - 1; + } + else + { + x1 = GetPage()->GetLeftBorder() + 1; + x2 = GetPage()->GetWidth() - GetPage()->GetRightBorder() - 1; + } + tools::Long y1 = GetPage()->GetUpperBorder() + 1; + tools::Long y2 = GetPage()->GetHeight() - GetPage()->GetLowerBorder() - 1; + const SdrPageGridFrameList* pFrames=GetPage()->GetGridFrameList(this,nullptr); + + sal_uInt16 nGridPaintCnt=1; + if (pFrames!=nullptr) nGridPaintCnt=pFrames->GetCount(); + for (sal_uInt16 nGridPaintNum=0; nGridPaintNumrRect.Right() +nX1Pix) x2=rRect.Right() +nX1Pix; + if (y1rRect.Bottom()+nY1Pix) y2=rRect.Bottom()+nY1Pix; + } + + tools::Long xBigOrg=aOrg.X()+nWrX; + while (xBigOrg>=x1) xBigOrg-=nx1; + while (xBigOrg=x1) xFinOrg-=nx2; + while (xFinOrg=y1) yBigOrg-=ny1; + while (yBigOrg=y1) yFinOrg-=ny2; + while (yFinOrg= 1000) + { + nStepOffset -= 1000; + nPointOffset++; + } + } + } + + if( bVertLines ) + { + DrawGridFlags nGridFlags = ( bVertSolid ? DrawGridFlags::VertLines : DrawGridFlags::Dots ); + sal_uInt16 nSteps = sal_uInt16(ny1 / ny2); + sal_uInt32 nRestPerStepMul1000 = nSteps ? ( ((ny1 * 1000L)/ nSteps) - (ny2 * 1000L) ) : 0; + sal_uInt32 nStepOffset = 0; + sal_uInt16 nPointOffset = 0; + + for(sal_uInt16 a=0;a= 1000) + { + nStepOffset -= 1000; + nPointOffset++; + } + } + } + } + } + + rOut.EnableMapMode(bMap0); + rOut.SetLineColor(aOriginalLineColor); +} + +void SdrPageView::AdjHdl() +{ + GetView().AdjustMarkHdl(); +} + +void SdrPageView::SetLayer(const OUString& rName, SdrLayerIDSet& rBS, bool bJa) +{ + if(!GetPage()) + return; + + SdrLayerID nID = GetPage()->GetLayerAdmin().GetLayerID(rName); + + if(SDRLAYER_NOTFOUND != nID) + rBS.Set(nID, bJa); +} + +bool SdrPageView::IsLayer(const OUString& rName, const SdrLayerIDSet& rBS) const +{ + if(!GetPage()) + return false; + + bool bRet(false); + + if (!rName.isEmpty()) + { + SdrLayerID nId = GetPage()->GetLayerAdmin().GetLayerID(rName); + + if(SDRLAYER_NOTFOUND != nId) + { + bRet = rBS.IsSet(nId); + } + } + + return bRet; +} + +bool SdrPageView::IsObjMarkable(SdrObject const * pObj) const +{ + if (!pObj) + return false; + if (pObj->IsMarkProtect()) + return false; // excluded from selection? + if (!pObj->IsVisible()) + return false; // only visible are selectable + if (!pObj->IsInserted()) + return false; // Obj deleted? + if (auto pObjGroup = dynamic_cast(pObj)) + { + // If object is a Group object, visibility may depend on + // multiple layers. If one object is markable, Group is markable. + SdrObjList* pObjList = pObjGroup->GetSubList(); + + if (pObjList && pObjList->GetObjCount()) + { + for (const rtl::Reference& pCandidate : *pObjList) + { + // call recursively + if (IsObjMarkable(pCandidate.get())) + return true; + } + return false; + } + else + { + // #i43302# + // Allow empty groups to be selected to be able to delete them + return true; + } + } + if (!pObj->Is3DObj() && pObj->getSdrPageFromSdrObject() != GetPage()) + { + // Obj suddenly in different Page + return false; + } + + // the layer has to be visible and must not be locked + SdrLayerID nL = pObj->GetLayer(); + if (!aLayerVisi.IsSet(nL)) + return false; + if (aLayerLock.IsSet(nL)) + return false; + return true; +} + +void SdrPageView::SetPageOrigin(const Point& rOrg) +{ + if (rOrg != maPageOrigin) + { + maPageOrigin = rOrg; + if (GetView().IsGridVisible()) + { + InvalidateAllWin(); + } + } +} + +void SdrPageView::ImpInvalidateHelpLineArea(sal_uInt16 nNum) const +{ + if (!(GetView().IsHlplVisible() && nNumOutputToWindow()) + { + OutputDevice& rOutDev = pCandidate->GetOutputDevice(); + tools::Rectangle aR(rHL.GetBoundRect(rOutDev)); + Size aSiz(rOutDev.PixelToLogic(Size(1,1))); + aR.AdjustLeft( -(aSiz.Width()) ); + aR.AdjustRight(aSiz.Width() ); + aR.AdjustTop( -(aSiz.Height()) ); + aR.AdjustBottom(aSiz.Height() ); + const_cast(GetView()).InvalidateOneWin(rOutDev, aR); + } + } +} + +void SdrPageView::SetHelpLines(const SdrHelpLineList& rHLL) +{ + aHelpLines=rHLL; + InvalidateAllWin(); +} + +void SdrPageView::SetHelpLine(sal_uInt16 nNum, const SdrHelpLine& rNewHelpLine) +{ + if (nNum >= aHelpLines.GetCount() || aHelpLines[nNum] == rNewHelpLine) + return; + + bool bNeedRedraw = true; + if (aHelpLines[nNum].GetKind()==rNewHelpLine.GetKind()) { + switch (rNewHelpLine.GetKind()) { + case SdrHelpLineKind::Vertical : if (aHelpLines[nNum].GetPos().X()==rNewHelpLine.GetPos().X()) bNeedRedraw = false; break; + case SdrHelpLineKind::Horizontal: if (aHelpLines[nNum].GetPos().Y()==rNewHelpLine.GetPos().Y()) bNeedRedraw = false; break; + default: break; + } // switch + } + if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum); + aHelpLines[nNum]=rNewHelpLine; + if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum); +} + +void SdrPageView::DeleteHelpLine(sal_uInt16 nNum) +{ + if (nNumIsGroupObject()) + return false; + + // Don't allow enter Diagrams + if(nullptr != pObj && pObj->isDiagram()) + return false; + + const bool bGlueInvalidate(GetView().ImpIsGlueVisible()); + + if (bGlueInvalidate) + { + GetView().GlueInvalidate(); + } + + // deselect all + GetView().UnmarkAll(); + + // set current group and list + SdrObjList* pNewObjList = pObj->GetSubList(); + SetCurrentGroupAndList(pObj, pNewObjList); + + // select contained object if only one object is contained, + // else select nothing and let the user decide what to do next + if(pNewObjList && pNewObjList->GetObjCount() == 1) + { + SdrObject* pFirstObject = pNewObjList->GetObj(0); + + if(GetView().GetSdrPageView()) + { + GetView().MarkObj(pFirstObject, GetView().GetSdrPageView()); + } + } + + // build new handles + GetView().AdjustMarkHdl(); + + // invalidate only when view wants to visualize group entering + InvalidateAllWin(); + + if (bGlueInvalidate) + { + GetView().GlueInvalidate(); + } + + return true; +} + +void SdrPageView::LeaveOneGroup() +{ + SdrObject* pLastGroup = GetCurrentGroup(); + if (!pLastGroup) + return; + + bool bGlueInvalidate = GetView().ImpIsGlueVisible(); + + if(bGlueInvalidate) + GetView().GlueInvalidate(); + + SdrObject* pParentGroup = pLastGroup->getParentSdrObjectFromSdrObject(); + SdrObjList* pParentList = GetPage(); + + if(pParentGroup) + pParentList = pParentGroup->GetSubList(); + + // deselect everything + GetView().UnmarkAll(); + + // allocations, pCurrentGroup and pCurrentList need to be set + SetCurrentGroupAndList(pParentGroup, pParentList); + + // select the group we just left + if (GetView().GetSdrPageView()) + GetView().MarkObj(pLastGroup, GetView().GetSdrPageView()); + + GetView().AdjustMarkHdl(); + + // invalidate only if view wants to visualize group entering + InvalidateAllWin(); + + if(bGlueInvalidate) + GetView().GlueInvalidate(); +} + +void SdrPageView::LeaveAllGroup() +{ + SdrObject* pLastGroup = GetCurrentGroup(); + if (!pLastGroup) + return; + + bool bGlueInvalidate = GetView().ImpIsGlueVisible(); + + if(bGlueInvalidate) + GetView().GlueInvalidate(); + + // deselect everything + GetView().UnmarkAll(); + + // allocations, pCurrentGroup and pCurrentList always need to be set + SetCurrentGroupAndList(nullptr, GetPage()); + + // find and select uppermost group + while (pLastGroup->getParentSdrObjectFromSdrObject()) + pLastGroup = pLastGroup->getParentSdrObjectFromSdrObject(); + + if (GetView().GetSdrPageView()) + GetView().MarkObj(pLastGroup, GetView().GetSdrPageView()); + + GetView().AdjustMarkHdl(); + + // invalidate only when view wants to visualize group entering + InvalidateAllWin(); + + if(bGlueInvalidate) + GetView().GlueInvalidate(); +} + +sal_uInt16 SdrPageView::GetEnteredLevel() const +{ + sal_uInt16 nCount=0; + SdrObject* pGrp=GetCurrentGroup(); + while (pGrp!=nullptr) { + nCount++; + pGrp=pGrp->getParentSdrObjectFromSdrObject(); + } + return nCount; +} + +void SdrPageView::CheckCurrentGroup() +{ + SdrObject* pGrp(GetCurrentGroup()); + + while(nullptr != pGrp && + (!pGrp->IsInserted() || nullptr == pGrp->getParentSdrObjListFromSdrObject() || nullptr == pGrp->getSdrPageFromSdrObject())) + { + // anything outside of the borders? + pGrp = pGrp->getParentSdrObjectFromSdrObject(); + } + + if(pGrp != GetCurrentGroup()) + { + if(nullptr != pGrp) + { + EnterGroup(pGrp); + } + else + { + LeaveAllGroup(); + } + } +} + +// Set background color for svx at SdrPageViews +void SdrPageView::SetApplicationBackgroundColor(Color aBackgroundColor) +{ + maBackgroundColor = aBackgroundColor; +} + + +// Set document color for svx at SdrPageViews +void SdrPageView::SetApplicationDocumentColor(Color aDocumentColor) +{ + maDocumentColor = aDocumentColor; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdpdf.cxx b/svx/source/svdraw/svdpdf.cxx new file mode 100644 index 0000000000..7509991ba3 --- /dev/null +++ b/svx/source/svdraw/svdpdf.cxx @@ -0,0 +1,1046 @@ +/* -*- 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 + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +ImpSdrPdfImport::ImpSdrPdfImport(SdrModel& rModel, SdrLayerID nLay, const tools::Rectangle& rRect, + Graphic const& rGraphic) + : mpVD(VclPtr::Create()) + , maScaleRect(rRect) + , mnMapScalingOfs(0) + , mpModel(&rModel) + , mnLayer(nLay) + , mnLineWidth(0) + , maDash(css::drawing::DashStyle_RECT, 0, 0, 0, 0, 0) + , mbMov(false) + , mbSize(false) + , maOfs(0, 0) + , mfScaleX(1.0) + , mfScaleY(1.0) + , maScaleX(1.0) + , maScaleY(1.0) + , mbFntDirty(true) + , mbLastObjWasPolyWithoutLine(false) + , mbNoLine(false) + , mbNoFill(false) + , mnPageCount(0) + , mdPageHeightPts(0) + , mpPDFium(vcl::pdf::PDFiumLibrary::get()) +{ + mpVD->EnableOutput(false); + mpVD->SetLineColor(); + mpVD->SetFillColor(); + maOldLineColor.SetRed(mpVD->GetLineColor().GetRed() + 1); + mpLineAttr = std::make_unique>( + rModel.GetItemPool()); + mpFillAttr = std::make_unique>( + rModel.GetItemPool()); + mpTextAttr + = std::make_unique>(rModel.GetItemPool()); + + checkClip(); + + // Load the buffer using pdfium. + auto const& rVectorGraphicData = rGraphic.getVectorGraphicData(); + auto* pData = rVectorGraphicData->getBinaryDataContainer().getData(); + sal_Int32 nSize = rVectorGraphicData->getBinaryDataContainer().getSize(); + mpPdfDocument = mpPDFium ? mpPDFium->openDocument(pData, nSize, OString()) : nullptr; + if (!mpPdfDocument) + return; + + mnPageCount = mpPdfDocument->getPageCount(); +} + +ImpSdrPdfImport::~ImpSdrPdfImport() = default; + +void ImpSdrPdfImport::DoObjects(SvdProgressInfo* pProgrInfo, sal_uInt32* pActionsToReport, + int nPageIndex) +{ + const int nPageCount = mpPdfDocument->getPageCount(); + if (!(nPageCount > 0 && nPageIndex >= 0 && nPageIndex < nPageCount)) + return; + + // Render next page. + auto pPdfPage = mpPdfDocument->openPage(nPageIndex); + if (!pPdfPage) + return; + + basegfx::B2DSize dPageSize = mpPdfDocument->getPageSize(nPageIndex); + + SetupPageScale(dPageSize.getWidth(), dPageSize.getHeight()); + + // Load the page text to extract it when we get text elements. + auto pTextPage = pPdfPage->getTextPage(); + + const int nPageObjectCount = pPdfPage->getObjectCount(); + if (pProgrInfo) + pProgrInfo->SetActionCount(nPageObjectCount); + + for (int nPageObjectIndex = 0; nPageObjectIndex < nPageObjectCount; ++nPageObjectIndex) + { + auto pPageObject = pPdfPage->getObject(nPageObjectIndex); + ImportPdfObject(pPageObject, pTextPage, nPageObjectIndex); + if (pProgrInfo && pActionsToReport) + { + (*pActionsToReport)++; + + if (*pActionsToReport >= 16) + { + if (!pProgrInfo->ReportActions(*pActionsToReport)) + break; + + *pActionsToReport = 0; + } + } + } +} + +void ImpSdrPdfImport::SetupPageScale(const double dPageWidth, const double dPageHeight) +{ + mfScaleX = mfScaleY = 1.0; + + // Store the page dimensions in Points. + mdPageHeightPts = dPageHeight; + + Size aPageSize(convertPointToMm100(dPageWidth), convertPointToMm100(dPageHeight)); + + if (aPageSize.Width() && aPageSize.Height() && (!maScaleRect.IsEmpty())) + { + maOfs = maScaleRect.TopLeft(); + + if (aPageSize.Width() != (maScaleRect.GetWidth() - 1)) + { + mfScaleX = static_cast(maScaleRect.GetWidth() - 1) + / static_cast(aPageSize.Width()); + } + + if (aPageSize.Height() != (maScaleRect.GetHeight() - 1)) + { + mfScaleY = static_cast(maScaleRect.GetHeight() - 1) + / static_cast(aPageSize.Height()); + } + } + + mbMov = maOfs.X() != 0 || maOfs.Y() != 0; + mbSize = false; + maScaleX = Fraction(1, 1); + maScaleY = Fraction(1, 1); + + if (aPageSize.Width() != (maScaleRect.GetWidth() - 1)) + { + maScaleX = Fraction(maScaleRect.GetWidth() - 1, aPageSize.Width()); + mbSize = true; + } + + if (aPageSize.Height() != (maScaleRect.GetHeight() - 1)) + { + maScaleY = Fraction(maScaleRect.GetHeight() - 1, aPageSize.Height()); + mbSize = true; + } +} + +size_t ImpSdrPdfImport::DoImport(SdrObjList& rOL, size_t nInsPos, int nPageNumber, + SvdProgressInfo* pProgrInfo) +{ + sal_uInt32 nActionsToReport(0); + + // execute + DoObjects(pProgrInfo, &nActionsToReport, nPageNumber); + + if (pProgrInfo) + { + pProgrInfo->ReportActions(nActionsToReport); + nActionsToReport = 0; + } + + // MapMode scaling + MapScaling(); + + // To calculate the progress meter, we use GetActionSize()*3. + // However, maTmpList has a lower entry count limit than GetActionSize(), + // so the actions that were assumed were too much have to be re-added. + // nActionsToReport = (rMtf.GetActionSize() - maTmpList.size()) * 2; + + // announce all currently unannounced rescales + if (pProgrInfo) + { + pProgrInfo->ReportRescales(nActionsToReport); + pProgrInfo->SetInsertCount(maTmpList.size()); + } + + nActionsToReport = 0; + + // insert all objects cached in aTmpList now into rOL from nInsPos + nInsPos = std::min(nInsPos, rOL.GetObjCount()); + + for (rtl::Reference& pObj : maTmpList) + { + rOL.NbcInsertObject(pObj.get(), nInsPos); + nInsPos++; + + if (pProgrInfo) + { + nActionsToReport++; + + if (nActionsToReport >= 32) // update all 32 actions + { + pProgrInfo->ReportInserts(nActionsToReport); + nActionsToReport = 0; + } + } + } + + // report all remaining inserts for the last time + if (pProgrInfo) + { + pProgrInfo->ReportInserts(nActionsToReport); + } + + return maTmpList.size(); +} + +void ImpSdrPdfImport::SetAttributes(SdrObject* pObj, bool bForceTextAttr) +{ + mbNoLine = false; + mbNoFill = false; + bool bLine(!bForceTextAttr); + bool bFill(!pObj || (pObj->IsClosedObj() && !bForceTextAttr)); + bool bText(bForceTextAttr || (pObj && pObj->GetOutlinerParaObject())); + + if (bLine) + { + if (mnLineWidth) + { + mpLineAttr->Put(XLineWidthItem(mnLineWidth)); + } + else + { + mpLineAttr->Put(XLineWidthItem(0)); + } + + maOldLineColor = mpVD->GetLineColor(); + + if (mpVD->IsLineColor()) + { + mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_SOLID)); //TODO support dashed lines. + mpLineAttr->Put(XLineColorItem(OUString(), mpVD->GetLineColor())); + } + else + { + mpLineAttr->Put(XLineStyleItem(drawing::LineStyle_NONE)); + } + + mpLineAttr->Put(XLineJointItem(css::drawing::LineJoint_NONE)); + + // Add LineCap support + mpLineAttr->Put(XLineCapItem(gaLineCap)); + + if (((maDash.GetDots() && maDash.GetDotLen()) + || (maDash.GetDashes() && maDash.GetDashLen())) + && maDash.GetDistance()) + { + mpLineAttr->Put(XLineDashItem(OUString(), maDash)); + } + else + { + mpLineAttr->Put(XLineDashItem(OUString(), XDash(css::drawing::DashStyle_RECT))); + } + } + else + { + mbNoLine = true; + } + + if (bFill) + { + if (mpVD->IsFillColor()) + { + mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_SOLID)); + mpFillAttr->Put(XFillColorItem(OUString(), mpVD->GetFillColor())); + } + else + { + mpFillAttr->Put(XFillStyleItem(drawing::FillStyle_NONE)); + } + } + else + { + mbNoFill = true; + } + + if (bText && mbFntDirty) + { + vcl::Font aFnt(mpVD->GetFont()); + const sal_uInt32 nHeight(FRound(aFnt.GetFontSize().Height() * mfScaleY)); + + mpTextAttr->Put(SvxFontItem(aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), + aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO)); + mpTextAttr->Put(SvxFontItem(aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), + aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CJK)); + mpTextAttr->Put(SvxFontItem(aFnt.GetFamilyType(), aFnt.GetFamilyName(), aFnt.GetStyleName(), + aFnt.GetPitch(), aFnt.GetCharSet(), EE_CHAR_FONTINFO_CTL)); + mpTextAttr->Put(SvxPostureItem(aFnt.GetItalic(), EE_CHAR_ITALIC)); + mpTextAttr->Put(SvxWeightItem(aFnt.GetWeight(), EE_CHAR_WEIGHT)); + mpTextAttr->Put(SvxFontHeightItem(nHeight, 100, EE_CHAR_FONTHEIGHT)); + mpTextAttr->Put(SvxFontHeightItem(nHeight, 100, EE_CHAR_FONTHEIGHT_CJK)); + mpTextAttr->Put(SvxFontHeightItem(nHeight, 100, EE_CHAR_FONTHEIGHT_CTL)); + mpTextAttr->Put(SvxCharScaleWidthItem(100, EE_CHAR_FONTWIDTH)); + mpTextAttr->Put(SvxUnderlineItem(aFnt.GetUnderline(), EE_CHAR_UNDERLINE)); + mpTextAttr->Put(SvxOverlineItem(aFnt.GetOverline(), EE_CHAR_OVERLINE)); + mpTextAttr->Put(SvxCrossedOutItem(aFnt.GetStrikeout(), EE_CHAR_STRIKEOUT)); + mpTextAttr->Put(SvxShadowedItem(aFnt.IsShadow(), EE_CHAR_SHADOW)); + + // #i118485# Setting this item leads to problems (written #i118498# for this) + // mpTextAttr->Put(SvxAutoKernItem(aFnt.IsKerning(), EE_CHAR_KERNING)); + + mpTextAttr->Put(SvxWordLineModeItem(aFnt.IsWordLineMode(), EE_CHAR_WLM)); + mpTextAttr->Put(SvxContourItem(aFnt.IsOutline(), EE_CHAR_OUTLINE)); + mpTextAttr->Put(SvxColorItem(mpVD->GetTextColor(), EE_CHAR_COLOR)); + //... svxfont textitem svditext + mbFntDirty = false; + } + + if (!pObj) + return; + + pObj->SetLayer(mnLayer); + + if (bLine) + { + pObj->SetMergedItemSet(*mpLineAttr); + } + + if (bFill) + { + pObj->SetMergedItemSet(*mpFillAttr); + } + + if (bText) + { + pObj->SetMergedItemSet(*mpTextAttr); + pObj->SetMergedItem(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT)); + } +} + +void ImpSdrPdfImport::InsertObj(SdrObject* pObj1, bool bScale) +{ + rtl::Reference pObj = pObj1; + if (bScale && !maScaleRect.IsEmpty()) + { + if (mbSize) + { + pObj->NbcResize(Point(), maScaleX, maScaleY); + } + + if (mbMov) + { + pObj->NbcMove(Size(maOfs.X(), maOfs.Y())); + } + } + + if (isClip()) + { + const basegfx::B2DPolyPolygon aPoly(pObj->TakeXorPoly()); + const basegfx::B2DRange aOldRange(aPoly.getB2DRange()); + const SdrLayerID aOldLayer(pObj->GetLayer()); + const SfxItemSet aOldItemSet(pObj->GetMergedItemSet()); + const SdrGrafObj* pSdrGrafObj = dynamic_cast(pObj.get()); + const SdrTextObj* pSdrTextObj = DynCastSdrTextObj(pObj.get()); + + if (pSdrTextObj && pSdrTextObj->HasText()) + { + // all text objects are created from ImportText and have no line or fill attributes, so + // it is okay to concentrate on the text itself + while (true) + { + const basegfx::B2DPolyPolygon aTextContour(pSdrTextObj->TakeContour()); + const basegfx::B2DRange aTextRange(aTextContour.getB2DRange()); + const basegfx::B2DRange aClipRange(maClip.getB2DRange()); + + // no overlap -> completely outside + if (!aClipRange.overlaps(aTextRange)) + { + pObj.clear(); + break; + } + + // when the clip is a rectangle fast check for inside is possible + if (basegfx::utils::isRectangle(maClip) && aClipRange.isInside(aTextRange)) + { + // completely inside ClipRect + break; + } + + // here text needs to be clipped; to do so, convert to SdrObjects with polygons + // and add these recursively. Delete original object, do not add in this run + rtl::Reference pConverted = pSdrTextObj->ConvertToPolyObj(true, true); + pObj.clear(); + if (pConverted) + { + // recursively add created conversion; per definition this shall not + // contain further SdrTextObjs. Visit only non-group objects + SdrObjListIter aIter(*pConverted, SdrIterMode::DeepNoGroups); + + // work with clones; the created conversion may contain group objects + // and when working with the original objects the loop itself could + // break and the cleanup later would be pretty complicated (only delete group + // objects, are these empty, ...?) + while (aIter.IsMore()) + { + SdrObject* pCandidate = aIter.Next(); + OSL_ENSURE(pCandidate && dynamic_cast(pCandidate) == nullptr, + "SdrObjListIter with SdrIterMode::DeepNoGroups error (!)"); + rtl::Reference pNewClone( + pCandidate->CloneSdrObject(pCandidate->getSdrModelFromSdrObject())); + + if (pNewClone) + { + InsertObj(pNewClone.get(), false); + } + else + { + OSL_ENSURE(false, "SdrObject::Clone() failed (!)"); + } + } + } + + break; + } + } + else + { + BitmapEx aBitmapEx; + + if (pSdrGrafObj) + { + aBitmapEx = pSdrGrafObj->GetGraphic().GetBitmapEx(); + } + + pObj.clear(); + + if (!aOldRange.isEmpty()) + { + // clip against ClipRegion + const basegfx::B2DPolyPolygon aNewPoly(basegfx::utils::clipPolyPolygonOnPolyPolygon( + aPoly, maClip, true, !aPoly.isClosed())); + const basegfx::B2DRange aNewRange(aNewPoly.getB2DRange()); + + if (!aNewRange.isEmpty()) + { + pObj = new SdrPathObj( + *mpModel, aNewPoly.isClosed() ? SdrObjKind::Polygon : SdrObjKind::PolyLine, + aNewPoly); + + pObj->SetLayer(aOldLayer); + pObj->SetMergedItemSet(aOldItemSet); + + if (!aBitmapEx.IsEmpty()) + { + // aNewRange is inside of aOldRange and defines which part of aBitmapEx is used + const double fScaleX(aBitmapEx.GetSizePixel().Width() + / (aOldRange.getWidth() ? aOldRange.getWidth() : 1.0)); + const double fScaleY( + aBitmapEx.GetSizePixel().Height() + / (aOldRange.getHeight() ? aOldRange.getHeight() : 1.0)); + basegfx::B2DRange aPixel(aNewRange); + basegfx::B2DHomMatrix aTrans; + + aTrans.translate(-aOldRange.getMinX(), -aOldRange.getMinY()); + aTrans.scale(fScaleX, fScaleY); + aPixel.transform(aTrans); + + const Size aOrigSizePixel(aBitmapEx.GetSizePixel()); + const Point aClipTopLeft( + basegfx::fround(floor(std::max(0.0, aPixel.getMinX()))), + basegfx::fround(floor(std::max(0.0, aPixel.getMinY())))); + const Size aClipSize( + basegfx::fround(ceil(std::min( + static_cast(aOrigSizePixel.Width()), aPixel.getWidth()))), + basegfx::fround( + ceil(std::min(static_cast(aOrigSizePixel.Height()), + aPixel.getHeight())))); + const BitmapEx aClippedBitmap(aBitmapEx, aClipTopLeft, aClipSize); + + pObj->SetMergedItem(XFillStyleItem(drawing::FillStyle_BITMAP)); + pObj->SetMergedItem(XFillBitmapItem(OUString(), Graphic(aClippedBitmap))); + pObj->SetMergedItem(XFillBmpTileItem(false)); + pObj->SetMergedItem(XFillBmpStretchItem(true)); + } + } + } + } + } + + if (!pObj) + return; + + // #i111954# check object for visibility + // used are SdrPathObj, SdrRectObj, SdrCircObj, SdrGrafObj + bool bVisible(false); + + if (pObj->HasLineStyle()) + { + bVisible = true; + } + + if (!bVisible && pObj->HasFillStyle()) + { + bVisible = true; + } + + if (!bVisible) + { + SdrTextObj* pTextObj = DynCastSdrTextObj(pObj.get()); + + if (pTextObj && pTextObj->HasText()) + { + bVisible = true; + } + } + + if (!bVisible) + { + SdrGrafObj* pGrafObj = dynamic_cast(pObj.get()); + + if (pGrafObj) + { + // this may be refined to check if the graphic really is visible. It + // is here to ensure that graphic objects without fill, line and text + // get created + bVisible = true; + } + } + + if (bVisible) + { + maTmpList.push_back(pObj); + + if (dynamic_cast(pObj.get())) + { + const bool bClosed(pObj->IsClosedObj()); + + mbLastObjWasPolyWithoutLine = mbNoLine && bClosed; + } + else + { + mbLastObjWasPolyWithoutLine = false; + } + } +} + +bool ImpSdrPdfImport::CheckLastPolyLineAndFillMerge(const basegfx::B2DPolyPolygon& rPolyPolygon) +{ + // #i73407# reformulation to use new B2DPolygon classes + if (mbLastObjWasPolyWithoutLine) + { + SdrObject* pTmpObj = !maTmpList.empty() ? maTmpList[maTmpList.size() - 1].get() : nullptr; + SdrPathObj* pLastPoly = dynamic_cast(pTmpObj); + + if (pLastPoly) + { + if (pLastPoly->GetPathPoly() == rPolyPolygon) + { + SetAttributes(nullptr); + + if (!mbNoLine && mbNoFill) + { + pLastPoly->SetMergedItemSet(*mpLineAttr); + + return true; + } + } + } + } + + return false; +} + +void ImpSdrPdfImport::checkClip() +{ + if (mpVD->IsClipRegion()) + { + maClip = mpVD->GetClipRegion().GetAsB2DPolyPolygon(); + + if (isClip()) + { + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createScaleTranslateB2DHomMatrix( + mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + + maClip.transform(aTransform); + } + } +} + +bool ImpSdrPdfImport::isClip() const { return !maClip.getB2DRange().isEmpty(); } +void ImpSdrPdfImport::ImportPdfObject( + std::unique_ptr const& pPageObject, + std::unique_ptr const& pTextPage, int nPageObjectIndex) +{ + if (!pPageObject) + return; + + const vcl::pdf::PDFPageObjectType ePageObjectType = pPageObject->getType(); + switch (ePageObjectType) + { + case vcl::pdf::PDFPageObjectType::Text: + ImportText(pPageObject, pTextPage, nPageObjectIndex); + break; + case vcl::pdf::PDFPageObjectType::Path: + ImportPath(pPageObject, nPageObjectIndex); + break; + case vcl::pdf::PDFPageObjectType::Image: + ImportImage(pPageObject, nPageObjectIndex); + break; + case vcl::pdf::PDFPageObjectType::Shading: + SAL_WARN("sd.filter", "Got page object SHADING: " << nPageObjectIndex); + break; + case vcl::pdf::PDFPageObjectType::Form: + ImportForm(pPageObject, pTextPage, nPageObjectIndex); + break; + default: + SAL_WARN("sd.filter", "Unknown PDF page object #" << nPageObjectIndex << " of type: " + << static_cast(ePageObjectType)); + break; + } +} + +void ImpSdrPdfImport::ImportForm(std::unique_ptr const& pPageObject, + std::unique_ptr const& pTextPage, + int /*nPageObjectIndex*/) +{ + // Get the form matrix to perform correct translation/scaling of the form sub-objects. + const basegfx::B2DHomMatrix aOldMatrix = maCurrentMatrix; + + maCurrentMatrix = pPageObject->getMatrix(); + + const int nCount = pPageObject->getFormObjectCount(); + for (int nIndex = 0; nIndex < nCount; ++nIndex) + { + auto pFormObject = pPageObject->getFormObject(nIndex); + + ImportPdfObject(pFormObject, pTextPage, -1); + } + + // Restore the old one. + maCurrentMatrix = aOldMatrix; +} + +void ImpSdrPdfImport::ImportText(std::unique_ptr const& pPageObject, + std::unique_ptr const& pTextPage, + int /*nPageObjectIndex*/) +{ + basegfx::B2DRectangle aTextRect = pPageObject->getBounds(); + basegfx::B2DHomMatrix aMatrix = pPageObject->getMatrix(); + + basegfx::B2DHomMatrix aTextMatrix(maCurrentMatrix); + + aTextRect *= aTextMatrix; + const tools::Rectangle aRect = PointsToLogic(aTextRect.getMinX(), aTextRect.getMaxX(), + aTextRect.getMinY(), aTextRect.getMaxY()); + + OUString sText = pPageObject->getText(pTextPage); + + const double dFontSize = pPageObject->getFontSize(); + double dFontSizeH = fabs(std::hypot(aMatrix.a(), aMatrix.c()) * dFontSize); + double dFontSizeV = fabs(std::hypot(aMatrix.b(), aMatrix.d()) * dFontSize); + + dFontSizeH = convertPointToMm100(dFontSizeH); + dFontSizeV = convertPointToMm100(dFontSizeV); + + const Size aFontSize(dFontSizeH, dFontSizeV); + vcl::Font aFnt = mpVD->GetFont(); + if (aFontSize != aFnt.GetFontSize()) + { + aFnt.SetFontSize(aFontSize); + mpVD->SetFont(aFnt); + mbFntDirty = true; + } + + OUString sFontName = pPageObject->getFontName(); + if (!sFontName.isEmpty() && sFontName != aFnt.GetFamilyName()) + { + aFnt.SetFamilyName(sFontName); + mpVD->SetFont(aFnt); + mbFntDirty = true; + } + + Color aTextColor(COL_TRANSPARENT); + bool bFill = false; + bool bUse = true; + switch (pPageObject->getTextRenderMode()) + { + case vcl::pdf::PDFTextRenderMode::Fill: + case vcl::pdf::PDFTextRenderMode::FillClip: + case vcl::pdf::PDFTextRenderMode::FillStroke: + case vcl::pdf::PDFTextRenderMode::FillStrokeClip: + bFill = true; + break; + case vcl::pdf::PDFTextRenderMode::Stroke: + case vcl::pdf::PDFTextRenderMode::StrokeClip: + case vcl::pdf::PDFTextRenderMode::Unknown: + break; + case vcl::pdf::PDFTextRenderMode::Invisible: + case vcl::pdf::PDFTextRenderMode::Clip: + bUse = false; + break; + } + if (bUse) + { + Color aColor = bFill ? pPageObject->getFillColor() : pPageObject->getStrokeColor(); + if (aColor != COL_TRANSPARENT) + aTextColor = aColor.GetRGBColor(); + } + + if (aTextColor != mpVD->GetTextColor()) + { + mpVD->SetTextColor(aTextColor); + mbFntDirty = true; + } + + InsertTextObject(aRect.TopLeft(), aRect.GetSize(), sText); +} + +void ImpSdrPdfImport::InsertTextObject(const Point& rPos, const Size& rSize, const OUString& rStr) +{ + // calc text box size, add 5% to make it fit safely + + FontMetric aFontMetric(mpVD->GetFontMetric()); + vcl::Font aFont(mpVD->GetFont()); + TextAlign eAlignment(aFont.GetAlignment()); + + // sal_Int32 nTextWidth = static_cast(mpVD->GetTextWidth(rStr) * mfScaleX); + sal_Int32 nTextHeight = static_cast(mpVD->GetTextHeight() * mfScaleY); + + Point aPosition(FRound(rPos.X() * mfScaleX + maOfs.X()), + FRound(rPos.Y() * mfScaleY + maOfs.Y())); + Size aSize(FRound(rSize.Width() * mfScaleX), FRound(rSize.Height() * mfScaleY)); + + if (eAlignment == ALIGN_BASELINE) + aPosition.AdjustY(-FRound(aFontMetric.GetAscent() * mfScaleY)); + else if (eAlignment == ALIGN_BOTTOM) + aPosition.AdjustY(-nTextHeight); + + tools::Rectangle aTextRect(aPosition, aSize); + rtl::Reference pText = new SdrRectObj(*mpModel, SdrObjKind::Text, aTextRect); + + pText->SetMergedItem(makeSdrTextUpperDistItem(0)); + pText->SetMergedItem(makeSdrTextLowerDistItem(0)); + pText->SetMergedItem(makeSdrTextRightDistItem(0)); + pText->SetMergedItem(makeSdrTextLeftDistItem(0)); + + if (aFont.GetAverageFontWidth()) + { + pText->ClearMergedItem(SDRATTR_TEXT_AUTOGROWWIDTH); + pText->SetMergedItem(makeSdrTextAutoGrowHeightItem(false)); + // don't let the margins eat the space needed for the text + pText->SetMergedItem(SdrTextFitToSizeTypeItem(drawing::TextFitToSizeType_ALLLINES)); + } + else + { + pText->SetMergedItem(makeSdrTextAutoGrowWidthItem(true)); + } + + pText->SetLayer(mnLayer); + pText->NbcSetText(rStr); + SetAttributes(pText.get(), true); + pText->SetSnapRect(aTextRect); + + if (!aFont.IsTransparent()) + { + SfxItemSetFixed aAttr(*mpFillAttr->GetPool()); + aAttr.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + aAttr.Put(XFillColorItem(OUString(), aFont.GetFillColor())); + pText->SetMergedItemSet(aAttr); + } + Degree100 nAngle = to(aFont.GetOrientation()); + if (nAngle) + pText->SdrAttrObj::NbcRotate(aPosition, nAngle); + InsertObj(pText.get(), false); +} + +void ImpSdrPdfImport::MapScaling() +{ + const size_t nCount(maTmpList.size()); + const MapMode& rMap = mpVD->GetMapMode(); + Point aMapOrg(rMap.GetOrigin()); + bool bMov2(aMapOrg.X() != 0 || aMapOrg.Y() != 0); + + if (bMov2) + { + for (size_t i = mnMapScalingOfs; i < nCount; i++) + { + SdrObject* pObj = maTmpList[i].get(); + + pObj->NbcMove(Size(aMapOrg.X(), aMapOrg.Y())); + } + } + + mnMapScalingOfs = nCount; +} + +void ImpSdrPdfImport::ImportImage(std::unique_ptr const& pPageObject, + int /*nPageObjectIndex*/) +{ + std::unique_ptr bitmap = pPageObject->getImageBitmap(); + if (!bitmap) + { + SAL_WARN("sd.filter", "Failed to get IMAGE"); + return; + } + + const vcl::pdf::PDFBitmapType format = bitmap->getFormat(); + if (format == vcl::pdf::PDFBitmapType::Unknown) + { + SAL_WARN("sd.filter", "Failed to get IMAGE format"); + return; + } + + const unsigned char* pBuf = bitmap->getBuffer(); + const int nWidth = bitmap->getWidth(); + const int nHeight = bitmap->getHeight(); + const int nStride = bitmap->getStride(); + BitmapEx aBitmap(Size(nWidth, nHeight), vcl::PixelFormat::N24_BPP); + + switch (format) + { + case vcl::pdf::PDFBitmapType::BGR: + ReadRawDIB(aBitmap, pBuf, ScanlineFormat::N24BitTcBgr, nHeight, nStride); + break; + case vcl::pdf::PDFBitmapType::BGRx: + ReadRawDIB(aBitmap, pBuf, ScanlineFormat::N32BitTcRgba, nHeight, nStride); + break; + case vcl::pdf::PDFBitmapType::BGRA: + ReadRawDIB(aBitmap, pBuf, ScanlineFormat::N32BitTcBgra, nHeight, nStride); + break; + default: + SAL_WARN("sd.filter", "Got IMAGE width: " << nWidth << ", height: " << nHeight + << ", stride: " << nStride + << ", format: " << static_cast(format)); + break; + } + + basegfx::B2DRectangle aBounds = pPageObject->getBounds(); + float left = aBounds.getMinX(); + // Upside down. + float bottom = aBounds.getMinY(); + float right = aBounds.getMaxX(); + // Upside down. + float top = aBounds.getMaxY(); + tools::Rectangle aRect = PointsToLogic(left, right, top, bottom); + aRect.AdjustRight(1); + aRect.AdjustBottom(1); + + rtl::Reference pGraf = new SdrGrafObj(*mpModel, Graphic(aBitmap), aRect); + + // This action is not creating line and fill, set directly, do not use SetAttributes(..) + pGraf->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); + pGraf->SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE)); + InsertObj(pGraf.get()); +} + +void ImpSdrPdfImport::ImportPath(std::unique_ptr const& pPageObject, + int /*nPageObjectIndex*/) +{ + auto aPathMatrix = pPageObject->getMatrix(); + + aPathMatrix *= maCurrentMatrix; + + basegfx::B2DPolyPolygon aPolyPoly; + basegfx::B2DPolygon aPoly; + std::vector aBezier; + + const int nSegments = pPageObject->getPathSegmentCount(); + for (int nSegmentIndex = 0; nSegmentIndex < nSegments; ++nSegmentIndex) + { + auto pPathSegment = pPageObject->getPathSegment(nSegmentIndex); + if (pPathSegment != nullptr) + { + basegfx::B2DPoint aB2DPoint = pPathSegment->getPoint(); + aB2DPoint *= aPathMatrix; + + const bool bClose = pPathSegment->isClosed(); + if (bClose) + aPoly.setClosed(bClose); // TODO: Review + + Point aPoint = PointsToLogic(aB2DPoint.getX(), aB2DPoint.getY()); + aB2DPoint.setX(aPoint.X()); + aB2DPoint.setY(aPoint.Y()); + + const vcl::pdf::PDFSegmentType eSegmentType = pPathSegment->getType(); + switch (eSegmentType) + { + case vcl::pdf::PDFSegmentType::Lineto: + aPoly.append(aB2DPoint); + break; + + case vcl::pdf::PDFSegmentType::Bezierto: + aBezier.emplace_back(aB2DPoint.getX(), aB2DPoint.getY()); + if (aBezier.size() == 3) + { + aPoly.appendBezierSegment(aBezier[0], aBezier[1], aBezier[2]); + aBezier.clear(); + } + break; + + case vcl::pdf::PDFSegmentType::Moveto: + // New Poly. + if (aPoly.count() > 0) + { + aPolyPoly.append(aPoly, 1); + aPoly.clear(); + } + + aPoly.append(aB2DPoint); + break; + + case vcl::pdf::PDFSegmentType::Unknown: + default: + SAL_WARN("sd.filter", "Unknown path segment type in PDF: " + << static_cast(eSegmentType)); + break; + } + } + } + + if (aBezier.size() == 3) + { + aPoly.appendBezierSegment(aBezier[0], aBezier[1], aBezier[2]); + aBezier.clear(); + } + + if (aPoly.count() > 0) + { + aPolyPoly.append(aPoly, 1); + aPoly.clear(); + } + + const basegfx::B2DHomMatrix aTransform( + basegfx::utils::createScaleTranslateB2DHomMatrix(mfScaleX, mfScaleY, maOfs.X(), maOfs.Y())); + aPolyPoly.transform(aTransform); + + float fWidth = pPageObject->getStrokeWidth(); + const double dWidth = 0.5 * fabs(std::hypot(aPathMatrix.a(), aPathMatrix.c()) * fWidth); + mnLineWidth = convertPointToMm100(dWidth); + + vcl::pdf::PDFFillMode nFillMode = vcl::pdf::PDFFillMode::Alternate; + bool bStroke = true; // Assume we have to draw, unless told otherwise. + if (pPageObject->getDrawMode(nFillMode, bStroke)) + { + if (nFillMode == vcl::pdf::PDFFillMode::Alternate) + mpVD->SetDrawMode(DrawModeFlags::Default); + else if (nFillMode == vcl::pdf::PDFFillMode::Winding) + mpVD->SetDrawMode(DrawModeFlags::Default); + else + mpVD->SetDrawMode(DrawModeFlags::NoFill); + } + + mpVD->SetFillColor(pPageObject->getFillColor()); + + if (bStroke) + { + mpVD->SetLineColor(pPageObject->getStrokeColor()); + } + else + mpVD->SetLineColor(COL_TRANSPARENT); + + if (!mbLastObjWasPolyWithoutLine || !CheckLastPolyLineAndFillMerge(aPolyPoly)) + { + rtl::Reference pPath + = new SdrPathObj(*mpModel, SdrObjKind::Polygon, std::move(aPolyPoly)); + SetAttributes(pPath.get()); + InsertObj(pPath.get(), false); + } +} + +Point ImpSdrPdfImport::PointsToLogic(double x, double y) const +{ + y = correctVertOrigin(y); + + Point aPos(convertPointToMm100(x), convertPointToMm100(y)); + return aPos; +} + +tools::Rectangle ImpSdrPdfImport::PointsToLogic(double left, double right, double top, + double bottom) const +{ + top = correctVertOrigin(top); + bottom = correctVertOrigin(bottom); + + Point aPos(convertPointToMm100(left), convertPointToMm100(top)); + Size aSize(convertPointToMm100(right - left), convertPointToMm100(bottom - top)); + + return tools::Rectangle(aPos, aSize); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdpntv.cxx b/svx/source/svdraw/svdpntv.cxx new file mode 100644 index 0000000000..4584e7f831 --- /dev/null +++ b/svx/source/svdraw/svdpntv.cxx @@ -0,0 +1,1218 @@ +/* -*- 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 +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; + +// interface to SdrPaintWindow + +SdrPaintWindow* SdrPaintView::FindPaintWindow(const OutputDevice& rOut) const +{ + // back to loop - there is more to test than a std::find_if and a lambda can do + for(auto& candidate : maPaintWindows) + { + if(&(candidate->GetOutputDevice()) == &rOut) + { + return candidate.get(); + } + + // check for patched to allow finding in that state, too + if(nullptr != candidate->getPatched() && &(candidate->getPatched()->GetOutputDevice()) == &rOut) + { + return candidate->getPatched(); + } + } + + return nullptr; +} + +SdrPaintWindow* SdrPaintView::GetPaintWindow(sal_uInt32 nIndex) const +{ + return maPaintWindows[nIndex].get(); +} + +void SdrPaintView::DeletePaintWindow(const SdrPaintWindow& rOld) +{ + auto aFindResult = ::std::find_if(maPaintWindows.begin(), maPaintWindows.end(), + [&](const std::unique_ptr& p) { return p.get() == &rOld; }); + + if(aFindResult != maPaintWindows.end()) + { + maPaintWindows.erase(aFindResult); + } +} + +OutputDevice* SdrPaintView::GetFirstOutputDevice() const +{ + if(PaintWindowCount()) + { + return &(GetPaintWindow(0)->GetOutputDevice()); + } + + return nullptr; +} + + +SvxViewChangedHint::SvxViewChangedHint() : SfxHint(SfxHintId::SvxViewChanged) +{ +} + + +BitmapEx convertMetafileToBitmapEx( + const GDIMetaFile& rMtf, + const basegfx::B2DRange& rTargetRange, + const sal_uInt32 nMaximumQuadraticPixels) +{ + BitmapEx aBitmapEx; + + if(rMtf.GetActionSize()) + { + const drawinglayer::primitive2d::Primitive2DReference aMtf( + new drawinglayer::primitive2d::MetafilePrimitive2D( + basegfx::utils::createScaleTranslateB2DHomMatrix( + rTargetRange.getRange(), + rTargetRange.getMinimum()), + rMtf)); + aBitmapEx = drawinglayer::convertPrimitive2DContainerToBitmapEx( + drawinglayer::primitive2d::Primitive2DContainer { aMtf }, + rTargetRange, + nMaximumQuadraticPixels); + } + + return aBitmapEx; +} + +SdrPaintView::SdrPaintView(SdrModel& rSdrModel, OutputDevice* pOut) + : mrModel(rSdrModel) + , mpActualOutDev(nullptr) + , mpDragWin(nullptr) + , mpDefaultStyleSheet(nullptr) + , maDefaultAttr(rSdrModel.GetItemPool()) + , maComeBackIdle( "svx::SdrPaintView aComeBackIdle" ) + , meAnimationMode(SdrAnimationMode::Animate) + , mnHitTolPix(2) + , mnMinMovPix(3) + , mnHitTolLog(0) + , mnMinMovLog(0) + , mbPageVisible(true) + , mbPageShadowVisible(true) + , mbPageBorderVisible(true) + , mbBordVisible(true) + , mbGridVisible(true) + , mbGridFront(false) + , mbHlplVisible(true) + , mbHlplFront(true) + , mbGlueVisible(false) + , mbGlueVisible2(false) + , mbGlueVisible3(false) + , mbGlueVisible4(false) + , mbSomeObjChgdFlag(false) + , mbSwapAsynchron(false) + , mbPrintPreview(false) + , mbAnimationPause(false) + , mbBufferedOutputAllowed(false) + , mbBufferedOverlayAllowed(false) + , mbPageDecorationAllowed(true) + , mbMasterPageVisualizationAllowed(true) + , mbPreviewRenderer(false) + , mbHideOle(false) + , mbHideChart(false) + , mbHideDraw(false) + , mbHideFormControl(false) + , mbPaintTextEdit(true) + , maGridColor(COL_BLACK) +{ + maComeBackIdle.SetPriority(TaskPriority::REPAINT); + maComeBackIdle.SetInvokeHandler(LINK(this,SdrPaintView,ImpComeBackHdl)); + + SetDefaultStyleSheet(GetModel().GetDefaultStyleSheet(), true); + + if (pOut) + AddDeviceToPaintView(*pOut, nullptr); + + maColorConfig.AddListener(this); + onChangeColorConfig(); +} + +SdrPaintView::~SdrPaintView() +{ + if (mpDefaultStyleSheet) + EndListening(*mpDefaultStyleSheet); + + maColorConfig.RemoveListener(this); + ClearPageView(); + + // delete existing SdrPaintWindows + maPaintWindows.clear(); +} + + +void SdrPaintView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + //If the stylesheet has been destroyed + if (&rBC == mpDefaultStyleSheet) + { + if (rHint.GetId() == SfxHintId::Dying) + mpDefaultStyleSheet = nullptr; + return; + } + + if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint) + return; + const SdrHint* pSdrHint = static_cast(&rHint); + SdrHintKind eKind = pSdrHint->GetKind(); + if (eKind==SdrHintKind::ObjectChange || eKind==SdrHintKind::ObjectInserted || eKind==SdrHintKind::ObjectRemoved) + { + bool bObjChg = !mbSomeObjChgdFlag; // if true, evaluate for ComeBack timer + if (bObjChg) + { + mbSomeObjChgdFlag=true; + maComeBackIdle.Start(); + } + } + + if (eKind==SdrHintKind::PageOrderChange) + { + const SdrPage* pPg=pSdrHint->GetPage(); + if (pPg && !pPg->IsInserted()) + { + if(mpPageView && mpPageView->GetPage() == pPg) + { + HideSdrPage(); + } + } + } +} + +void SdrPaintView::ConfigurationChanged( ::utl::ConfigurationBroadcaster* , ConfigurationHints eHint) +{ + if (eHint == ConfigurationHints::OnlyCurrentDocumentColorScheme) + return; + onChangeColorConfig(); + InvalidateAllWin(); +} + +IMPL_LINK_NOARG(SdrPaintView, ImpComeBackHdl, Timer *, void) +{ + if (mbSomeObjChgdFlag) { + mbSomeObjChgdFlag=false; + ModelHasChanged(); + } +} + +void SdrPaintView::FlushComeBackTimer() const +{ + if (mbSomeObjChgdFlag) { + // casting to nonconst + const_cast(this)->ImpComeBackHdl(&const_cast(this)->maComeBackIdle); + const_cast(this)->maComeBackIdle.Stop(); + } +} + +void SdrPaintView::ModelHasChanged() +{ + // broadcast to all PageViews + if(mpPageView && !mpPageView->GetPage()->IsInserted()) + { + HideSdrPage(); + } + + // test mpPageView here again, HideSdrPage() may have invalidated it. + if(mpPageView) + { + mpPageView->ModelHasChanged(); + } +} + + +bool SdrPaintView::IsAction() const +{ + return false; +} + +void SdrPaintView::MovAction(const Point&) +{ +} + +void SdrPaintView::EndAction() +{ +} + +void SdrPaintView::BckAction() +{ +} + +void SdrPaintView::BrkAction() +{ +} + +void SdrPaintView::TakeActionRect(tools::Rectangle&) const +{ +} + + +// info about TextEdit. Default is false. +bool SdrPaintView::IsTextEdit() const +{ + return false; +} + +sal_uInt16 SdrPaintView::ImpGetMinMovLogic(short nMinMov, const OutputDevice* pOut) const +{ + if (nMinMov>=0) return sal_uInt16(nMinMov); + if (pOut==nullptr) + { + pOut = GetFirstOutputDevice(); + } + if (pOut!=nullptr) { + return short(-pOut->PixelToLogic(Size(nMinMov,0)).Width()); + } else { + return 0; + } +} + +sal_uInt16 SdrPaintView::ImpGetHitTolLogic(short nHitTol, const OutputDevice* pOut) const +{ + if (nHitTol>=0) return sal_uInt16(nHitTol); + if (pOut==nullptr) + { + pOut = GetFirstOutputDevice(); + } + if (pOut!=nullptr) { + return short(-pOut->PixelToLogic(Size(nHitTol,0)).Width()); + } else { + return 0; + } +} + +void SdrPaintView::TheresNewMapMode() +{ + if (mpActualOutDev) { + mnHitTolLog=static_cast(mpActualOutDev->PixelToLogic(Size(mnHitTolPix,0)).Width()); + mnMinMovLog=static_cast(mpActualOutDev->PixelToLogic(Size(mnMinMovPix,0)).Width()); + } +} + +void SdrPaintView::SetActualWin(const OutputDevice* pWin) +{ + mpActualOutDev = const_cast(pWin); + TheresNewMapMode(); +} + + +void SdrPaintView::ClearPageView() +{ + BrkAction(); + + if(mpPageView) + { + InvalidateAllWin(); + mpPageView.reset(); + } +} + +SdrPageView* SdrPaintView::ShowSdrPage(SdrPage* pPage) +{ + if(pPage && (!mpPageView || mpPageView->GetPage() != pPage)) + { + if(mpPageView) + { + InvalidateAllWin(); + mpPageView.reset(); + } + + if (SdrView *pView = dynamic_cast(this)) + { + mpPageView.reset(new SdrPageView(pPage, *pView)); + mpPageView->Show(); + } + } + + return mpPageView.get(); +} + +void SdrPaintView::HideSdrPage() +{ + if(mpPageView) + { + mpPageView->Hide(); + mpPageView.reset(); + } +} + +void SdrPaintView::AddDeviceToPaintView(OutputDevice& rNewDev, vcl::Window *pWindow) +{ + SdrPaintWindow* pNewPaintWindow = new SdrPaintWindow(*this, rNewDev, pWindow); + maPaintWindows.emplace_back(pNewPaintWindow); + + if(mpPageView) + { + mpPageView->AddPaintWindowToPageView(*pNewPaintWindow); + } +} + +void SdrPaintView::DeleteDeviceFromPaintView(OutputDevice& rOldDev) +{ + SdrPaintWindow* pCandidate = FindPaintWindow(rOldDev); + + if(pCandidate) + { + if(mpPageView) + { + mpPageView->RemovePaintWindowFromPageView(*pCandidate); + } + + DeletePaintWindow(*pCandidate); + } +} + +void SdrPaintView::SetLayerVisible(const OUString& rName, bool bShow) +{ + if(mpPageView) + { + mpPageView->SetLayerVisible(rName, bShow); + } + + InvalidateAllWin(); +} + +bool SdrPaintView::IsLayerVisible(const OUString& rName) const +{ + if(mpPageView) + { + return mpPageView->IsLayerVisible(rName); + } + + return false; +} + +void SdrPaintView::SetLayerLocked(const OUString& rName, bool bLock) +{ + if(mpPageView) + { + mpPageView->SetLayerLocked(rName,bLock); + } +} + +bool SdrPaintView::IsLayerLocked(const OUString& rName) const +{ + if(mpPageView) + { + return mpPageView->IsLayerLocked(rName); + } + + return false; +} + +void SdrPaintView::SetLayerPrintable(const OUString& rName, bool bPrn) +{ + if(mpPageView) + { + mpPageView->SetLayerPrintable(rName,bPrn); + } +} + +bool SdrPaintView::IsLayerPrintable(const OUString& rName) const +{ + if(mpPageView) + { + return mpPageView->IsLayerPrintable(rName); + } + + return false; +} + +void SdrPaintView::PrePaint() +{ + if(mpPageView) + { + mpPageView->PrePaint(); + } +} + + +// #define SVX_REPAINT_TIMER_TEST + +void SdrPaintView::CompleteRedraw(OutputDevice* pOut, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector) +{ +#ifdef SVX_REPAINT_TIMER_TEST +#define REMEMBERED_TIMES_COUNT (10) + static bool bDoTimerTest(false); + static bool bTimesInited(false); + static sal_uInt32 nRepeatCount(10); + static double fLastTimes[REMEMBERED_TIMES_COUNT]; + const sal_uInt64 nStartTime(tools::Time::GetSystemTicks()); + sal_uInt32 count(1); + sal_uInt32 a; + + if(bDoTimerTest) + { + count = nRepeatCount; + } + + for(a = 0; a < count; a++) + { +#endif // SVX_REPAINT_TIMER_TEST + + // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region + // rReg may be made more granular (fine) with using it. Normally, rReg + // does come from Window::Paint() anyways and thus is based on a single + // rectangle which was derived from exactly that repaint region + vcl::Region aOptimizedRepaintRegion(rReg); + + if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType()) + { + vcl::Window* pWindow = pOut->GetOwnerWindow(); + + if(pWindow->IsInPaint()) + { + if(!pWindow->GetPaintRegion().IsEmpty()) + { + aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion()); + } + } + } + + SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut); + OSL_ENSURE(pPaintWindow, "SdrPaintView::CompleteRedraw: No OutDev (!)"); + + DoCompleteRedraw(*pPaintWindow, aOptimizedRepaintRegion, pRedirector); + EndCompleteRedraw(*pPaintWindow, true); + +#ifdef SVX_REPAINT_TIMER_TEST + } + + if(bDoTimerTest) + { + const sal_uInt64 nStopTime(tools::Time::GetSystemTicks()); + const sal_uInt64 nNeededTime(nStopTime - nStartTime); + const double fTimePerPaint((double)nNeededTime / (double)nRepeatCount); + + if(!bTimesInited) + { + for(a = 0; a < REMEMBERED_TIMES_COUNT; a++) + { + fLastTimes[a] = fTimePerPaint; + } + + bTimesInited = true; + } + else + { + for(a = 1; a < REMEMBERED_TIMES_COUNT; a++) + { + fLastTimes[a - 1] = fLastTimes[a]; + } + + fLastTimes[REMEMBERED_TIMES_COUNT - 1] = fTimePerPaint; + } + + double fAddedTimes(0.0); + + for(a = 0; a < REMEMBERED_TIMES_COUNT; a++) + { + fAddedTimes += fLastTimes[a]; + } + + const double fAverageTimePerPaint(fAddedTimes / (double)REMEMBERED_TIMES_COUNT); + + fprintf(stderr, "-----------(start result)----------\n"); + fprintf(stderr, "StartTime : %" SAL_PRIuUINT64 ", StopTime: %" SAL_PRIuUINT64 ", NeededTime: %" SAL_PRIuUINT64 ", TimePerPaint: %f\n", nStartTime, nStopTime, nNeededTime, fTimePerPaint); + fprintf(stderr, "Remembered times: "); + + for(a = 0; a < REMEMBERED_TIMES_COUNT; a++) + { + fprintf(stderr, "%d: %f ", a, fLastTimes[a]); + } + + fprintf(stderr, "\n"); + fprintf(stderr, "AverageTimePerPaint: %f\n", fAverageTimePerPaint); + fprintf(stderr, "-----------(stop result)----------\n"); + } +#endif // SVX_REPAINT_TIMER_TEST +} + + +// #i72889# + +SdrPaintWindow* SdrPaintView::BeginCompleteRedraw(OutputDevice* pOut) +{ + OSL_ENSURE(pOut, "SdrPaintView::BeginCompleteRedraw: No OutDev (!)"); + SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut); + + if(pPaintWindow) + { + // draw preprocessing, only for known devices + // prepare PreRendering + pPaintWindow->PreparePreRenderDevice(); + } + else + { + // None of the known OutputDevices is the target of this paint, use + // a temporary SdrPaintWindow for this Redraw. + pPaintWindow = new SdrPaintWindow(*this, *pOut); + pPaintWindow->setTemporaryTarget(true); + } + + return pPaintWindow; +} + +void SdrPaintView::DoCompleteRedraw(SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector) +{ + // redraw all PageViews with the target. This may expand the RedrawRegion + // at the PaintWindow, plus taking care of FormLayer expansion + if(mpPageView) + { + mpPageView->CompleteRedraw(rPaintWindow, rReg, pRedirector); + } +} + +void SdrPaintView::EndCompleteRedraw(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer) +{ + std::unique_ptr pPaintWindow; + if (comphelper::LibreOfficeKit::isActive() && rPaintWindow.getTemporaryTarget()) + { + // Tiled rendering, we must paint the TextEdit to the output device. + pPaintWindow.reset(&rPaintWindow); + pPaintWindow->setTemporaryTarget(false); + } + + if(rPaintWindow.getTemporaryTarget()) + { + // get rid of temp target again + delete &rPaintWindow; + } + else + { + // draw postprocessing, only for known devices + // it is necessary to always paint FormLayer + // In the LOK case control rendering is performed through LokControlHandler + if(!comphelper::LibreOfficeKit::isActive() && bPaintFormLayer) + { + ImpFormLayerDrawing(rPaintWindow); + } + + // look for active TextEdit. As long as this cannot be painted to a VDev, + // it cannot get part of buffering. In that case, output evtl. prerender + // early and paint text edit to window. + SdrPageView* pPageView = GetSdrPageView(); + if(IsTextEdit() && pPageView) + { + if (!comphelper::LibreOfficeKit::isActive() || mbPaintTextEdit) + static_cast< SdrView* >(this)->TextEditDrawing(rPaintWindow); + } + + if (comphelper::LibreOfficeKit::isActive() && pPageView) + { + // Look for active text edits in other views showing the same page, + // and show them as well. Show only if Page/MasterPage mode is matching. + bool bRequireMasterPage = pPageView->GetPage() ? pPageView->GetPage()->IsMasterPage() : false; + SdrViewIter::ForAllViews(pPageView->GetPage(), + [this, &bRequireMasterPage, &rPaintWindow] (SdrView* pView) + { + SdrPageView* pCurrentPageView = pView->GetSdrPageView(); + bool bIsCurrentMasterPage = (pCurrentPageView && pCurrentPageView->GetPage()) ? + pCurrentPageView->GetPage()->IsMasterPage() : false; + + if (pView == this || bRequireMasterPage != bIsCurrentMasterPage) + return false; + + if (pView->IsTextEdit() && pView->GetSdrPageView()) + { + pView->TextEditDrawing(rPaintWindow); + } + return false; + }); + } + + // draw Overlay, also to PreRender device if exists + rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion()); + + // output PreRendering + rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion()); + } +} + + +SdrPaintWindow* SdrPaintView::BeginDrawLayers(OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect) +{ + // #i74769# use BeginCompleteRedraw() as common base + SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut); + OSL_ENSURE(pPaintWindow, "SdrPaintView::BeginDrawLayers: No SdrPaintWindow (!)"); + + if(mpPageView) + { + SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow); + + if(pKnownTarget) + { + vcl::Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, bDisableIntersect ); + + // prepare redraw + pKnownTarget->PrepareRedraw(aOptimizedRepaintRegion); + + // remember prepared SdrPageWindow + mpPageView->setPreparedPageWindow(pKnownTarget); + } + } + + return pPaintWindow; +} + +void SdrPaintView::EndDrawLayers(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer) +{ + // #i74769# use EndCompleteRedraw() as common base + EndCompleteRedraw(rPaintWindow, bPaintFormLayer); + + if(mpPageView) + { + // forget prepared SdrPageWindow + mpPageView->setPreparedPageWindow(nullptr); + } +} + +void SdrPaintView::UpdateDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg) +{ + SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut); + OSL_ENSURE(pPaintWindow, "SdrPaintView::UpdateDrawLayersRegion: No SdrPaintWindow (!)"); + + if(mpPageView) + { + SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow); + + if(pKnownTarget) + { + vcl::Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, false/*bDisableIntersect*/ ); + pKnownTarget->GetPaintWindow().SetRedrawRegion(aOptimizedRepaintRegion); + mpPageView->setPreparedPageWindow(pKnownTarget); // already set actually + } + } +} + +vcl::Region SdrPaintView::OptimizeDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect) +{ + // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region + // rReg may be made more granular (fine) with using it. Normally, rReg + // does come from Window::Paint() anyways and thus is based on a single + // rectangle which was derived from exactly that repaint region + vcl::Region aOptimizedRepaintRegion(rReg); + + // #i76114# Intersecting the region with the Window's paint region is disabled + // for print preview in Calc, because the intersection can be empty (if the paint + // region is outside of the table area of the page), and then no clip region + // would be set. + if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType() && !bDisableIntersect) + { + vcl::Window* pWindow = pOut->GetOwnerWindow(); + + if(pWindow->IsInPaint()) + { + if(!pWindow->GetPaintRegion().IsEmpty()) + { + aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion()); + } + } + } + return aOptimizedRepaintRegion; +} + + +void SdrPaintView::ImpFormLayerDrawing( SdrPaintWindow& rPaintWindow ) +{ + if(!mpPageView) + return; + + SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(rPaintWindow); + + if(pKnownTarget) + { + const SdrModel& rModel = GetModel(); + const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin(); + const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName()); + + // BUFFERED use GetTargetOutputDevice() now, it may be targeted to VDevs, too + // need to set PreparedPageWindow to make DrawLayer use the correct ObjectContact + mpPageView->setPreparedPageWindow(pKnownTarget); + mpPageView->DrawLayer(nControlLayerId, &rPaintWindow.GetTargetOutputDevice()); + mpPageView->setPreparedPageWindow(nullptr); + } +} + + +bool SdrPaintView::KeyInput(const KeyEvent& /*rKEvt*/, vcl::Window* /*pWin*/) +{ + return false; +} + +void SdrPaintView::GlueInvalidate() const +{ + // Do not invalidate GluePoints in Online + // They are handled on front-end + if (comphelper::LibreOfficeKit::isActive()) + return; + + const sal_uInt32 nWindowCount(PaintWindowCount()); + + for(sal_uInt32 nWinNum(0); nWinNum < nWindowCount; nWinNum++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(nWinNum); + + if(pPaintWindow->OutputToWindow()) + { + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + + if(mpPageView) + { + const SdrObjList* pOL=mpPageView->GetObjList(); + for (const rtl::Reference& pObj : *pOL) { + const SdrGluePointList* pGPL=pObj->GetGluePointList(); + if (pGPL!=nullptr && pGPL->GetCount()!=0) { + pGPL->Invalidate(*rOutDev.GetOwnerWindow(), pObj.get()); + } + } + } + } + } +} + +void SdrPaintView::InvalidateAllWin() +{ + const sal_uInt32 nWindowCount(PaintWindowCount()); + + for(sal_uInt32 a(0); a < nWindowCount; a++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(a); + + if(pPaintWindow->OutputToWindow()) + { + InvalidateOneWin(pPaintWindow->GetOutputDevice()); + } + } +} + +void SdrPaintView::InvalidateAllWin(const tools::Rectangle& rRect) +{ + const sal_uInt32 nWindowCount(PaintWindowCount()); + + for(sal_uInt32 a(0); a < nWindowCount; a++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(a); + + if(pPaintWindow->OutputToWindow()) + { + OutputDevice& rOutDev = pPaintWindow->GetOutputDevice(); + tools::Rectangle aRect(rRect); + + Point aOrg(rOutDev.GetMapMode().GetOrigin()); + aOrg.setX(-aOrg.X() ); aOrg.setY(-aOrg.Y() ); + tools::Rectangle aOutRect(aOrg, rOutDev.GetOutputSize()); + + // In case of tiled rendering we want to get all invalidations, so visual area is not interesting. + if (aRect.Overlaps(aOutRect) || comphelper::LibreOfficeKit::isActive()) + { + InvalidateOneWin(rOutDev, aRect); + } + } + } +} + +void SdrPaintView::InvalidateOneWin(OutputDevice& rDevice) +{ + // do not erase background, that causes flicker (!) + rDevice.GetOwnerWindow()->Invalidate(InvalidateFlags::NoErase); +} + +void SdrPaintView::InvalidateOneWin(OutputDevice& rDevice, const tools::Rectangle& rRect) +{ + // do not erase background, that causes flicker (!) + rDevice.GetOwnerWindow()->Invalidate(rRect, InvalidateFlags::NoErase); +} + +void SdrPaintView::LeaveOneGroup() +{ + if(mpPageView) + { + mpPageView->LeaveOneGroup(); + } +} + +void SdrPaintView::LeaveAllGroup() +{ + if(mpPageView) + { + mpPageView->LeaveAllGroup(); + } +} + +bool SdrPaintView::IsGroupEntered() const +{ + if(mpPageView) + { + return (mpPageView->GetEnteredLevel() != 0); + } + + return false; +} + +void SdrPaintView::SetNotPersistDefaultAttr(const SfxItemSet& rAttr) +{ + // bReplaceAll has no effect here at all. + bool bMeasure= dynamic_cast(this) != nullptr && static_cast(this)->IsMeasureTool(); + + if (const SdrLayerIdItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERID)) + { + SdrLayerID nLayerId = pPoolItem->GetValue(); + const SdrLayer* pLayer = GetModel().GetLayerAdmin().GetLayerPerID(nLayerId); + if (pLayer!=nullptr) { + if (bMeasure) maMeasureLayer=pLayer->GetName(); + else maActualLayer=pLayer->GetName(); + } + } + if (const SdrLayerNameItem *pPoolItem = rAttr.GetItemIfSet(SDRATTR_LAYERNAME)) + { + if (bMeasure) maMeasureLayer = pPoolItem->GetValue(); + else maActualLayer = pPoolItem->GetValue(); + } +} + +void SdrPaintView::MergeNotPersistDefaultAttr(SfxItemSet& rAttr) const +{ + // bOnlyHardAttr has no effect here at all. + bool bMeasure= dynamic_cast(this) != nullptr && static_cast(this)->IsMeasureTool(); + const OUString& aNam = bMeasure ? maMeasureLayer : maActualLayer; + rAttr.Put(SdrLayerNameItem(aNam)); + SdrLayerID nLayer = GetModel().GetLayerAdmin().GetLayerID(aNam); + if (nLayer!=SDRLAYER_NOTFOUND) { + rAttr.Put(SdrLayerIdItem(nLayer)); + } +} + +void SdrPaintView::SetDefaultAttr(const SfxItemSet& rAttr, bool bReplaceAll) +{ +#ifdef DBG_UTIL + { + bool bHasEEFeatureItems=false; + SfxItemIter aIter(rAttr); + for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem; + pItem = aIter.NextItem()) + { + if (!IsInvalidItem(pItem)) { + sal_uInt16 nW=pItem->Which(); + if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true; + } + } + + if(bHasEEFeatureItems) + { + std::unique_ptr xInfoBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Info, VclButtonsType::Ok, + "SdrPaintView::SetDefaultAttr(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents.")); + xInfoBox->run(); + } + } +#endif + if (bReplaceAll) maDefaultAttr.Set(rAttr); + else maDefaultAttr.Put(rAttr,false); // if FALSE, regard InvalidItems as "holes," not as Default + SetNotPersistDefaultAttr(rAttr); +} + +void SdrPaintView::SetDefaultStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + if (mpDefaultStyleSheet) + EndListening(*mpDefaultStyleSheet); + mpDefaultStyleSheet=pStyleSheet; + if (mpDefaultStyleSheet) + StartListening(*mpDefaultStyleSheet); + + if (pStyleSheet!=nullptr && !bDontRemoveHardAttr) { + SfxWhichIter aIter(pStyleSheet->GetItemSet()); + sal_uInt16 nWhich=aIter.FirstWhich(); + while (nWhich!=0) { + if (aIter.GetItemState()==SfxItemState::SET) { + maDefaultAttr.ClearItem(nWhich); + } + nWhich=aIter.NextWhich(); + } + } +} + +void SdrPaintView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const +{ + if(bOnlyHardAttr || !mpDefaultStyleSheet) + { + rTargetSet.Put(maDefaultAttr, false); + } + else + { + // else merge with DefStyleSheet + rTargetSet.Put(mpDefaultStyleSheet->GetItemSet(), false); + rTargetSet.Put(maDefaultAttr, false); + } + MergeNotPersistDefaultAttr(rTargetSet); +} + +void SdrPaintView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll) +{ + SetDefaultAttr(rSet,bReplaceAll); +} + +SfxStyleSheet* SdrPaintView::GetStyleSheet() const +{ + return mpDefaultStyleSheet; +} + +void SdrPaintView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr) +{ + SetDefaultStyleSheet(pStyleSheet,bDontRemoveHardAttr); +} + +void SdrPaintView::MakeVisible(const tools::Rectangle& rRect, vcl::Window& rWin) +{ + // TODO: handle when the text cursor goes out of the chart area + // However this hack avoids that the cursor gets misplaced wrt the text. + if (comphelper::LibreOfficeKit::isActive() && rWin.IsChart()) + { + return; + } + + MapMode aMap(rWin.GetMapMode()); + Size aActualSize(rWin.GetOutDev()->GetOutputSize()); + + if( aActualSize.IsEmpty() ) + return; + + Size aNewSize(rRect.GetSize()); + bool bNewScale=false; + bool bNeedMoreX=aNewSize.Width()>aActualSize.Width(); + bool bNeedMoreY=aNewSize.Height()>aActualSize.Height(); + if (bNeedMoreX || bNeedMoreY) + { + bNewScale=true; + // set new MapMode (Size+Org) and invalidate everything + Fraction aXFact(aNewSize.Width(),aActualSize.Width()); + Fraction aYFact(aNewSize.Height(),aActualSize.Height()); + if (aYFact>aXFact) aXFact=aYFact; + aXFact*=aMap.GetScaleX(); + aXFact.ReduceInaccurate(10); // to avoid runovers and BigInt mapping + aMap.SetScaleX(aXFact); + aMap.SetScaleY(aYFact); + rWin.SetMapMode(aMap); + aActualSize=rWin.GetOutDev()->GetOutputSize(); + } + Point aOrg(aMap.GetOrigin()); + tools::Long dx=0,dy=0; + tools::Long l=-aOrg.X(); + tools::Long r=-aOrg.X()+aActualSize.Width()-1; + tools::Long o=-aOrg.Y(); + tools::Long u=-aOrg.Y()+aActualSize.Height()-1; + if (l>rRect.Left()) dx=rRect.Left()-l; + else if (rrRect.Top()) dy=rRect.Top()-o; + else if (uPageWindowCount(); b++) + { + SdrPageWindow& rPageWindow = *(mpPageView->GetPageWindow(b)); + sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact(); + sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator(); + + if(rAnimator.IsPaused() != bSet) + { + rAnimator.SetPaused(bSet); + } + } +} + +void SdrPaintView::SetAnimationMode( const SdrAnimationMode eMode ) +{ + meAnimationMode = eMode; +} + +void SdrPaintView::VisAreaChanged(const OutputDevice* pOut) +{ + if(!mpPageView) + return; + + if (pOut) + { + SdrPageWindow* pWindow = mpPageView->FindPageWindow(*const_cast(pOut)); + + if(pWindow) + { + VisAreaChanged(); + } + } + else + { + VisAreaChanged(); + } +} + +void SdrPaintView::VisAreaChanged() +{ + // notify SfxListener + Broadcast(SvxViewChangedHint()); +} + + +void SdrPaintView::onChangeColorConfig() +{ + maGridColor = maColorConfig.GetColorValue( svtools::DRAWGRID ).nColor; +} + + +// Set background color for svx at SdrPageViews +void SdrPaintView::SetApplicationBackgroundColor(Color aBackgroundColor) +{ + if(mpPageView) + { + mpPageView->SetApplicationBackgroundColor(aBackgroundColor); + } +} + +// Set document color for svx at SdrPageViews +void SdrPaintView::SetApplicationDocumentColor(Color aDocumentColor) +{ + if(mpPageView) + { + mpPageView->SetApplicationDocumentColor(aDocumentColor); + } +} + +bool SdrPaintView::IsBufferedOutputAllowed() const +{ + return (mbBufferedOutputAllowed && SvtOptionsDrawinglayer::IsPaintBuffer()); +} + +void SdrPaintView::SetBufferedOutputAllowed(bool bNew) +{ + if(bNew != mbBufferedOutputAllowed) + { + mbBufferedOutputAllowed = bNew; + } +} + +bool SdrPaintView::IsBufferedOverlayAllowed() const +{ + return (mbBufferedOverlayAllowed && SvtOptionsDrawinglayer::IsOverlayBuffer()); +} + +void SdrPaintView::SetBufferedOverlayAllowed(bool bNew) +{ + if(bNew != mbBufferedOverlayAllowed) + { + mbBufferedOverlayAllowed = bNew; + } +} + + +void SdrPaintView::SetPageDecorationAllowed(bool bNew) +{ + if(bNew != mbPageDecorationAllowed) + { + mbPageDecorationAllowed = bNew; + } +} + +void SdrPaintView::SetMasterPageVisualizationAllowed(bool bNew) +{ + if(bNew != mbMasterPageVisualizationAllowed) + { + mbMasterPageVisualizationAllowed = bNew; + } +} + +// #i38135# Sets the timer for Object animations and restarts. +void SdrPaintView::SetAnimationTimer(sal_uInt32 nTime) +{ + if(mpPageView) + { + // first, reset all timers at all windows to 0L + for(sal_uInt32 a(0); a < mpPageView->PageWindowCount(); a++) + { + SdrPageWindow& rPageWindow = *mpPageView->GetPageWindow(a); + sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact(); + sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator(); + rAnimator.SetTime(nTime); + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdpoev.cxx b/svx/source/svdraw/svdpoev.cxx new file mode 100644 index 0000000000..1cfca1ab94 --- /dev/null +++ b/svx/source/svdraw/svdpoev.cxx @@ -0,0 +1,647 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace sdr; + + +void SdrPolyEditView::ImpResetPolyPossibilityFlags() +{ + eMarkedPointsSmooth=SdrPathSmoothKind::DontCare; + eMarkedSegmentsKind=SdrPathSegmentKind::DontCare; + bSetMarkedPointsSmoothPossible=false; + bSetMarkedSegmentsKindPossible=false; +} + +SdrPolyEditView::SdrPolyEditView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: SdrEditView(rSdrModel, pOut) +{ + ImpResetPolyPossibilityFlags(); +} + +SdrPolyEditView::~SdrPolyEditView() +{ +} + +void SdrPolyEditView::ImpCheckPolyPossibilities() +{ + ImpResetPolyPossibilityFlags(); + const size_t nMarkCount(GetMarkedObjectCount()); + + if(!nMarkCount || ImpIsFrameHandles()) + return; + + bool b1stSmooth(true); + bool b1stSegm(true); + bool bCurve(false); + bool bSmoothFuz(false); + bool bSegmFuz(false); + basegfx::B2VectorContinuity eSmooth = basegfx::B2VectorContinuity::NONE; + + for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum) + { + SdrMark* pM = GetSdrMarkByIndex(nMarkNum); + CheckPolyPossibilitiesHelper( pM, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth ); + } +} + +void SdrPolyEditView::CheckPolyPossibilitiesHelper( SdrMark* pM, bool& b1stSmooth, bool& b1stSegm, bool& bCurve, bool& bSmoothFuz, bool& bSegmFuz, basegfx::B2VectorContinuity& eSmooth ) +{ + SdrObject* pObj = pM->GetMarkedSdrObj(); + SdrPathObj* pPath = dynamic_cast( pObj ); + + if (!pPath) + return; + + SdrUShortCont& rPts = pM->GetMarkedPoints(); + if (rPts.empty()) + return; + + const bool bClosed(pPath->IsClosed()); + bSetMarkedPointsSmoothPossible = true; + + if (bClosed) + { + bSetMarkedSegmentsKindPossible = true; + } + + for (const auto& rPt : rPts) + { + sal_uInt32 nNum(rPt); + sal_uInt32 nPolyNum, nPntNum; + + if(PolyPolygonEditor::GetRelativePolyPoint(pPath->GetPathPoly(), nNum, nPolyNum, nPntNum)) + { + const basegfx::B2DPolygon aLocalPolygon(pPath->GetPathPoly().getB2DPolygon(nPolyNum)); + bool bCanSegment(bClosed || nPntNum < aLocalPolygon.count() - 1); + + if(!bSetMarkedSegmentsKindPossible && bCanSegment) + { + bSetMarkedSegmentsKindPossible = true; + } + + if(!bSmoothFuz) + { + if (b1stSmooth) + { + b1stSmooth = false; + eSmooth = basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum); + } + else + { + bSmoothFuz = (eSmooth != basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum)); + } + } + + if(!bSegmFuz && bCanSegment) + { + bool bCrv(aLocalPolygon.isNextControlPointUsed(nPntNum)); + + if(b1stSegm) + { + b1stSegm = false; + bCurve = bCrv; + } + else + { + bSegmFuz = (bCrv != bCurve); + } + } + } + } + + if(!b1stSmooth && !bSmoothFuz) + { + if(basegfx::B2VectorContinuity::NONE == eSmooth) + { + eMarkedPointsSmooth = SdrPathSmoothKind::Angular; + } + + if(basegfx::B2VectorContinuity::C1 == eSmooth) + { + eMarkedPointsSmooth = SdrPathSmoothKind::Asymmetric; + } + + if(basegfx::B2VectorContinuity::C2 == eSmooth) + { + eMarkedPointsSmooth = SdrPathSmoothKind::Symmetric; + } + } + + if(!b1stSegm && !bSegmFuz) + { + eMarkedSegmentsKind = bCurve ? SdrPathSegmentKind::Curve : SdrPathSegmentKind::Line; + } +} + +void SdrPolyEditView::SetMarkedPointsSmooth(SdrPathSmoothKind eKind) +{ + basegfx::B2VectorContinuity eFlags; + + if(SdrPathSmoothKind::Angular == eKind) + { + eFlags = basegfx::B2VectorContinuity::NONE; + } + else if(SdrPathSmoothKind::Asymmetric == eKind) + { + eFlags = basegfx::B2VectorContinuity::C1; + } + else if(SdrPathSmoothKind::Symmetric == eKind) + { + eFlags = basegfx::B2VectorContinuity::C2; + } + else + { + return; + } + + if(!HasMarkedPoints()) + return; + + SortMarkedObjects(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditSetPointsSmooth), GetDescriptionOfMarkedPoints()); + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t nMarkNum(nMarkCount); nMarkNum > 0;) + { + --nMarkNum; + SdrMark* pM = GetSdrMarkByIndex(nMarkNum); + SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); + if (!pPath) + continue; + + SdrUShortCont& rPts = pM->GetMarkedPoints(); + PolyPolygonEditor aEditor(pPath->GetPathPoly()); + if (aEditor.SetPointsSmooth(eFlags, rPts)) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); + pPath->SetPathPoly(aEditor.GetPolyPolygon()); + } + } + + if( bUndo ) + EndUndo(); +} + +void SdrPolyEditView::SetMarkedSegmentsKind(SdrPathSegmentKind eKind) +{ + if(!HasMarkedPoints()) + return; + + SortMarkedObjects(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditSetSegmentsKind), GetDescriptionOfMarkedPoints()); + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t nMarkNum=nMarkCount; nMarkNum > 0;) + { + --nMarkNum; + SdrMark* pM = GetSdrMarkByIndex(nMarkNum); + SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); + if (!pPath) + continue; + SdrUShortCont& rPts = pM->GetMarkedPoints(); + PolyPolygonEditor aEditor( pPath->GetPathPoly()); + if (aEditor.SetSegmentsKind(eKind, rPts)) + { + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); + pPath->SetPathPoly(aEditor.GetPolyPolygon()); + } + } + + if( bUndo ) + EndUndo(); +} + +bool SdrPolyEditView::IsSetMarkedPointsSmoothPossible() const +{ + ForcePossibilities(); + return bSetMarkedPointsSmoothPossible; +} + +SdrPathSmoothKind SdrPolyEditView::GetMarkedPointsSmooth() const +{ + ForcePossibilities(); + return eMarkedPointsSmooth; +} + +bool SdrPolyEditView::IsSetMarkedSegmentsKindPossible() const +{ + ForcePossibilities(); + return bSetMarkedSegmentsKindPossible; +} + +SdrPathSegmentKind SdrPolyEditView::GetMarkedSegmentsKind() const +{ + ForcePossibilities(); + return eMarkedSegmentsKind; +} + +bool SdrPolyEditView::IsDeleteMarkedPointsPossible() const +{ + return HasMarkedPoints(); +} + +void SdrPolyEditView::DeleteMarkedPoints() +{ + if (!HasMarkedPoints()) + return; + + BrkAction(); + SortMarkedObjects(); + const size_t nMarkCount=GetMarkedObjectCount(); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + // Description + BegUndo(SvxResId(STR_EditDelete),GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Delete); + } + + for (size_t nMarkNum=nMarkCount; nMarkNum>0;) + { + --nMarkNum; + SdrMark* pM=GetSdrMarkByIndex(nMarkNum); + SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); + if (!pPath) + continue; + + SdrUShortCont& rPts = pM->GetMarkedPoints(); + PolyPolygonEditor aEditor( pPath->GetPathPoly()); + if (aEditor.DeletePoints(rPts)) + { + if( aEditor.GetPolyPolygon().count() ) + { + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); + pPath->SetPathPoly( aEditor.GetPolyPolygon() ); + } + else + { + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pPath)); + pM->GetPageView()->GetObjList()->RemoveObject(pPath->GetOrdNum()); + } + } + } + + if( bUndo ) + EndUndo(); + UnmarkAllPoints(); + MarkListHasChanged(); +} + +void SdrPolyEditView::RipUpAtMarkedPoints() +{ + if(!HasMarkedPoints()) + return; + + SortMarkedObjects(); + const size_t nMarkCount(GetMarkedObjectCount()); + + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + BegUndo(SvxResId(STR_EditRipUp), GetDescriptionOfMarkedPoints()); + + for(size_t nMarkNum = nMarkCount; nMarkNum > 0;) + { + --nMarkNum; + SdrMark* pM = GetSdrMarkByIndex(nMarkNum); + SdrPathObj* pObj = dynamic_cast( pM->GetMarkedSdrObj() ); + if (!pObj) + continue; + + SdrUShortCont& rPts = pM->GetMarkedPoints(); + + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + bool bCorrectionFlag(false); + sal_uInt32 nMax(pObj->GetHdlCount()); + + for(SdrUShortCont::const_reverse_iterator it = rPts.rbegin(); it != rPts.rend(); ++it) + { + sal_uInt32 nNewPt0Idx(0); + rtl::Reference pNewObj = pObj->RipPoint(*it, nNewPt0Idx); + + if(pNewObj) + { + pM->GetPageView()->GetObjList()->InsertObject(pNewObj.get(), pObj->GetOrdNum() + 1); + if (bUndo) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pNewObj)); + MarkObj(pNewObj.get(), pM->GetPageView(), false, true); + } + + if(nNewPt0Idx) + { + // correction necessary? + DBG_ASSERT(!bCorrectionFlag,"Multiple index corrections at SdrPolyEditView::RipUp()."); + if(!bCorrectionFlag) + { + bCorrectionFlag = true; + + SdrUShortCont aReplaceSet; + for(const auto& rPt : rPts) + { + sal_uInt32 nPntNum(rPt); + nPntNum += nNewPt0Idx; + + if(nPntNum >= nMax) + { + nPntNum -= nMax; + } + + aReplaceSet.insert( static_cast(nPntNum) ); + } + rPts.swap(aReplaceSet); + + it = rPts.rbegin(); + } + } + } + } + + UnmarkAllPoints(); + if( bUndo ) + EndUndo(); + MarkListHasChanged(); +} + +bool SdrPolyEditView::IsRipUpAtMarkedPointsPossible() const +{ + bool bRetval(false); + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t a = 0; a < nMarkCount; ++a) + { + const SdrMark* pMark = GetSdrMarkByIndex(a); + const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); + + if (!pMarkedPathObject) + continue; + + const SdrUShortCont& rSelectedPoints = pMark->GetMarkedPoints(); + if (rSelectedPoints.empty()) + continue; + + const basegfx::B2DPolyPolygon& rPathPolyPolygon = pMarkedPathObject->GetPathPoly(); + + if(1 == rPathPolyPolygon.count()) + { + // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions + // are different and methods need to be changed thoroughly with interaction rework + const tools::Polygon aPathPolygon(rPathPolyPolygon.getB2DPolygon(0)); + const sal_uInt16 nPointCount(aPathPolygon.GetSize()); + + if(nPointCount >= 3) + { + bRetval = pMarkedPathObject->IsClosedObj() // #i76617# + || std::any_of(rSelectedPoints.begin(), rSelectedPoints.end(), + [nPointCount](const sal_uInt16 nMarkedPointNum) { + return nMarkedPointNum > 0 && nMarkedPointNum < nPointCount - 1; + }); + } + } + } + + return bRetval; +} + +bool SdrPolyEditView::IsOpenCloseMarkedObjectsPossible() const +{ + bool bRetval(false); + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t a = 0; a < nMarkCount; ++a) + { + const SdrMark* pMark = GetSdrMarkByIndex(a); + const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); + + if(pMarkedPathObject) + { + // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions + // are different and methods need to be changed thoroughly with interaction rework + const tools::PolyPolygon aPathPolyPolygon(pMarkedPathObject->GetPathPoly()); + const sal_uInt16 nPolygonCount(aPathPolyPolygon.Count()); + + for(sal_uInt16 b(0); !bRetval && b < nPolygonCount; b++) + { + const tools::Polygon& rPathPolygon = aPathPolyPolygon[b]; + const sal_uInt16 nPointCount(rPathPolygon.GetSize()); + + bRetval = (nPointCount >= 3); + } + } + } + + return bRetval; +} + +SdrObjClosedKind SdrPolyEditView::GetMarkedObjectsClosedState() const +{ + bool bOpen(false); + bool bClosed(false); + const size_t nMarkCount(GetMarkedObjectCount()); + + for(size_t a = 0; !(bOpen && bClosed) && a < nMarkCount; ++a) + { + const SdrMark* pMark = GetSdrMarkByIndex(a); + const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); + + if(pMarkedPathObject) + { + if(pMarkedPathObject->IsClosedObj()) + { + bClosed = true; + } + else + { + bOpen = true; + } + } + } + + if(bOpen && bClosed) + { + return SdrObjClosedKind::DontCare; + } + else if(bOpen) + { + return SdrObjClosedKind::Open; + } + else + { + return SdrObjClosedKind::Closed; + } +} + +void SdrPolyEditView::ImpTransformMarkedPoints(PPolyTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4) +{ + const bool bUndo = IsUndoEnabled(); + + const size_t nMarkCount=GetMarkedObjectCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrPathObj* pPath=dynamic_cast( pObj ); + if (!pPath) + continue; + + const SdrUShortCont& rPts = pM->GetMarkedPoints(); + if (rPts.empty()) + continue; + + if( bUndo ) + AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); + + basegfx::B2DPolyPolygon aXPP(pPath->GetPathPoly()); + + for (const auto& rPt : rPts) + { + sal_uInt32 nPt = rPt; + sal_uInt32 nPolyNum, nPointNum; + + if(PolyPolygonEditor::GetRelativePolyPoint(aXPP, nPt, nPolyNum, nPointNum)) + { + //#i83671# used nLocalPointNum (which was the polygon point count) + // instead of the point index (nPointNum). This of course led + // to a wrong point access to the B2DPolygon. + basegfx::B2DPolygon aNewXP(aXPP.getB2DPolygon(nPolyNum)); + Point aPos, aC1, aC2; + bool bC1(false); + bool bC2(false); + + const basegfx::B2DPoint aB2DPos(aNewXP.getB2DPoint(nPointNum)); + aPos = Point(FRound(aB2DPos.getX()), FRound(aB2DPos.getY())); + + if(aNewXP.isPrevControlPointUsed(nPointNum)) + { + const basegfx::B2DPoint aB2DC1(aNewXP.getPrevControlPoint(nPointNum)); + aC1 = Point(FRound(aB2DC1.getX()), FRound(aB2DC1.getY())); + bC1 = true; + } + + if(aNewXP.isNextControlPointUsed(nPointNum)) + { + const basegfx::B2DPoint aB2DC2(aNewXP.getNextControlPoint(nPointNum)); + aC2 = Point(FRound(aB2DC2.getX()), FRound(aB2DC2.getY())); + bC2 = true; + } + + (*pTrFunc)(aPos,&aC1,&aC2,p1,p2,p3,p4); + aNewXP.setB2DPoint(nPointNum, basegfx::B2DPoint(aPos.X(), aPos.Y())); + + if (bC1) + { + aNewXP.setPrevControlPoint(nPointNum, basegfx::B2DPoint(aC1.X(), aC1.Y())); + } + + if (bC2) + { + aNewXP.setNextControlPoint(nPointNum, basegfx::B2DPoint(aC2.X(), aC2.Y())); + } + + aXPP.setB2DPolygon(nPolyNum, aNewXP); + } + } + + pPath->SetPathPoly(aXPP); + } +} + + +static void ImpMove(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/) +{ + rPt.Move(*static_cast(p1)); + if (pC1!=nullptr) pC1->Move(*static_cast(p1)); + if (pC2!=nullptr) pC2->Move(*static_cast(p1)); +} + +void SdrPolyEditView::MoveMarkedPoints(const Size& rSiz) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditMove)); + BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Move); + ImpTransformMarkedPoints(ImpMove,&rSiz); + EndUndo(); + AdjustMarkHdl(); +} + +static void ImpResize(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* p2, const void* p3, const void* /*p4*/) +{ + ResizePoint(rPt,*static_cast(p1),*static_cast(p2),*static_cast(p3)); + if (pC1!=nullptr) ResizePoint(*pC1,*static_cast(p1),*static_cast(p2),*static_cast(p3)); + if (pC2!=nullptr) ResizePoint(*pC2,*static_cast(p1),*static_cast(p2),*static_cast(p3)); +} + +void SdrPolyEditView::ResizeMarkedPoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditResize)); + BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Resize); + ImpTransformMarkedPoints(ImpResize,&rRef,&xFact,&yFact); + EndUndo(); + AdjustMarkHdl(); +} + +static void ImpRotate(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* p3, const void* p4) +{ + RotatePoint(rPt,*static_cast(p1),*static_cast(p3),*static_cast(p4)); + if (pC1!=nullptr) RotatePoint(*pC1,*static_cast(p1),*static_cast(p3),*static_cast(p4)); + if (pC2!=nullptr) RotatePoint(*pC2,*static_cast(p1),*static_cast(p3),*static_cast(p4)); +} + +void SdrPolyEditView::RotateMarkedPoints(const Point& rRef, Degree100 nAngle) +{ + ForceUndirtyMrkPnt(); + OUString aStr(SvxResId(STR_EditResize)); + BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Rotate); + double nSin = sin(toRadians(nAngle)); + double nCos = cos(toRadians(nAngle)); + ImpTransformMarkedPoints(ImpRotate,&rRef,&nAngle,&nSin,&nCos); + EndUndo(); + AdjustMarkHdl(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdsnpv.cxx b/svx/source/svdraw/svdsnpv.cxx new file mode 100644 index 0000000000..bcef8b3c3e --- /dev/null +++ b/svx/source/svdraw/svdsnpv.cxx @@ -0,0 +1,633 @@ +/* -*- 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 +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +class ImplPageOriginOverlay +{ + // The OverlayObjects + sdr::overlay::OverlayObjectList maObjects; + + // The current position in logical coordinates + basegfx::B2DPoint maPosition; + +public: + ImplPageOriginOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos); + + // 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 SetPosition(const basegfx::B2DPoint& rNewPosition); +}; + +ImplPageOriginOverlay::ImplPageOriginOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos) +: maPosition(rStartPos) +{ + 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 aNew(new sdr::overlay::OverlayCrosshairStriped( + maPosition)); + xTargetOverlay->add(*aNew); + maObjects.append(std::move(aNew)); + } + } +} + +void ImplPageOriginOverlay::SetPosition(const basegfx::B2DPoint& rNewPosition) +{ + if(rNewPosition == maPosition) + return; + + // apply to OverlayObjects + for(sal_uInt32 a(0); a < maObjects.count(); a++) + { + sdr::overlay::OverlayCrosshairStriped* pCandidate = + static_cast< sdr::overlay::OverlayCrosshairStriped* >(&maObjects.getOverlayObject(a)); + + if(pCandidate) + { + pCandidate->setBasePosition(rNewPosition); + } + } + + // remember new position + maPosition = rNewPosition; +} + + +class ImplHelpLineOverlay +{ + // The OverlayObjects + sdr::overlay::OverlayObjectList maObjects; + + // The current position in logical coordinates + basegfx::B2DPoint maPosition; + + // HelpLine specific stuff + SdrPageView* mpPageView; + sal_uInt16 mnHelpLineNumber; + SdrHelpLineKind meHelpLineKind; + +public: + ImplHelpLineOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, + SdrPageView* pPageView, sal_uInt16 nHelpLineNumber, SdrHelpLineKind eKind); + + // 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 SetPosition(const basegfx::B2DPoint& rNewPosition); + + // access to HelpLine specific stuff + SdrPageView* GetPageView() const { return mpPageView; } + sal_uInt16 GetHelpLineNumber() const { return mnHelpLineNumber; } + SdrHelpLineKind GetHelpLineKind() const { return meHelpLineKind; } +}; + +ImplHelpLineOverlay::ImplHelpLineOverlay( + const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, + SdrPageView* pPageView, sal_uInt16 nHelpLineNumber, SdrHelpLineKind eKind) +: maPosition(rStartPos), + mpPageView(pPageView), + mnHelpLineNumber(nHelpLineNumber), + meHelpLineKind(eKind) +{ + 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 aNew(new sdr::overlay::OverlayHelplineStriped( + maPosition, meHelpLineKind)); + xTargetOverlay->add(*aNew); + maObjects.append(std::move(aNew)); + } + } +} + +void ImplHelpLineOverlay::SetPosition(const basegfx::B2DPoint& rNewPosition) +{ + if(rNewPosition == maPosition) + return; + + // apply to OverlayObjects + for(sal_uInt32 a(0); a < maObjects.count(); a++) + { + sdr::overlay::OverlayHelplineStriped* pCandidate = + static_cast< sdr::overlay::OverlayHelplineStriped* >(&maObjects.getOverlayObject(a)); + + if(pCandidate) + { + pCandidate->setBasePosition(rNewPosition); + } + } + + // remember new position + maPosition = rNewPosition; +} + +SdrSnapView::SdrSnapView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: SdrPaintView(rSdrModel, pOut) + ,mpPageOriginOverlay(nullptr) + ,mpHelpLineOverlay(nullptr) + ,nMagnSizPix(4) + ,nSnapAngle(1500) + ,nEliminatePolyPointLimitAngle(0) + ,eCrookMode(SdrCrookMode::Rotate) + ,bSnapEnab(true) + ,bGridSnap(true) + ,bBordSnap(true) + ,bHlplSnap(true) + ,bOFrmSnap(true) + ,bOPntSnap(false) + ,bOConSnap(true) + ,bMoveSnapOnlyTopLeft(false) + ,bOrtho(false) + ,bBigOrtho(true) + ,bAngleSnapEnab(false) + ,bMoveOnlyDragging(false) + ,bSlantButShear(false) + ,bCrookNoContortion(false) + ,bEliminatePolyPoints(false) +{ +} + +SdrSnapView::~SdrSnapView() +{ + BrkSetPageOrg(); + BrkDragHelpLine(); +} + + +bool SdrSnapView::IsAction() const +{ + return IsSetPageOrg() || IsDragHelpLine() || SdrPaintView::IsAction(); +} + +void SdrSnapView::MovAction(const Point& rPnt) +{ + SdrPaintView::MovAction(rPnt); + if (IsSetPageOrg()) { + MovSetPageOrg(rPnt); + } + if (IsDragHelpLine()) { + MovDragHelpLine(rPnt); + } +} + +void SdrSnapView::EndAction() +{ + if (IsSetPageOrg()) { + EndSetPageOrg(); + } + if (IsDragHelpLine()) { + EndDragHelpLine(); + } + SdrPaintView::EndAction(); +} + +void SdrSnapView::BckAction() +{ + BrkSetPageOrg(); + BrkDragHelpLine(); + SdrPaintView::BckAction(); +} + +void SdrSnapView::BrkAction() +{ + BrkSetPageOrg(); + BrkDragHelpLine(); + SdrPaintView::BrkAction(); +} + +void SdrSnapView::TakeActionRect(tools::Rectangle& rRect) const +{ + if (IsSetPageOrg() || IsDragHelpLine()) { + rRect=tools::Rectangle(maDragStat.GetNow(),maDragStat.GetNow()); + } else { + SdrPaintView::TakeActionRect(rRect); + } +} + + +Point SdrSnapView::GetSnapPos(const Point& rPnt, const SdrPageView* pPV) const +{ + Point aPt(rPnt); + SnapPos(aPt,pPV); + return aPt; +} + +#define NOT_SNAPPED 0x7FFFFFFF +SdrSnap SdrSnapView::SnapPos(Point& rPnt, const SdrPageView* pPV) const +{ + if (!bSnapEnab) return SdrSnap::NOTSNAPPED; + tools::Long x=rPnt.X(); + tools::Long y=rPnt.Y(); + if (pPV==nullptr) { + pPV=GetSdrPageView(); + if (pPV==nullptr) return SdrSnap::NOTSNAPPED; + } + + tools::Long dx=NOT_SNAPPED; + tools::Long dy=NOT_SNAPPED; + tools::Long dx1,dy1; + tools::Long mx=aMagnSiz.Width(); + tools::Long my=aMagnSiz.Height(); + if (mbHlplVisible && bHlplSnap && !IsDragHelpLine()) + { + const SdrHelpLineList& rHLL=pPV->GetHelpLines(); + sal_uInt16 nCount=rHLL.GetCount(); + for (sal_uInt16 i=nCount; i>0;) { + i--; + const SdrHelpLine& rHL=rHLL[i]; + const Point& rPos=rHL.GetPos(); + switch (rHL.GetKind()) { + case SdrHelpLineKind::Vertical: { + tools::Long a=x-rPos.X(); + if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)GetPage(); + tools::Long xs=pPage->GetWidth(); + tools::Long ys=pPage->GetHeight(); + tools::Long lft=pPage->GetLeftBorder(); + tools::Long rgt=pPage->GetRightBorder(); + tools::Long upp=pPage->GetUpperBorder(); + tools::Long lwr=pPage->GetLowerBorder(); + tools::Long a; + a=x- lft ; if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)GetPage(),SdrIterMode::DeepNoGroups,true); + + while (aIter.IsMore() && (nMaxPointSnapCount>0 || nMaxFrameSnapCount>0)) { + SdrObject* pO=aIter.Next(); + tools::Rectangle aRect(pO->GetCurrentBoundRect()); + aRect.AdjustLeft( -mx ); + aRect.AdjustRight(mx ); + aRect.AdjustTop( -my ); + aRect.AdjustBottom(my ); + if (aRect.Contains(rPnt)) { + if (bOPntSnap && nMaxPointSnapCount>0) + { + sal_uInt32 nCount(pO->GetSnapPointCount()); + for (sal_uInt32 i(0); i < nCount && nMaxPointSnapCount > 0; i++) + { + Point aP(pO->GetSnapPoint(i)); + dx1=x-aP.X(); + dy1=y-aP.Y(); + if (std::abs(dx1)<=mx && std::abs(dy1)<=my && std::abs(dx1)0) { + tools::Rectangle aLog(pO->GetSnapRect()); + tools::Rectangle aR1(aLog); + aR1.AdjustLeft( -mx ); + aR1.AdjustRight(mx ); + aR1.AdjustTop( -my ); + aR1.AdjustBottom(my ); + if (aR1.Contains(rPnt)) { + if (std::abs(x-aLog.Left ())<=mx) { dx1=-(x-aLog.Left ()); if (std::abs(dx1)(x); + + // round instead of trunc + if(fx - static_cast(pPV->GetPageOrigin().X()) >= 0.0) + fx += fSnapWidth / 2.0; + else + fx -= fSnapWidth / 2.0; + + x = static_cast((fx - static_cast(pPV->GetPageOrigin().X())) / fSnapWidth); + x = static_cast(static_cast(x) * fSnapWidth + static_cast(pPV->GetPageOrigin().X())); + dx = 0; + } + fSnapWidth = double(aSnapWdtY); + if(dy == NOT_SNAPPED && fSnapWidth) + { + double fy = static_cast(y); + + // round instead of trunc + if(fy - static_cast(pPV->GetPageOrigin().Y()) >= 0.0) + fy += fSnapWidth / 2.0; + else + fy -= fSnapWidth / 2.0; + + y = static_cast((fy - static_cast(pPV->GetPageOrigin().Y())) / fSnapWidth); + y = static_cast(static_cast(y) * fSnapWidth + static_cast(pPV->GetPageOrigin().Y())); + dy = 0; + } + } + SdrSnap bRet=SdrSnap::NOTSNAPPED; + if (dx==NOT_SNAPPED) dx=0; else bRet|=SdrSnap::XSNAPPED; + if (dy==NOT_SNAPPED) dy=0; else bRet|=SdrSnap::YSNAPPED; + rPnt.setX(x+dx ); + rPnt.setY(y+dy ); + return bRet; +} + +void SdrSnapView::CheckSnap(const Point& rPt, tools::Long& nBestXSnap, tools::Long& nBestYSnap, bool& bXSnapped, bool& bYSnapped) const +{ + Point aPt(rPt); + SdrSnap nRet=SnapPos(aPt,nullptr); + aPt-=rPt; + if (nRet & SdrSnap::XSNAPPED) { + if (bXSnapped) { + if (std::abs(aPt.X())SetPosition(aNewPos); + } +} + +void SdrSnapView::EndSetPageOrg() +{ + if(!IsSetPageOrg()) + return; + + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + Point aPnt(maDragStat.GetNow()); + pPV->SetPageOrigin(aPnt); + } + + // cleanup + BrkSetPageOrg(); +} + +void SdrSnapView::BrkSetPageOrg() +{ + if(IsSetPageOrg()) + { + DBG_ASSERT(mpPageOriginOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)"); + delete mpPageOriginOverlay; + mpPageOriginOverlay = nullptr; + } +} + + +bool SdrSnapView::PickHelpLine(const Point& rPnt, short nTol, const OutputDevice& rOut, sal_uInt16& rnHelpLineNum, SdrPageView*& rpPV) const +{ + rpPV=nullptr; + nTol=ImpGetHitTolLogic(nTol,&rOut); + SdrPageView* pPV = GetSdrPageView(); + + if(pPV) + { + Point aPnt(rPnt); + sal_uInt16 nIndex=pPV->GetHelpLines().HitTest(aPnt,sal_uInt16(nTol),rOut); + if (nIndex!=SDRHELPLINE_NOTFOUND) { + rpPV=pPV; + rnHelpLineNum=nIndex; + return true; + } + } + return false; +} + +// start HelpLine drag for new HelpLine +bool SdrSnapView::BegDragHelpLine(sal_uInt16 nHelpLineNum, SdrPageView* pPV) +{ + bool bRet(false); + + BrkAction(); + + if(pPV && nHelpLineNum < pPV->GetHelpLines().GetCount()) + { + const SdrHelpLineList& rHelpLines = pPV->GetHelpLines(); + const SdrHelpLine& rHelpLine = rHelpLines[nHelpLineNum]; + Point aHelpLinePos = rHelpLine.GetPos(); + basegfx::B2DPoint aStartPos(aHelpLinePos.X(), aHelpLinePos.Y()); + + DBG_ASSERT(nullptr == mpHelpLineOverlay, "SdrSnapView::BegDragHelpLine: There exists an ImplHelpLineOverlay (!)"); + mpHelpLineOverlay = new ImplHelpLineOverlay(*this, aStartPos, pPV, nHelpLineNum, rHelpLine.GetKind()); + + maDragStat.Reset(GetSnapPos(aHelpLinePos, pPV)); + maDragStat.SetMinMove(ImpGetMinMovLogic(-3, nullptr)); + + bRet = true; + } + + return bRet; +} + +// start HelpLine drag with existing HelpLine +void SdrSnapView::BegDragHelpLine(const Point& rPnt, SdrHelpLineKind eNewKind) +{ + BrkAction(); + + if(GetSdrPageView()) + { + DBG_ASSERT(nullptr == mpHelpLineOverlay, "SdrSnapView::BegDragHelpLine: There exists an ImplHelpLineOverlay (!)"); + basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y()); + mpHelpLineOverlay = new ImplHelpLineOverlay(*this, aStartPos, nullptr, 0, eNewKind); + maDragStat.Reset(GetSnapPos(rPnt, nullptr)); + } +} + +PointerStyle SdrSnapView::GetDraggedHelpLinePointer() const +{ + if(IsDragHelpLine()) + { + switch(mpHelpLineOverlay->GetHelpLineKind()) + { + case SdrHelpLineKind::Vertical : return PointerStyle::ESize; + case SdrHelpLineKind::Horizontal: return PointerStyle::SSize; + default : return PointerStyle::Move; + } + } + + return PointerStyle::Move; +} + +void SdrSnapView::MovDragHelpLine(const Point& rPnt) +{ + if(IsDragHelpLine() && maDragStat.CheckMinMoved(rPnt)) + { + Point aPnt(GetSnapPos(rPnt, nullptr)); + + if(aPnt != maDragStat.GetNow()) + { + maDragStat.NextMove(aPnt); + DBG_ASSERT(mpHelpLineOverlay, "SdrSnapView::MovDragHelpLine: no ImplHelpLineOverlay (!)"); + basegfx::B2DPoint aNewPos(maDragStat.GetNow().X(), maDragStat.GetNow().Y()); + mpHelpLineOverlay->SetPosition(aNewPos); + } + } +} + +bool SdrSnapView::EndDragHelpLine() +{ + bool bRet(false); + + if(IsDragHelpLine()) + { + if(maDragStat.IsMinMoved()) + { + SdrPageView* pPageView = mpHelpLineOverlay->GetPageView(); + + if(pPageView) + { + // moved existing one + Point aPnt(maDragStat.GetNow()); + const SdrHelpLineList& rHelpLines = pPageView->GetHelpLines(); + SdrHelpLine aChangedHelpLine = rHelpLines[mpHelpLineOverlay->GetHelpLineNumber()]; + aChangedHelpLine.SetPos(aPnt); + pPageView->SetHelpLine(mpHelpLineOverlay->GetHelpLineNumber(), aChangedHelpLine); + + bRet = true; + } + else + { + // create new one + pPageView = GetSdrPageView(); + + if(pPageView) + { + Point aPnt(maDragStat.GetNow()); + SdrHelpLine aNewHelpLine(mpHelpLineOverlay->GetHelpLineKind(), aPnt); + pPageView->InsertHelpLine(aNewHelpLine); + + bRet = true; + } + } + } + + // cleanup + BrkDragHelpLine(); + } + + return bRet; +} + +void SdrSnapView::BrkDragHelpLine() +{ + if(IsDragHelpLine()) + { + DBG_ASSERT(mpHelpLineOverlay, "SdrSnapView::EndDragHelpLine: no ImplHelpLineOverlay (!)"); + delete mpHelpLineOverlay; + mpHelpLineOverlay = nullptr; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdtext.cxx b/svx/source/svdraw/svdtext.cxx new file mode 100644 index 0000000000..0fe4fa47d4 --- /dev/null +++ b/svx/source/svdraw/svdtext.cxx @@ -0,0 +1,132 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include + +SdrText::SdrText( SdrTextObj& rObject ) +: mrObject( rObject ) +, mbPortionInfoChecked( false ) +{ + OSL_ENSURE(&mrObject, "SdrText created without SdrTextObj (!)"); +} + +SdrText::~SdrText() +{ +} + +void SdrText::CheckPortionInfo( const SdrOutliner& rOutliner ) +{ + if(mbPortionInfoChecked) + return; + + // #i102062# no action when the Outliner is the HitTestOutliner, + // this will remove WrongList info at the OPO + if(&rOutliner == &mrObject.getSdrModelFromSdrObject().GetHitTestOutliner()) + return; + + // TODO: optimization: we could create a BigTextObject + mbPortionInfoChecked=true; + + if(mpOutlinerParaObject && rOutliner.ShouldCreateBigTextObject()) + { + // #i102062# MemoryLeak closed + mpOutlinerParaObject = rOutliner.CreateParaObject(); + } +} + +void SdrText::ReformatText() +{ + mbPortionInfoChecked=false; + mpOutlinerParaObject->ClearPortionInfo(); +} + +const SfxItemSet& SdrText::GetItemSet() const +{ + return const_cast< SdrText* >(this)->GetObjectItemSet(); +} + +void SdrText::SetOutlinerParaObject( std::optional pTextObject ) +{ + mpOutlinerParaObject = std::move(pTextObject); + mbPortionInfoChecked = false; +} + +OutlinerParaObject* SdrText::GetOutlinerParaObject() +{ + return mpOutlinerParaObject ? &*mpOutlinerParaObject : nullptr; +} + +const OutlinerParaObject* SdrText::GetOutlinerParaObject() const +{ + return mpOutlinerParaObject ? &*mpOutlinerParaObject : nullptr; +} + +/** returns the current OutlinerParaObject and removes it from this instance */ +std::optional SdrText::RemoveOutlinerParaObject() +{ + std::optional pOPO = std::move(mpOutlinerParaObject); + mbPortionInfoChecked = false; + return pOPO; +} + +void SdrText::ForceOutlinerParaObject( OutlinerMode nOutlMode ) +{ + if(mpOutlinerParaObject) + return; + + std::unique_ptr pOutliner( + SdrMakeOutliner( + nOutlMode, + mrObject.getSdrModelFromSdrObject())); + + if(pOutliner) + { + Outliner& aDrawOutliner(mrObject.getSdrModelFromSdrObject().GetDrawOutliner()); + pOutliner->SetCalcFieldValueHdl( aDrawOutliner.GetCalcFieldValueHdl() ); + pOutliner->SetStyleSheet( 0, GetStyleSheet()); + SetOutlinerParaObject( pOutliner->CreateParaObject() ); + } +} + +const SfxItemSet& SdrText::GetObjectItemSet() +{ + return mrObject.GetObjectItemSet(); +} + +SfxStyleSheet* SdrText::GetStyleSheet() const +{ + return mrObject.GetStyleSheet(); +} + +void SdrText::dumpAsXml(xmlTextWriterPtr pWriter) const +{ + (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SdrText")); + mpOutlinerParaObject->dumpAsXml(pWriter); + (void)xmlTextWriterEndElement(pWriter); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdtrans.cxx b/svx/source/svdraw/svdtrans.cxx new file mode 100644 index 0000000000..23c7495ad7 --- /dev/null +++ b/svx/source/svdraw/svdtrans.cxx @@ -0,0 +1,882 @@ +/* -*- 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 +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +void MoveXPoly(XPolygon& rPoly, const Size& S) +{ + rPoly.Move(S.Width(),S.Height()); +} + +void ResizeRect(tools::Rectangle& rRect, const Point& rRef, const Fraction& rxFact, const Fraction& ryFact) +{ + Fraction aXFact(rxFact); + Fraction aYFact(ryFact); + + if (!aXFact.IsValid()) { + SAL_WARN( "svx.svdraw", "invalid fraction xFract, using Fraction(1,1)" ); + aXFact = Fraction(1,1); + tools::Long nWdt = rRect.Right() - rRect.Left(); + if (nWdt == 0) rRect.AdjustRight( 1 ); + } + rRect.SetLeft( rRef.X() + FRound( (rRect.Left() - rRef.X()) * double(aXFact) ) ); + rRect.SetRight( rRef.X() + FRound( (rRect.Right() - rRef.X()) * double(aXFact) ) ); + + if (!aYFact.IsValid()) { + SAL_WARN( "svx.svdraw", "invalid fraction yFract, using Fraction(1,1)" ); + aYFact = Fraction(1,1); + tools::Long nHgt = rRect.Bottom() - rRect.Top(); + if (nHgt == 0) rRect.AdjustBottom( 1 ); + } + rRect.SetTop( rRef.Y() + FRound( (rRect.Top() - rRef.Y()) * double(aYFact) ) ); + rRect.SetBottom( rRef.Y() + FRound( (rRect.Bottom() - rRef.Y()) * double(aYFact) ) ); + + rRect.Normalize(); +} + + +void ResizePoly(tools::Polygon& rPoly, const Point& rRef, const Fraction& xFact, const Fraction& yFact) +{ + sal_uInt16 nCount=rPoly.GetSize(); + for (sal_uInt16 i=0; iAdjustY( -y0 ); + // resize, account for the distance from the center + pC1->setY(FRound(static_cast(pC1->Y()) /rRad.X()*(cx-pC1->X())) ); + pC1->AdjustY(cy ); + } else { + // move into the direction of the center, as a basic position for the rotation + pC1->AdjustX( -x0 ); + // resize, account for the distance from the center + tools::Long nPntRad=cy-pC1->Y(); + double nFact=static_cast(nPntRad)/static_cast(rRad.Y()); + pC1->setX(FRound(static_cast(pC1->X())*nFact) ); + pC1->AdjustX(cx ); + } + RotatePoint(*pC1,rCenter,sn,cs); + } + if (bC2) { + if (bVert) { + // move into the direction of the center, as a basic position for the rotation + pC2->AdjustY( -y0 ); + // resize, account for the distance from the center + pC2->setY(FRound(static_cast(pC2->Y()) /rRad.X()*(rCenter.X()-pC2->X())) ); + pC2->AdjustY(cy ); + } else { + // move into the direction of the center, as a basic position for the rotation + pC2->AdjustX( -x0 ); + // resize, account for the distance from the center + tools::Long nPntRad=rCenter.Y()-pC2->Y(); + double nFact=static_cast(nPntRad)/static_cast(rRad.Y()); + pC2->setX(FRound(static_cast(pC2->X())*nFact) ); + pC2->AdjustX(cx ); + } + RotatePoint(*pC2,rCenter,sn,cs); + } + rSin=sn; + rCos=cs; + return nAngle; +} + +double CrookSlantXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter, + const Point& rRad, double& rSin, double& rCos, bool bVert) +{ + bool bC1=pC1!=nullptr; + bool bC2=pC2!=nullptr; + tools::Long x0=rPnt.X(); + tools::Long y0=rPnt.Y(); + tools::Long dx1=0,dy1=0; + tools::Long dxC1=0,dyC1=0; + tools::Long dxC2=0,dyC2=0; + if (bVert) { + tools::Long nStart=rCenter.X()-rRad.X(); + dx1=rPnt.X()-nStart; + rPnt.setX(nStart ); + if (bC1) { + dxC1=pC1->X()-nStart; + pC1->setX(nStart ); + } + if (bC2) { + dxC2=pC2->X()-nStart; + pC2->setX(nStart ); + } + } else { + tools::Long nStart=rCenter.Y()-rRad.Y(); + dy1=rPnt.Y()-nStart; + rPnt.setY(nStart ); + if (bC1) { + dyC1=pC1->Y()-nStart; + pC1->setY(nStart ); + } + if (bC2) { + dyC2=pC2->Y()-nStart; + pC2->setY(nStart ); + } + } + double nAngle=GetCrookAngle(rPnt,rCenter,rRad,bVert); + double sn=sin(nAngle); + double cs=cos(nAngle); + RotatePoint(rPnt,rCenter,sn,cs); + if (bC1) { if (bVert) pC1->AdjustY( -(y0-rCenter.Y()) ); else pC1->AdjustX( -(x0-rCenter.X()) ); RotatePoint(*pC1,rCenter,sn,cs); } + if (bC2) { if (bVert) pC2->AdjustY( -(y0-rCenter.Y()) ); else pC2->AdjustX( -(x0-rCenter.X()) ); RotatePoint(*pC2,rCenter,sn,cs); } + if (bVert) { + rPnt.AdjustX(dx1 ); + if (bC1) pC1->AdjustX(dxC1 ); + if (bC2) pC2->AdjustX(dxC2 ); + } else { + rPnt.AdjustY(dy1 ); + if (bC1) pC1->AdjustY(dyC1 ); + if (bC2) pC2->AdjustY(dyC2 ); + } + rSin=sn; + rCos=cs; + return nAngle; +} + +double CrookStretchXPoint(Point& rPnt, Point* pC1, Point* pC2, const Point& rCenter, + const Point& rRad, double& rSin, double& rCos, bool bVert, + const tools::Rectangle& rRefRect) +{ + tools::Long y0=rPnt.Y(); + CrookSlantXPoint(rPnt,pC1,pC2,rCenter,rRad,rSin,rCos,bVert); + if (bVert) { + } else { + tools::Long nTop=rRefRect.Top(); + tools::Long nBtm=rRefRect.Bottom(); + tools::Long nHgt=nBtm-nTop; + tools::Long dy=rPnt.Y()-y0; + double a=static_cast(y0-nTop)/nHgt; + a*=dy; + rPnt.setY(y0+FRound(a) ); + } + return 0.0; +} + + +void CrookRotatePoly(XPolygon& rPoly, const Point& rCenter, const Point& rRad, bool bVert) +{ + double nSin,nCos; + sal_uInt16 nPointCnt=rPoly.GetPointCount(); + sal_uInt16 i=0; + while (i0) a=-9000_deg100; + else a=9000_deg100; + } else { + a = Degree100(FRound(basegfx::rad2deg<100>(atan2(static_cast(-rPnt.Y()), static_cast(rPnt.X()))))); + } + return a; +} + +Degree100 NormAngle18000(Degree100 a) +{ + while (a<-18000_deg100) a+=36000_deg100; + while (a>=18000_deg100) a-=36000_deg100; + return a; +} + +Degree100 NormAngle36000(Degree100 a) +{ + a %= 36000_deg100; + if (a < 0_deg100) + a += 36000_deg100; + return a; +} + +sal_uInt16 GetAngleSector(Degree100 nAngle) { return (NormAngle36000(nAngle) / 9000_deg100).get(); } + +tools::Long GetLen(const Point& rPnt) +{ + tools::Long x=std::abs(rPnt.X()); + tools::Long y=std::abs(rPnt.Y()); + if (x+y<0x8000) { // because 7FFF * 7FFF * 2 = 7FFE0002 + x*=x; + y*=y; + x+=y; + x=FRound(sqrt(static_cast(x))); + return x; + } else { + double nx=x; + double ny=y; + nx*=nx; + ny*=ny; + nx+=ny; + nx=sqrt(nx); + if (nx>0x7FFFFFFF) { + return 0x7FFFFFFF; // we can't go any further, for fear of an overrun! + } else { + return FRound(nx); + } + } +} + + +void GeoStat::RecalcSinCos() +{ + if (m_nRotationAngle==0_deg100) { + mfSinRotationAngle=0.0; + mfCosRotationAngle=1.0; + } else { + double a = toRadians(m_nRotationAngle); + mfSinRotationAngle=sin(a); + mfCosRotationAngle=cos(a); + } +} + +void GeoStat::RecalcTan() +{ + if (m_nShearAngle==0_deg100) { + mfTanShearAngle=0.0; + } else { + double a = toRadians(m_nShearAngle); + mfTanShearAngle=tan(a); + } +} + + +tools::Polygon Rect2Poly(const tools::Rectangle& rRect, const GeoStat& rGeo) +{ + tools::Polygon aPol(5); + aPol[0]=rRect.TopLeft(); + aPol[1]=rRect.TopRight(); + aPol[2]=rRect.BottomRight(); + aPol[3]=rRect.BottomLeft(); + aPol[4]=rRect.TopLeft(); + if (rGeo.m_nShearAngle) ShearPoly(aPol,rRect.TopLeft(),rGeo.mfTanShearAngle); + if (rGeo.m_nRotationAngle) RotatePoly(aPol,rRect.TopLeft(),rGeo.mfSinRotationAngle,rGeo.mfCosRotationAngle); + return aPol; +} + +namespace svx +{ +tools::Rectangle polygonToRectangle(const tools::Polygon& rPolygon, GeoStat& rGeo) +{ + rGeo.m_nRotationAngle = GetAngle(rPolygon[1] - rPolygon[0]); + rGeo.m_nRotationAngle = NormAngle36000(rGeo.m_nRotationAngle); + + // rotation successful + rGeo.RecalcSinCos(); + + Point aPoint1(rPolygon[1] - rPolygon[0]); + if (rGeo.m_nRotationAngle) + RotatePoint(aPoint1, Point(0,0), -rGeo.mfSinRotationAngle, rGeo.mfCosRotationAngle); // -Sin to reverse rotation + tools::Long nWidth = aPoint1.X(); + + Point aPoint0(rPolygon[0]); + Point aPoint3(rPolygon[3] - rPolygon[0]); + if (rGeo.m_nRotationAngle) + RotatePoint(aPoint3, Point(0,0), -rGeo.mfSinRotationAngle, rGeo.mfCosRotationAngle); // -Sin to reverse rotation + tools::Long nHeight = aPoint3.Y(); + + Degree100 nShearAngle = GetAngle(aPoint3); + nShearAngle -= 27000_deg100; // ShearWink is measured against a vertical line + nShearAngle = -nShearAngle; // negating, because '+' is shearing clock-wise + + bool bMirror = aPoint3.Y() < 0; + if (bMirror) + { // "exchange of points" when mirroring + nHeight = -nHeight; + nShearAngle += 18000_deg100; + aPoint0 = rPolygon[3]; + } + + nShearAngle = NormAngle18000(nShearAngle); + if (nShearAngle < -9000_deg100 || nShearAngle > 9000_deg100) + { + nShearAngle = NormAngle18000(nShearAngle + 18000_deg100); + } + + if (nShearAngle < -SDRMAXSHEAR) + nShearAngle = -SDRMAXSHEAR; // limit ShearWinkel (shear angle) to +/- 89.00 deg + + if (nShearAngle > SDRMAXSHEAR) + nShearAngle = SDRMAXSHEAR; + + rGeo.m_nShearAngle = nShearAngle; + rGeo.RecalcTan(); + + Point aRU(aPoint0); + aRU.AdjustX(nWidth); + aRU.AdjustY(nHeight); + + return tools::Rectangle(aPoint0, aRU); +} + +} // end svx + +void OrthoDistance8(const Point& rPt0, Point& rPt, bool bBigOrtho) +{ + tools::Long dx=rPt.X()-rPt0.X(); + tools::Long dy=rPt.Y()-rPt0.Y(); + tools::Long dxa=std::abs(dx); + tools::Long dya=std::abs(dy); + if (dx==0 || dy==0 || dxa==dya) return; + if (dxa>=dya*2) { rPt.setY(rPt0.Y() ); return; } + if (dya>=dxa*2) { rPt.setX(rPt0.X() ); return; } + if ((dxa=0 ? 1 : -1) ) ); + } else { + rPt.setX(rPt0.X()+(dya* (dx>=0 ? 1 : -1) ) ); + } +} + +void OrthoDistance4(const Point& rPt0, Point& rPt, bool bBigOrtho) +{ + tools::Long dx=rPt.X()-rPt0.X(); + tools::Long dy=rPt.Y()-rPt0.Y(); + tools::Long dxa=std::abs(dx); + tools::Long dya=std::abs(dy); + if ((dxa=0 ? 1 : -1) ) ); + } else { + rPt.setX(rPt0.X()+(dya* (dx>=0 ? 1 : -1) ) ); + } +} + + +tools::Long BigMulDiv(tools::Long nVal, tools::Long nMul, tools::Long nDiv) +{ + if (!nDiv) + return 0x7fffffff; + return BigInt::Scale(nVal, nMul, nDiv); +} + +static FrPair toPair(o3tl::Length eFrom, o3tl::Length eTo) +{ + const auto& [nNum, nDen] = o3tl::getConversionMulDiv(eFrom, eTo); + return FrPair(nNum, nDen); +} + +// How many eU units fit into a mm, respectively an inch? +// Or: How many mm, respectively inches, are there in an eU (and then give me the inverse) + +static FrPair GetInchOrMM(MapUnit eU) +{ + switch (eU) { + case MapUnit::Map1000thInch: return toPair(o3tl::Length::in, o3tl::Length::in1000); + case MapUnit::Map100thInch : return toPair(o3tl::Length::in, o3tl::Length::in100); + case MapUnit::Map10thInch : return toPair(o3tl::Length::in, o3tl::Length::in10); + case MapUnit::MapInch : return toPair(o3tl::Length::in, o3tl::Length::in); + case MapUnit::MapPoint : return toPair(o3tl::Length::in, o3tl::Length::pt); + case MapUnit::MapTwip : return toPair(o3tl::Length::in, o3tl::Length::twip); + case MapUnit::Map100thMM : return toPair(o3tl::Length::mm, o3tl::Length::mm100); + case MapUnit::Map10thMM : return toPair(o3tl::Length::mm, o3tl::Length::mm10); + case MapUnit::MapMM : return toPair(o3tl::Length::mm, o3tl::Length::mm); + case MapUnit::MapCM : return toPair(o3tl::Length::mm, o3tl::Length::cm); + case MapUnit::MapPixel : { + ScopedVclPtrInstance< VirtualDevice > pVD; + pVD->SetMapMode(MapMode(MapUnit::Map100thMM)); + Point aP(pVD->PixelToLogic(Point(64,64))); // 64 pixels for more accuracy + return FrPair(6400,aP.X(),6400,aP.Y()); + } + case MapUnit::MapAppFont: case MapUnit::MapSysFont: { + ScopedVclPtrInstance< VirtualDevice > pVD; + pVD->SetMapMode(MapMode(eU)); + Point aP(pVD->LogicToPixel(Point(32,32))); // 32 units for more accuracy + pVD->SetMapMode(MapMode(MapUnit::Map100thMM)); + aP=pVD->PixelToLogic(aP); + return FrPair(3200,aP.X(),3200,aP.Y()); + } + default: break; + } + return Fraction(1,1); +} + +// Calculate the factor that we need to convert units from eS to eD. +// e. g. GetMapFactor(UNIT_MM,UNIT_100TH_MM) => 100. + +FrPair GetMapFactor(MapUnit eS, MapUnit eD) +{ + if (eS==eD) return FrPair(1,1,1,1); + const auto eFrom = MapToO3tlLength(eS, o3tl::Length::invalid); + const auto eTo = MapToO3tlLength(eD, o3tl::Length::invalid); + if (eFrom != o3tl::Length::invalid && eTo != o3tl::Length::invalid) + return toPair(eFrom, eTo); + FrPair aS(GetInchOrMM(eS)); + FrPair aD(GetInchOrMM(eD)); + bool bSInch=IsInch(eS); + bool bDInch=IsInch(eD); + FrPair aRet(aD.X()/aS.X(),aD.Y()/aS.Y()); + if (bSInch && !bDInch) { aRet.X()*=Fraction(127,5); aRet.Y()*=Fraction(127,5); } + if (!bSInch && bDInch) { aRet.X()*=Fraction(5,127); aRet.Y()*=Fraction(5,127); } + return aRet; +}; + +FrPair GetMapFactor(FieldUnit eS, FieldUnit eD) +{ + if (eS==eD) return FrPair(1,1,1,1); + auto eFrom = FieldToO3tlLength(eS), eTo = FieldToO3tlLength(eD); + if (eFrom == o3tl::Length::invalid) + { + if (eTo == o3tl::Length::invalid) + return FrPair(1,1,1,1); + eFrom = IsInch(eD) ? o3tl::Length::in : o3tl::Length::mm; + } + else if (eTo == o3tl::Length::invalid) + eTo = IsInch(eS) ? o3tl::Length::in : o3tl::Length::mm; + return toPair(eFrom, eTo); +}; + +void SdrFormatter::Undirty() +{ + const o3tl::Length eFrom = MapToO3tlLength(m_eSrcMU, o3tl::Length::invalid); + const o3tl::Length eTo = MapToO3tlLength(m_eDstMU, o3tl::Length::invalid); + if (eFrom != o3tl::Length::invalid && eTo != o3tl::Length::invalid) + { + const auto& [mul, div] = o3tl::getConversionMulDiv(eFrom, eTo); + sal_Int64 nMul = mul; + sal_Int64 nDiv = div; + short nComma = 0; + + // shorten trailing zeros for dividend + while (0 == (nMul % 10)) + { + nComma--; + nMul /= 10; + } + + // shorten trailing zeros for divisor + while (0 == (nDiv % 10)) + { + nComma++; + nDiv /= 10; + } + m_nMul = nMul; + m_nDiv = nDiv; + m_nComma = nComma; + } + else + { + m_nMul = m_nDiv = 1; + m_nComma = 0; + } + m_bDirty=false; +} + + +OUString SdrFormatter::GetStr(tools::Long nVal) const +{ + static constexpr OUString aNullCode(u"0"_ustr); + + if(!nVal) + { + return aNullCode; + } + + // we may lose some decimal places here, because of MulDiv instead of Real + bool bNeg(nVal < 0); + SvtSysLocale aSysLoc; + const LocaleDataWrapper& rLoc = aSysLoc.GetLocaleData(); + + if (m_bDirty) + const_cast(this)->Undirty(); + + sal_Int16 nC(m_nComma); + + if(bNeg) + nVal = -nVal; + + while(nC <= -3) + { + nVal *= 1000; + nC += 3; + } + + while(nC <= -1) + { + nVal *= 10; + nC++; + } + + if(m_nMul != m_nDiv) + nVal = BigMulDiv(nVal, m_nMul, m_nDiv); + + OUStringBuffer aStr = OUString::number(nVal); + + if(nC > 0 && aStr.getLength() <= nC ) + { + // decimal separator necessary + sal_Int32 nCount(nC - aStr.getLength()); + + if(nCount >= 0 && LocaleDataWrapper::isNumLeadingZero()) + nCount++; + + for(sal_Int32 i=0; i 0) + { + // TODO: we should round here + aStr.remove(aStr.getLength() - nWeg, nWeg); + nC = nNumDigits; + } + } + + // remember everything before the decimal separator for later + sal_Int32 nForComma(aStr.getLength() - nC); + + if(nC > 0) + { + // insert comma char (decimal separator) + // remove trailing zeros + while(nC > 0 && aStr[aStr.getLength() - 1] == aNullCode.getStr()[0]) + { + aStr.remove(aStr.getLength() - 1, 1); + nC--; + } + + if(nC > 0) + { + // do we still have decimal places? + sal_Unicode cDec(rLoc.getNumDecimalSep()[0]); + aStr.insert(nForComma, cDec); + } + } + + // add in thousands separator (if necessary) + if( nForComma > 3 ) + { + const OUString& aThoSep( rLoc.getNumThousandSep() ); + if ( aThoSep.getLength() > 0 ) + { + sal_Unicode cTho( aThoSep[0] ); + sal_Int32 i(nForComma - 3); + + while(i > 0) + { + aStr.insert(i, cTho); + i -= 3; + } + } + } + + if(aStr.isEmpty()) + aStr.append(aNullCode); + + if(bNeg && (aStr.getLength() > 1 || aStr[0] != aNullCode.getStr()[0])) + { + aStr.insert(0, "-"); + } + + return aStr.makeStringAndClear(); +} + +OUString SdrFormatter::GetUnitStr(MapUnit eUnit) +{ + switch(eUnit) + { + // metrically + case MapUnit::Map100thMM : + return "/100mm"; + case MapUnit::Map10thMM : + return "/10mm"; + case MapUnit::MapMM : + return "mm"; + case MapUnit::MapCM : + return "cm"; + + // Inch + case MapUnit::Map1000thInch: + return "/1000\""; + case MapUnit::Map100thInch : + return "/100\""; + case MapUnit::Map10thInch : + return "/10\""; + case MapUnit::MapInch : + return "\""; + case MapUnit::MapPoint : + return "pt"; + case MapUnit::MapTwip : + return "twip"; + + // others + case MapUnit::MapPixel : + return "pixel"; + case MapUnit::MapSysFont : + return "sysfont"; + case MapUnit::MapAppFont : + return "appfont"; + case MapUnit::MapRelative : + return "%"; + default: + return OUString(); + } +} + +OUString SdrFormatter::GetUnitStr(FieldUnit eUnit) +{ + switch(eUnit) + { + default : + case FieldUnit::NONE : + case FieldUnit::CUSTOM : + return OUString(); + + // metrically + case FieldUnit::MM_100TH: + return "/100mm"; + case FieldUnit::MM : + return "mm"; + case FieldUnit::CM : + return "cm"; + case FieldUnit::M : + return "m"; + case FieldUnit::KM : + return "km"; + + // Inch + case FieldUnit::TWIP : + return "twip"; + case FieldUnit::POINT : + return "pt"; + case FieldUnit::PICA : + return "pica"; + case FieldUnit::INCH : + return "\""; + case FieldUnit::FOOT : + return "ft"; + case FieldUnit::MILE : + return "mile(s)"; + + // others + case FieldUnit::PERCENT: + return "%"; + } +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdundo.cxx b/svx/source/svdraw/svdundo.cxx new file mode 100644 index 0000000000..0dcfede6e0 --- /dev/null +++ b/svx/source/svdraw/svdundo.cxx @@ -0,0 +1,1789 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // #i124389# +#include +#include +#include +#include +#include +#include +#include +#include + + +// iterates over all views and unmarks this SdrObject if it is marked +static void ImplUnmarkObject( SdrObject* pObj ) +{ + SdrViewIter::ForAllViews( pObj, + [&pObj] (SdrView* pView) + { + pView->MarkObj( pObj, pView->GetSdrPageView(), true ); + }); +} + +SdrUndoAction::SdrUndoAction(SdrModel& rNewMod) + : rMod(rNewMod), m_nViewShellId(-1) +{ + if (SfxViewShell* pViewShell = SfxViewShell::Current()) + m_nViewShellId = pViewShell->GetViewShellId(); +} + +SdrUndoAction::~SdrUndoAction() {} + +bool SdrUndoAction::CanRepeat(SfxRepeatTarget& rView) const +{ + SdrView* pV=dynamic_cast( &rView ); + if (pV!=nullptr) return CanSdrRepeat(*pV); + return false; +} + +void SdrUndoAction::Repeat(SfxRepeatTarget& rView) +{ + SdrView* pV=dynamic_cast( &rView ); + if (pV!=nullptr) SdrRepeat(*pV); + DBG_ASSERT(pV!=nullptr,"Repeat: SfxRepeatTarget that was handed over is not a SdrView"); +} + +OUString SdrUndoAction::GetRepeatComment(SfxRepeatTarget& rView) const +{ + SdrView* pV=dynamic_cast( &rView ); + if (pV!=nullptr) return GetSdrRepeatComment(); + return OUString(); +} + +bool SdrUndoAction::CanSdrRepeat(SdrView& /*rView*/) const +{ + return false; +} + +void SdrUndoAction::SdrRepeat(SdrView& /*rView*/) +{ +} + +OUString SdrUndoAction::GetSdrRepeatComment() const +{ + return OUString(); +} + +ViewShellId SdrUndoAction::GetViewShellId() const +{ + return m_nViewShellId; +} + +SdrUndoGroup::SdrUndoGroup(SdrModel& rNewMod) +: SdrUndoAction(rNewMod), + eFunction(SdrRepeatFunc::NONE) +{} + +SdrUndoGroup::~SdrUndoGroup() +{ +} + +void SdrUndoGroup::AddAction(std::unique_ptr pAct) +{ + maActions.push_back(std::move(pAct)); +} + +void SdrUndoGroup::Undo() +{ + for (auto it = maActions.rbegin(); it != maActions.rend(); ++it) + (*it)->Undo(); +} + +void SdrUndoGroup::Redo() +{ + for (std::unique_ptr & pAction : maActions) + pAction->Redo(); +} + +OUString SdrUndoGroup::GetComment() const +{ + return aComment.replaceAll("%1", aObjDescription); +} + +bool SdrUndoGroup::CanSdrRepeat(SdrView& rView) const +{ + switch (eFunction) + { + case SdrRepeatFunc::NONE : return false; + case SdrRepeatFunc::Delete : return rView.AreObjectsMarked(); + case SdrRepeatFunc::CombinePolyPoly: return rView.IsCombinePossible(); + case SdrRepeatFunc::CombineOnePoly : return rView.IsCombinePossible(true); + case SdrRepeatFunc::DismantlePolys : return rView.IsDismantlePossible(); + case SdrRepeatFunc::DismantleLines : return rView.IsDismantlePossible(true); + case SdrRepeatFunc::ConvertToPoly : return rView.IsConvertToPolyObjPossible(); + case SdrRepeatFunc::ConvertToPath : return rView.IsConvertToPathObjPossible(); + case SdrRepeatFunc::Group : return rView.IsGroupPossible(); + case SdrRepeatFunc::Ungroup : return rView.IsUnGroupPossible(); + case SdrRepeatFunc::PutToTop : return rView.IsToTopPossible(); + case SdrRepeatFunc::PutToBottom : return rView.IsToBtmPossible(); + case SdrRepeatFunc::MoveToTop : return rView.IsToTopPossible(); + case SdrRepeatFunc::MoveToBottom : return rView.IsToBtmPossible(); + case SdrRepeatFunc::ReverseOrder : return rView.IsReverseOrderPossible(); + case SdrRepeatFunc::ImportMtf : return rView.IsImportMtfPossible(); + default: break; + } // switch + return false; +} + +void SdrUndoGroup::SdrRepeat(SdrView& rView) +{ + switch (eFunction) + { + case SdrRepeatFunc::NONE : break; + case SdrRepeatFunc::Delete : rView.DeleteMarked(); break; + case SdrRepeatFunc::CombinePolyPoly : rView.CombineMarkedObjects(false); break; + case SdrRepeatFunc::CombineOnePoly : rView.CombineMarkedObjects(); break; + case SdrRepeatFunc::DismantlePolys : rView.DismantleMarkedObjects(); break; + case SdrRepeatFunc::DismantleLines : rView.DismantleMarkedObjects(true); break; + case SdrRepeatFunc::ConvertToPoly : rView.ConvertMarkedToPolyObj(); break; + case SdrRepeatFunc::ConvertToPath : rView.ConvertMarkedToPathObj(false); break; + case SdrRepeatFunc::Group : rView.GroupMarked(); break; + case SdrRepeatFunc::Ungroup : rView.UnGroupMarked(); break; + case SdrRepeatFunc::PutToTop : rView.PutMarkedToTop(); break; + case SdrRepeatFunc::PutToBottom : rView.PutMarkedToBtm(); break; + case SdrRepeatFunc::MoveToTop : rView.MovMarkedToTop(); break; + case SdrRepeatFunc::MoveToBottom : rView.MovMarkedToBtm(); break; + case SdrRepeatFunc::ReverseOrder : rView.ReverseOrderOfMarked(); break; + case SdrRepeatFunc::ImportMtf : rView.DoImportMarkedMtf(); break; + default: break; + } // switch +} + +OUString SdrUndoGroup::GetSdrRepeatComment() const +{ + return aComment.replaceAll("%1", SvxResId(STR_ObjNameSingulPlural)); +} + +SdrUndoObj::SdrUndoObj(SdrObject& rNewObj) +: SdrUndoAction(rNewObj.getSdrModelFromSdrObject()) + ,mxObj(&rNewObj) +{ +} + +SdrUndoObj::~SdrUndoObj() {} + +OUString SdrUndoObj::GetDescriptionStringForObject( const SdrObject& _rForObject, TranslateId pStrCacheID, bool bRepeat ) +{ + const OUString rStr {SvxResId(pStrCacheID)}; + + const sal_Int32 nPos = rStr.indexOf("%1"); + if (nPos < 0) + return rStr; + + if (bRepeat) + return rStr.replaceAt(nPos, 2, SvxResId(STR_ObjNameSingulPlural)); + + return rStr.replaceAt(nPos, 2, _rForObject.TakeObjNameSingul()); +} + +OUString SdrUndoObj::ImpGetDescriptionStr(TranslateId pStrCacheID, bool bRepeat) const +{ + if ( mxObj ) + return GetDescriptionStringForObject( *mxObj, pStrCacheID, bRepeat ); + return OUString(); +} + +// common call method for possible change of the page when UNDO/REDO is triggered +void SdrUndoObj::ImpShowPageOfThisObject() +{ + if(mxObj && mxObj->IsInserted() && mxObj->getSdrPageFromSdrObject()) + { + SdrHint aHint(SdrHintKind::SwitchToPage, *mxObj, mxObj->getSdrPageFromSdrObject()); + mxObj->getSdrModelFromSdrObject().Broadcast(aHint); + } +} + +void SdrUndoAttrObj::ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet) +{ + SfxStyleSheetBase* pThere = rStyleSheetPool.Find(rSheet.GetName(), rSheet.GetFamily()); + + if(!pThere) + { + // re-insert remembered style which was removed in the meantime. To do this + // without assertion, do it without parent and set parent after insertion + const OUString aParent(rSheet.GetParent()); + + rSheet.SetParent(OUString()); + rStyleSheetPool.Insert(&rSheet); + rSheet.SetParent(aParent); + } +} + +SdrUndoAttrObj::SdrUndoAttrObj(SdrObject& rNewObj, bool bStyleSheet1, bool bSaveText) + : SdrUndoObj(rNewObj) + , bHaveToTakeRedoSet(true) +{ + bStyleSheet = bStyleSheet1; + + SdrObjList* pOL = rNewObj.GetSubList(); + bool bIsGroup(pOL!=nullptr && pOL->GetObjCount()); + bool bIs3DScene(bIsGroup && DynCastE3dScene(mxObj.get())); + + if(bIsGroup) + { + // it's a group object! + pUndoGroup.reset(new SdrUndoGroup(mxObj->getSdrModelFromSdrObject())); + + for (const rtl::Reference& pObj : *pOL) + { + pUndoGroup->AddAction( + std::make_unique(*pObj, bStyleSheet1)); + } + } + + if(bIsGroup && !bIs3DScene) + return; + + moUndoSet.emplace( mxObj->GetMergedItemSet() ); + + if(bStyleSheet) + mxUndoStyleSheet = mxObj->GetStyleSheet(); + + if(bSaveText) + { + auto p = mxObj->GetOutlinerParaObject(); + if(p) + pTextUndo = *p; + } +} + +SdrUndoAttrObj::~SdrUndoAttrObj() +{ + moUndoSet.reset(); + moRedoSet.reset(); + pUndoGroup.reset(); + pTextUndo.reset(); + pTextRedo.reset(); +} + +void SdrUndoAttrObj::Undo() +{ + E3DModifySceneSnapRectUpdater aUpdater(mxObj.get()); + bool bIs3DScene(DynCastE3dScene(mxObj.get())); + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + if(!pUndoGroup || bIs3DScene) + { + if(bHaveToTakeRedoSet) + { + bHaveToTakeRedoSet = false; + + moRedoSet.emplace( mxObj->GetMergedItemSet() ); + + if(bStyleSheet) + mxRedoStyleSheet = mxObj->GetStyleSheet(); + + if(pTextUndo) + { + // #i8508# + auto p = mxObj->GetOutlinerParaObject(); + if(p) + pTextRedo = *p; + } + } + + if(bStyleSheet) + { + mxRedoStyleSheet = mxObj->GetStyleSheet(); + SfxStyleSheet* pSheet = mxUndoStyleSheet.get(); + + if(pSheet && mxObj->getSdrModelFromSdrObject().GetStyleSheetPool()) + { + ensureStyleSheetInStyleSheetPool(*mxObj->getSdrModelFromSdrObject().GetStyleSheetPool(), *pSheet); + mxObj->SetStyleSheet(pSheet, true); + } + else + { + OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)"); + } + } + + sdr::properties::ItemChangeBroadcaster aItemChange(*mxObj); + + // Since ClearItem sets back everything to normal + // it also sets fit-to-size text to non-fit-to-size text and + // switches on autogrowheight (the default). That may lead to + // losing the geometry size info for the object when it is + // laid out again from AdjustTextFrameWidthAndHeight(). This makes + // rescuing the size of the object necessary. + const tools::Rectangle aSnapRect = mxObj->GetSnapRect(); + // SdrObjCustomShape::NbcSetSnapRect needs logic instead of snap rect + const tools::Rectangle aLogicRect = mxObj->GetLogicRect(); + + if(moUndoSet) + { + if(dynamic_cast( mxObj.get() ) != nullptr) + { + // do a more smooth item deletion here, else the text + // rect will be reformatted, especially when information regarding + // vertical text is changed. When clearing only set items it's + // slower, but safer regarding such information (it's not changed + // usually) + SfxWhichIter aIter(*moUndoSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + + while(nWhich) + { + if(SfxItemState::SET != aIter.GetItemState(false)) + { + mxObj->ClearMergedItem(nWhich); + } + + nWhich = aIter.NextWhich(); + } + } + else + { + mxObj->ClearMergedItem(); + } + + mxObj->SetMergedItemSet(*moUndoSet); + } + + // Restore previous size here when it was changed. + if(aSnapRect != mxObj->GetSnapRect()) + { + if(dynamic_cast(mxObj.get())) + mxObj->NbcSetSnapRect(aLogicRect); + else + mxObj->NbcSetSnapRect(aSnapRect); + } + + mxObj->GetProperties().BroadcastItemChange(aItemChange); + + if(pTextUndo) + { + mxObj->SetOutlinerParaObject(*pTextUndo); + } + } + + if(pUndoGroup) + { + pUndoGroup->Undo(); + } +} + +void SdrUndoAttrObj::Redo() +{ + E3DModifySceneSnapRectUpdater aUpdater(mxObj.get()); + bool bIs3DScene(DynCastE3dScene(mxObj.get())); + + if(!pUndoGroup || bIs3DScene) + { + if(bStyleSheet) + { + mxUndoStyleSheet = mxObj->GetStyleSheet(); + SfxStyleSheet* pSheet = mxRedoStyleSheet.get(); + + if(pSheet && mxObj->getSdrModelFromSdrObject().GetStyleSheetPool()) + { + ensureStyleSheetInStyleSheetPool(*mxObj->getSdrModelFromSdrObject().GetStyleSheetPool(), *pSheet); + mxObj->SetStyleSheet(pSheet, true); + } + else + { + OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)"); + } + } + + sdr::properties::ItemChangeBroadcaster aItemChange(*mxObj); + + const tools::Rectangle aSnapRect = mxObj->GetSnapRect(); + const tools::Rectangle aLogicRect = mxObj->GetLogicRect(); + + if(moRedoSet) + { + if(dynamic_cast( mxObj.get() ) != nullptr) + { + // do a more smooth item deletion here, else the text + // rect will be reformatted, especially when information regarding + // vertical text is changed. When clearing only set items it's + // slower, but safer regarding such information (it's not changed + // usually) + SfxWhichIter aIter(*moRedoSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + + while(nWhich) + { + if(SfxItemState::SET != aIter.GetItemState(false)) + { + mxObj->ClearMergedItem(nWhich); + } + + nWhich = aIter.NextWhich(); + } + } + else + { + mxObj->ClearMergedItem(); + } + + mxObj->SetMergedItemSet(*moRedoSet); + } + + // Restore previous size here when it was changed. + if(aSnapRect != mxObj->GetSnapRect()) + { + if(dynamic_cast(mxObj.get())) + mxObj->NbcSetSnapRect(aLogicRect); + else + mxObj->NbcSetSnapRect(aSnapRect); + } + + mxObj->GetProperties().BroadcastItemChange(aItemChange); + + // #i8508# + if(pTextRedo) + { + mxObj->SetOutlinerParaObject(*pTextRedo); + } + } + + if(pUndoGroup) + { + pUndoGroup->Redo(); + } + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +OUString SdrUndoAttrObj::GetComment() const +{ + if(bStyleSheet) + { + return ImpGetDescriptionStr(STR_EditSetStylesheet); + } + else + { + return ImpGetDescriptionStr(STR_EditSetAttributes); + } +} + +OUString SdrUndoAttrObj::GetSdrRepeatComment() const +{ + if(bStyleSheet) + { + return ImpGetDescriptionStr(STR_EditSetStylesheet, true); + } + else + { + return ImpGetDescriptionStr(STR_EditSetAttributes, true); + } +} + + +SdrUndoMoveObj::~SdrUndoMoveObj() {} + +void SdrUndoMoveObj::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + mxObj->Move(Size(-aDistance.Width(),-aDistance.Height())); +} + +void SdrUndoMoveObj::Redo() +{ + mxObj->Move(Size(aDistance.Width(),aDistance.Height())); + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +OUString SdrUndoMoveObj::GetComment() const +{ + return ImpGetDescriptionStr(STR_EditMove); +} + +void SdrUndoMoveObj::SdrRepeat(SdrView& rView) +{ + rView.MoveMarkedObj(aDistance); +} + +bool SdrUndoMoveObj::CanSdrRepeat(SdrView& rView) const +{ + return rView.AreObjectsMarked(); +} + +OUString SdrUndoMoveObj::GetSdrRepeatComment() const +{ + return ImpGetDescriptionStr(STR_EditMove,true); +} + + +SdrUndoGeoObj::SdrUndoGeoObj(SdrObject& rNewObj) + : SdrUndoObj(rNewObj) + , mbSkipChangeLayout(false) +{ + SdrObjList* pOL=rNewObj.GetSubList(); + if (pOL!=nullptr && pOL->GetObjCount() && !DynCastE3dScene(&rNewObj)) + { + // this is a group object! + // If this were 3D scene, we'd only add an Undo for the scene itself + // (which we do elsewhere). + pUndoGroup.reset(new SdrUndoGroup(mxObj->getSdrModelFromSdrObject())); + for (const rtl::Reference& pObj : *pOL) + pUndoGroup->AddAction(std::make_unique(*pObj)); + } + else + { + pUndoGeo = mxObj->GetGeoData(); + } +} + +SdrUndoGeoObj::~SdrUndoGeoObj() +{ + pUndoGeo.reset(); + pRedoGeo.reset(); + pUndoGroup.reset(); +} + +void SdrUndoGeoObj::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + if(pUndoGroup) + { + pUndoGroup->Undo(); + + // only repaint, no objectchange + mxObj->ActionChanged(); + } + else + { + pRedoGeo = mxObj->GetGeoData(); + + auto pTableObj = dynamic_cast(mxObj.get()); + if (pTableObj && mbSkipChangeLayout) + pTableObj->SetSkipChangeLayout(true); + mxObj->SetGeoData(*pUndoGeo); + if (pTableObj && mbSkipChangeLayout) + pTableObj->SetSkipChangeLayout(false); + } +} + +void SdrUndoGeoObj::Redo() +{ + if(pUndoGroup) + { + pUndoGroup->Redo(); + + // only repaint, no objectchange + mxObj->ActionChanged(); + } + else + { + pUndoGeo = mxObj->GetGeoData(); + mxObj->SetGeoData(*pRedoGeo); + } + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +OUString SdrUndoGeoObj::GetComment() const +{ + return ImpGetDescriptionStr(STR_DragMethObjOwn); +} + +SdrUndoDiagramModelData::SdrUndoDiagramModelData(SdrObject& rNewObj, svx::diagram::DiagramDataStatePtr& rStartState) +: SdrUndoObj(rNewObj) +, m_aStartState(rStartState) +, m_aEndState() +{ + if(rNewObj.isDiagram()) + m_aEndState = rNewObj.getDiagramHelper()->extractDiagramDataState(); +} + +SdrUndoDiagramModelData::~SdrUndoDiagramModelData() +{ +} + +void SdrUndoDiagramModelData::implUndoRedo(bool bUndo) +{ + if(!mxObj) + return; + + if(!mxObj->isDiagram()) + return; + + mxObj->getDiagramHelper()->applyDiagramDataState( + bUndo ? m_aStartState : m_aEndState); + mxObj->getDiagramHelper()->reLayout(*static_cast(mxObj.get())); +} + +void SdrUndoDiagramModelData::Undo() +{ + implUndoRedo(true); +} + +void SdrUndoDiagramModelData::Redo() +{ + implUndoRedo(false); +} + +OUString SdrUndoDiagramModelData::GetComment() const +{ + return ImpGetDescriptionStr(STR_DiagramModelDataChange); +} + +SdrUndoObjList::SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect) + : SdrUndoObj(rNewObj) +{ + pObjList=mxObj->getParentSdrObjListFromSdrObject(); + if (bOrdNumDirect) + { + nOrdNum=mxObj->GetOrdNumDirect(); + } + else + { + nOrdNum=mxObj->GetOrdNum(); + } +} + +SdrUndoObjList::~SdrUndoObjList() +{ +} + +void SdrUndoRemoveObj::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + DBG_ASSERT(!mxObj->IsInserted(),"UndoRemoveObj: mxObj has already been inserted."); + if (mxObj->IsInserted()) + return; + + // #i11426# + // For UNDOs in Calc/Writer it is necessary to adapt the anchor + // position of the target object. + Point aOwnerAnchorPos(0, 0); + + if (dynamic_cast< const SdrObjGroup* >(pObjList->getSdrObjectFromSdrObjList()) != nullptr) + { + aOwnerAnchorPos = pObjList->getSdrObjectFromSdrObjList()->GetAnchorPos(); + } + + E3DModifySceneSnapRectUpdater aUpdater(pObjList->getSdrObjectFromSdrObjList()); + pObjList->InsertObject(mxObj.get(), nOrdNum); + + // #i11426# + if(aOwnerAnchorPos.X() || aOwnerAnchorPos.Y()) + { + mxObj->NbcSetAnchorPos(aOwnerAnchorPos); + } +} + +void SdrUndoRemoveObj::Redo() +{ + DBG_ASSERT(mxObj->IsInserted(),"RedoRemoveObj: mxObj is not inserted."); + if (mxObj->IsInserted()) + { + ImplUnmarkObject( mxObj.get() ); + E3DModifySceneSnapRectUpdater aUpdater(mxObj.get()); + pObjList->RemoveObject(mxObj->GetOrdNum()); + } + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +SdrUndoRemoveObj::~SdrUndoRemoveObj() +{ +} + + +void SdrUndoInsertObj::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + DBG_ASSERT(mxObj->IsInserted(),"UndoInsertObj: mxObj is not inserted."); + if (mxObj->IsInserted()) + { + ImplUnmarkObject( mxObj.get() ); + + rtl::Reference pChkObj= pObjList->RemoveObject(mxObj->GetOrdNum()); + DBG_ASSERT(pChkObj.get()==mxObj.get(),"UndoInsertObj: RemoveObjNum!=mxObj"); + } +} + +void SdrUndoInsertObj::Redo() +{ + DBG_ASSERT(!mxObj->IsInserted(),"RedoInsertObj: mxObj is already inserted"); + if (!mxObj->IsInserted()) + { + // Restore anchor position of an object, + // which becomes a member of a group, because its cleared in method + // . Needed for correct Redo in Writer. (#i45952#) + Point aAnchorPos( 0, 0 ); + + if (dynamic_cast(pObjList->getSdrObjectFromSdrObjList()) != nullptr) + { + aAnchorPos = mxObj->GetAnchorPos(); + } + + pObjList->InsertObject(mxObj.get(), nOrdNum); + + // Arcs lose position when grouped (#i45952#) + if ( aAnchorPos.X() || aAnchorPos.Y() ) + { + mxObj->NbcSetAnchorPos( aAnchorPos ); + } + } + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +SdrUndoDelObj::SdrUndoDelObj(SdrObject& rNewObj, bool bOrdNumDirect) +: SdrUndoRemoveObj(rNewObj,bOrdNumDirect) +{ +} + +void SdrUndoDelObj::Undo() +{ + SdrUndoRemoveObj::Undo(); +} + +void SdrUndoDelObj::Redo() +{ + SdrUndoRemoveObj::Redo(); +} + +OUString SdrUndoDelObj::GetComment() const +{ + return ImpGetDescriptionStr(STR_EditDelete); +} + +void SdrUndoDelObj::SdrRepeat(SdrView& rView) +{ + rView.DeleteMarked(); +} + +bool SdrUndoDelObj::CanSdrRepeat(SdrView& rView) const +{ + return rView.AreObjectsMarked(); +} + +OUString SdrUndoDelObj::GetSdrRepeatComment() const +{ + return ImpGetDescriptionStr(STR_EditDelete,true); +} + + +void SdrUndoNewObj::Undo() +{ + SdrUndoInsertObj::Undo(); +} + +void SdrUndoNewObj::Redo() +{ + SdrUndoInsertObj::Redo(); +} + +OUString SdrUndoNewObj::GetComment( const SdrObject& _rForObject ) +{ + return GetDescriptionStringForObject( _rForObject, STR_UndoInsertObj ); +} + +OUString SdrUndoNewObj::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoInsertObj); +} + +SdrUndoReplaceObj::SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1) + : SdrUndoObj(rOldObj1) + , mxNewObj(&rNewObj1) +{ + pObjList=mxObj->getParentSdrObjListFromSdrObject(); +} + +SdrUndoReplaceObj::~SdrUndoReplaceObj() +{ +} + +void SdrUndoReplaceObj::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + DBG_ASSERT(!mxObj->IsInserted(),"SdrUndoReplaceObj::Undo(): Old object is already inserted!"); + DBG_ASSERT(mxNewObj->IsInserted(),"SdrUndoReplaceObj::Undo(): New object is not inserted!"); + + ImplUnmarkObject( mxNewObj.get() ); + pObjList->ReplaceObject(mxObj.get(), mxNewObj->GetOrdNum()); +} + +void SdrUndoReplaceObj::Redo() +{ + ImplUnmarkObject( mxObj.get() ); + pObjList->ReplaceObject(mxNewObj.get(), mxObj->GetOrdNum()); + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + + +OUString SdrUndoCopyObj::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoCopyObj); +} + + +// #i11702# + +SdrUndoObjectLayerChange::SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer) + : SdrUndoObj(rObj) + , maOldLayer(aOldLayer) + , maNewLayer(aNewLayer) +{ +} + +void SdrUndoObjectLayerChange::Undo() +{ + ImpShowPageOfThisObject(); + mxObj->SetLayer(maOldLayer); +} + +void SdrUndoObjectLayerChange::Redo() +{ + mxObj->SetLayer(maNewLayer); + ImpShowPageOfThisObject(); +} + + +SdrUndoObjOrdNum::SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1) + : SdrUndoObj(rNewObj) + , nOldOrdNum(nOldOrdNum1) + , nNewOrdNum(nNewOrdNum1) +{ +} + +void SdrUndoObjOrdNum::Undo() +{ + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + SdrObjList* pOL=mxObj->getParentSdrObjListFromSdrObject(); + if (pOL==nullptr) + { + OSL_FAIL("UndoObjOrdNum: mxObj does not have an ObjList."); + return; + } + pOL->SetObjectOrdNum(nNewOrdNum,nOldOrdNum); +} + +void SdrUndoObjOrdNum::Redo() +{ + SdrObjList* pOL=mxObj->getParentSdrObjListFromSdrObject(); + if (pOL==nullptr) + { + OSL_FAIL("RedoObjOrdNum: mxObj does not have an ObjList."); + return; + } + pOL->SetObjectOrdNum(nOldOrdNum,nNewOrdNum); + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +OUString SdrUndoObjOrdNum::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoObjOrdNum); +} + +SdrUndoSort::SdrUndoSort(const SdrPage & rPage, + ::std::vector const& rSortOrder) + : SdrUndoAction(rPage.getSdrModelFromSdrPage()) + , m_OldSortOrder(rSortOrder.size()) + , m_NewSortOrder(rSortOrder) + , m_nPage(rPage.GetPageNum()) +{ + // invert order + for (size_t i = 0; i < rSortOrder.size(); ++i) + { + m_OldSortOrder[rSortOrder[i]] = i; + } +} + +void SdrUndoSort::Do(::std::vector & rSortOrder) +{ + SdrPage & rPage(*rMod.GetPage(m_nPage)); + if (rPage.GetObjCount() != rSortOrder.size()) + { + // can probably happen with sw's cursed SdrVirtObj mess - no good solution for that + SAL_WARN("svx", "SdrUndoSort size mismatch"); + return; + } + + // hopefully this can't throw + rPage.sort(rSortOrder); +} + +void SdrUndoSort::Undo() +{ + Do(m_OldSortOrder); +} + +void SdrUndoSort::Redo() +{ + Do(m_NewSortOrder); +} + +OUString SdrUndoSort::GetComment() const +{ + return SvxResId(STR_SortShapes); +} + +SdrUndoObjSetText::SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText) + : SdrUndoObj(rNewObj) + , bNewTextAvailable(false) + , bEmptyPresObj(false) + , mnText(nText) +{ + SdrText* pText = static_cast< SdrTextObj*>( &rNewObj )->getText(mnText); + if( pText && pText->GetOutlinerParaObject() ) + pOldText = *pText->GetOutlinerParaObject(); + + bEmptyPresObj = rNewObj.IsEmptyPresObj(); +} + +SdrUndoObjSetText::~SdrUndoObjSetText() +{ + pOldText.reset(); + pNewText.reset(); +} + +bool SdrUndoObjSetText::IsDifferent() const +{ + if (!pOldText || !pNewText) + return pOldText || pNewText; + return *pOldText != *pNewText; +} + +void SdrUndoObjSetText::AfterSetText() +{ + if (!bNewTextAvailable) + { + SdrText* pText = static_cast< SdrTextObj*>( mxObj.get() )->getText(mnText); + if( pText && pText->GetOutlinerParaObject() ) + pNewText = *pText->GetOutlinerParaObject(); + bNewTextAvailable=true; + } +} + +void SdrUndoObjSetText::Undo() +{ + // only works with SdrTextObj + SdrTextObj* pTarget = DynCastSdrTextObj(mxObj.get()); + + if(!pTarget) + { + OSL_ENSURE(false, "SdrUndoObjSetText::Undo with SdrObject not based on SdrTextObj (!)"); + return; + } + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); + + // save old text for Redo + if(!bNewTextAvailable) + { + AfterSetText(); + } + + SdrText* pText = pTarget->getText(mnText); + if (pText) + { + // copy text for Undo, because the original now belongs to SetOutlinerParaObject() + pTarget->NbcSetOutlinerParaObjectForText(pOldText, pText); + } + + pTarget->SetEmptyPresObj(bEmptyPresObj); + pTarget->ActionChanged(); + + // #i124389# if it's a table, also need to relayout TextFrame + if(dynamic_cast< sdr::table::SdrTableObj* >(pTarget) != nullptr) + { + pTarget->NbcAdjustTextFrameWidthAndHeight(); + } + + // #i122410# SetOutlinerParaObject at SdrText does not trigger a + // BroadcastObjectChange, but it is needed to make evtl. SlideSorters + // update their preview. + pTarget->BroadcastObjectChange(); +} + +void SdrUndoObjSetText::Redo() +{ + // only works with SdrTextObj + SdrTextObj* pTarget = DynCastSdrTextObj(mxObj.get()); + + if(!pTarget) + { + OSL_ENSURE(false, "SdrUndoObjSetText::Redo with SdrObject not based on SdrTextObj (!)"); + return; + } + + SdrText* pText = pTarget->getText(mnText); + if (pText) + { + // copy text for Undo, because the original now belongs to SetOutlinerParaObject() + pTarget->NbcSetOutlinerParaObjectForText( pNewText, pText ); + } + + pTarget->ActionChanged(); + + // #i124389# if it's a table, also need to relayout TextFrame + if(dynamic_cast< sdr::table::SdrTableObj* >(pTarget) != nullptr) + { + pTarget->NbcAdjustTextFrameWidthAndHeight(); + } + + // #i122410# NbcSetOutlinerParaObjectForText at SdrTextObj does not trigger a + // BroadcastObjectChange, but it is needed to make evtl. SlideSorters + // update their preview. + pTarget->BroadcastObjectChange(); + + // Trigger PageChangeCall + ImpShowPageOfThisObject(); +} + +OUString SdrUndoObjSetText::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoObjSetText); +} + +OUString SdrUndoObjSetText::GetSdrRepeatComment() const +{ + return ImpGetDescriptionStr(STR_UndoObjSetText); +} + +void SdrUndoObjSetText::SdrRepeat(SdrView& rView) +{ + if (!(bNewTextAvailable && rView.AreObjectsMarked())) + return; + + const SdrMarkList& rML=rView.GetMarkedObjectList(); + + const bool bUndo = rView.IsUndoEnabled(); + if( bUndo ) + { + OUString aStr = ImpGetDescriptionStr(STR_UndoObjSetText); + rView.BegUndo(aStr); + } + + const size_t nCount=rML.GetMarkCount(); + for (size_t nm=0; nmGetMarkedSdrObj(); + SdrTextObj* pTextObj=DynCastSdrTextObj( pObj2 ); + if (pTextObj!=nullptr) + { + if( bUndo ) + rView.AddUndo(std::make_unique(*pTextObj,0)); + + pTextObj->SetOutlinerParaObject(pNewText); + } + } + + if( bUndo ) + rView.EndUndo(); +} + +bool SdrUndoObjSetText::CanSdrRepeat(SdrView& rView) const +{ + bool bOk = false; + if (bNewTextAvailable && rView.AreObjectsMarked()) { + bOk=true; + } + return bOk; +} + +// Undo/Redo for setting object's name (#i73249#) +SdrUndoObjStrAttr::SdrUndoObjStrAttr( SdrObject& rNewObj, + const ObjStrAttrType eObjStrAttr, + OUString sOldStr, + OUString sNewStr) + : SdrUndoObj( rNewObj ) + , meObjStrAttr( eObjStrAttr ) + , msOldStr(std::move( sOldStr )) + , msNewStr(std::move( sNewStr )) +{ +} + +void SdrUndoObjStrAttr::Undo() +{ + ImpShowPageOfThisObject(); + + switch ( meObjStrAttr ) + { + case ObjStrAttrType::Name: + mxObj->SetName( msOldStr ); + break; + case ObjStrAttrType::Title: + mxObj->SetTitle( msOldStr ); + break; + case ObjStrAttrType::Description: + mxObj->SetDescription( msOldStr ); + break; + } +} + +void SdrUndoObjStrAttr::Redo() +{ + switch ( meObjStrAttr ) + { + case ObjStrAttrType::Name: + mxObj->SetName( msNewStr ); + break; + case ObjStrAttrType::Title: + mxObj->SetTitle( msNewStr ); + break; + case ObjStrAttrType::Description: + mxObj->SetDescription( msNewStr ); + break; + } + + ImpShowPageOfThisObject(); +} + +OUString SdrUndoObjStrAttr::GetComment() const +{ + OUString aStr; + switch ( meObjStrAttr ) + { + case ObjStrAttrType::Name: + aStr = ImpGetDescriptionStr( STR_UndoObjName) + + " '" + msNewStr + "'"; + break; + case ObjStrAttrType::Title: + aStr = ImpGetDescriptionStr( STR_UndoObjTitle ); + break; + case ObjStrAttrType::Description: + aStr = ImpGetDescriptionStr( STR_UndoObjDescription ); + break; + } + + return aStr; +} + +SdrUndoObjDecorative::SdrUndoObjDecorative(SdrObject & rObj, bool const WasDecorative) + : SdrUndoObj(rObj) + , m_WasDecorative(WasDecorative) +{ +} + +void SdrUndoObjDecorative::Undo() +{ + ImpShowPageOfThisObject(); + + mxObj->SetDecorative(m_WasDecorative); +} + +void SdrUndoObjDecorative::Redo() +{ + mxObj->SetDecorative(!m_WasDecorative); + + ImpShowPageOfThisObject(); +} + +OUString SdrUndoObjDecorative::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoObjDecorative); +} + + +SdrUndoLayer::SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) + : SdrUndoAction(rNewModel) + , pLayer(rNewLayerAdmin.GetLayer(nLayerNum)) + , pLayerAdmin(&rNewLayerAdmin) + , nNum(nLayerNum) + , bItsMine(false) +{ +} + +SdrUndoLayer::~SdrUndoLayer() +{ + if (bItsMine) + { + delete pLayer; + } +} + +void SdrUndoNewLayer::Undo() +{ + DBG_ASSERT(!bItsMine,"SdrUndoNewLayer::Undo(): Layer already belongs to UndoAction."); + bItsMine=true; + // coverity[leaked_storage] - owned by this SdrUndoNewLayer as pLayer + SdrLayer* pCmpLayer = pLayerAdmin->RemoveLayer(nNum).release(); + assert(pCmpLayer == pLayer && "SdrUndoNewLayer::Undo(): Removed layer is != pLayer."); (void)pCmpLayer; +} + +void SdrUndoNewLayer::Redo() +{ + DBG_ASSERT(bItsMine,"SdrUndoNewLayer::Undo(): Layer does not belong to UndoAction."); + bItsMine=false; + pLayerAdmin->InsertLayer(std::unique_ptr(pLayer),nNum); +} + +OUString SdrUndoNewLayer::GetComment() const +{ + return SvxResId(STR_UndoNewLayer); +} + + +void SdrUndoDelLayer::Undo() +{ + DBG_ASSERT(bItsMine,"SdrUndoDelLayer::Undo(): Layer does not belong to UndoAction."); + bItsMine=false; + pLayerAdmin->InsertLayer(std::unique_ptr(pLayer),nNum); +} + +void SdrUndoDelLayer::Redo() +{ + DBG_ASSERT(!bItsMine,"SdrUndoDelLayer::Undo(): Layer already belongs to UndoAction."); + bItsMine=true; + // coverity[leaked_storage] - owned by this SdrUndoNewLayer as pLayer + SdrLayer* pCmpLayer= pLayerAdmin->RemoveLayer(nNum).release(); + assert(pCmpLayer == pLayer && "SdrUndoDelLayer::Redo(): Removed layer is != pLayer."); (void)pCmpLayer; +} + +OUString SdrUndoDelLayer::GetComment() const +{ + return SvxResId(STR_UndoDelLayer); +} + + +SdrUndoPage::SdrUndoPage(SdrPage& rNewPg) +: SdrUndoAction(rNewPg.getSdrModelFromSdrPage()) + ,mxPage(&rNewPg) +{ +} + +SdrUndoPage::~SdrUndoPage() {} + +void SdrUndoPage::ImpInsertPage(sal_uInt16 nNum) +{ + DBG_ASSERT(!mxPage->IsInserted(),"SdrUndoPage::ImpInsertPage(): mxPage is already inserted."); + if (!mxPage->IsInserted()) + { + if (mxPage->IsMasterPage()) + { + rMod.InsertMasterPage(mxPage.get(), nNum); + } + else + { + rMod.InsertPage(mxPage.get(), nNum); + } + } +} + +void SdrUndoPage::ImpRemovePage(sal_uInt16 nNum) +{ + DBG_ASSERT(mxPage->IsInserted(),"SdrUndoPage::ImpRemovePage(): mxPage is not inserted."); + if (!mxPage->IsInserted()) + return; + + rtl::Reference pChkPg; + if (mxPage->IsMasterPage()) + { + pChkPg = rMod.RemoveMasterPage(nNum); + } + else + { + pChkPg = rMod.RemovePage(nNum); + } + DBG_ASSERT(pChkPg==mxPage,"SdrUndoPage::ImpRemovePage(): RemovePage!=mxPage"); +} + +void SdrUndoPage::ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum) +{ + DBG_ASSERT(mxPage->IsInserted(),"SdrUndoPage::ImpMovePage(): mxPage is not inserted."); + if (mxPage->IsInserted()) + { + if (mxPage->IsMasterPage()) + { + rMod.MoveMasterPage(nOldNum,nNewNum); + } + else + { + rMod.MovePage(nOldNum,nNewNum); + } + } +} + +OUString SdrUndoPage::ImpGetDescriptionStr(TranslateId pStrCacheID) +{ + return SvxResId(pStrCacheID); +} + + +SdrUndoPageList::SdrUndoPageList(SdrPage& rNewPg) + : SdrUndoPage(rNewPg) +{ + nPageNum=rNewPg.GetPageNum(); +} + +SdrUndoPageList::~SdrUndoPageList() +{ +} + + +SdrUndoDelPage::SdrUndoDelPage(SdrPage& rNewPg) + : SdrUndoPageList(rNewPg) + , mbHasFillBitmap(false) +{ + // keep fill bitmap separately to remove it from pool if not used elsewhere + if (mxPage->IsMasterPage()) + { + SfxStyleSheet* const pStyleSheet = mxPage->getSdrPageProperties().GetStyleSheet(); + if (pStyleSheet) + queryFillBitmap(pStyleSheet->GetItemSet()); + } + else + { + queryFillBitmap(mxPage->getSdrPageProperties().GetItemSet()); + } + if (bool(mpFillBitmapItem)) + clearFillBitmap(); + + // now remember the master page relationships + if(!mxPage->IsMasterPage()) + return; + + sal_uInt16 nPageCnt(rMod.GetPageCount()); + + for(sal_uInt16 nPageNum2(0); nPageNum2 < nPageCnt; nPageNum2++) + { + SdrPage* pDrawPage = rMod.GetPage(nPageNum2); + + if(pDrawPage->TRG_HasMasterPage()) + { + SdrPage& rMasterPage = pDrawPage->TRG_GetMasterPage(); + + if(mxPage.get() == &rMasterPage) + { + if(!pUndoGroup) + { + pUndoGroup.reset( new SdrUndoGroup(rMod) ); + } + + pUndoGroup->AddAction(rMod.GetSdrUndoFactory().CreateUndoPageRemoveMasterPage(*pDrawPage)); + } + } + } +} + +SdrUndoDelPage::~SdrUndoDelPage() +{ +} + +void SdrUndoDelPage::Undo() +{ + if (bool(mpFillBitmapItem)) + restoreFillBitmap(); + ImpInsertPage(nPageNum); + if (pUndoGroup!=nullptr) + { + // recover master page relationships + pUndoGroup->Undo(); + } +} + +void SdrUndoDelPage::Redo() +{ + ImpRemovePage(nPageNum); + if (bool(mpFillBitmapItem)) + clearFillBitmap(); +} + +OUString SdrUndoDelPage::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoDelPage); +} + +OUString SdrUndoDelPage::GetSdrRepeatComment() const +{ + return ImpGetDescriptionStr(STR_UndoDelPage); +} + +void SdrUndoDelPage::SdrRepeat(SdrView& /*rView*/) +{ +} + +bool SdrUndoDelPage::CanSdrRepeat(SdrView& /*rView*/) const +{ + return false; +} + +void SdrUndoDelPage::queryFillBitmap(const SfxItemSet& rItemSet) +{ + if (const XFillBitmapItem *pItem = rItemSet.GetItemIfSet(XATTR_FILLBITMAP, false)) + mpFillBitmapItem.reset(pItem->Clone()); + if (const XFillStyleItem *pItem = rItemSet.GetItemIfSet(XATTR_FILLSTYLE, false)) + mbHasFillBitmap = pItem->GetValue() == css::drawing::FillStyle_BITMAP; +} + +void SdrUndoDelPage::clearFillBitmap() +{ + if (mxPage->IsMasterPage()) + { + SfxStyleSheet* const pStyleSheet = mxPage->getSdrPageProperties().GetStyleSheet(); + assert(bool(pStyleSheet)); // who took away my stylesheet? + if (pStyleSheet->GetListenerCount() == 1) + { + SfxItemSet& rItemSet = pStyleSheet->GetItemSet(); + rItemSet.ClearItem(XATTR_FILLBITMAP); + if (mbHasFillBitmap) + rItemSet.ClearItem(XATTR_FILLSTYLE); + } + } + else + { + SdrPageProperties &rPageProps = mxPage->getSdrPageProperties(); + rPageProps.ClearItem(XATTR_FILLBITMAP); + if (mbHasFillBitmap) + rPageProps.ClearItem(XATTR_FILLSTYLE); + } +} + +void SdrUndoDelPage::restoreFillBitmap() +{ + if (mxPage->IsMasterPage()) + { + SfxStyleSheet* const pStyleSheet = mxPage->getSdrPageProperties().GetStyleSheet(); + assert(bool(pStyleSheet)); // who took away my stylesheet? + if (pStyleSheet->GetListenerCount() == 1) + { + SfxItemSet& rItemSet = pStyleSheet->GetItemSet(); + rItemSet.Put(*mpFillBitmapItem); + if (mbHasFillBitmap) + rItemSet.Put(XFillStyleItem(css::drawing::FillStyle_BITMAP)); + } + } + else + { + SdrPageProperties &rPageProps = mxPage->getSdrPageProperties(); + rPageProps.PutItem(*mpFillBitmapItem); + if (mbHasFillBitmap) + rPageProps.PutItem(XFillStyleItem(css::drawing::FillStyle_BITMAP)); + } +} + + +void SdrUndoNewPage::Undo() +{ + ImpRemovePage(nPageNum); +} + +void SdrUndoNewPage::Redo() +{ + ImpInsertPage(nPageNum); +} + +OUString SdrUndoNewPage::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoNewPage); +} + + +OUString SdrUndoCopyPage::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoCopPage); +} + +OUString SdrUndoCopyPage::GetSdrRepeatComment() const +{ + return ImpGetDescriptionStr(STR_UndoCopPage); +} + +void SdrUndoCopyPage::SdrRepeat(SdrView& /*rView*/) +{ + +} + +bool SdrUndoCopyPage::CanSdrRepeat(SdrView& /*rView*/) const +{ + return false; +} + + +void SdrUndoSetPageNum::Undo() +{ + ImpMovePage(nNewPageNum,nOldPageNum); +} + +void SdrUndoSetPageNum::Redo() +{ + ImpMovePage(nOldPageNum,nNewPageNum); +} + +OUString SdrUndoSetPageNum::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoMovPage); +} + +SdrUndoPageMasterPage::SdrUndoPageMasterPage(SdrPage& rChangedPage) + : SdrUndoPage(rChangedPage) + , mbOldHadMasterPage(mxPage->TRG_HasMasterPage()) + , maOldMasterPageNumber(0) +{ + // get current state from page + if(mbOldHadMasterPage) + { + maOldSet = mxPage->TRG_GetMasterPageVisibleLayers(); + maOldMasterPageNumber = mxPage->TRG_GetMasterPage().GetPageNum(); + } +} + +SdrUndoPageMasterPage::~SdrUndoPageMasterPage() +{ +} + +SdrUndoPageRemoveMasterPage::SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage) +: SdrUndoPageMasterPage(rChangedPage) +{ +} + +void SdrUndoPageRemoveMasterPage::Undo() +{ + if(mbOldHadMasterPage) + { + mxPage->TRG_SetMasterPage(*mxPage->getSdrModelFromSdrPage().GetMasterPage(maOldMasterPageNumber)); + mxPage->TRG_SetMasterPageVisibleLayers(maOldSet); + } +} + +void SdrUndoPageRemoveMasterPage::Redo() +{ + mxPage->TRG_ClearMasterPage(); +} + +OUString SdrUndoPageRemoveMasterPage::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoDelPageMasterDscr); +} + +SdrUndoPageChangeMasterPage::SdrUndoPageChangeMasterPage(SdrPage& rChangedPage) + : SdrUndoPageMasterPage(rChangedPage) + , mbNewHadMasterPage(false) + , maNewMasterPageNumber(0) +{ +} + +void SdrUndoPageChangeMasterPage::Undo() +{ + // remember values from new page + if(mxPage->TRG_HasMasterPage()) + { + mbNewHadMasterPage = true; + maNewSet = mxPage->TRG_GetMasterPageVisibleLayers(); + maNewMasterPageNumber = mxPage->TRG_GetMasterPage().GetPageNum(); + } + + // restore old values + if(mbOldHadMasterPage) + { + mxPage->TRG_ClearMasterPage(); + mxPage->TRG_SetMasterPage(*mxPage->getSdrModelFromSdrPage().GetMasterPage(maOldMasterPageNumber)); + mxPage->TRG_SetMasterPageVisibleLayers(maOldSet); + } +} + +void SdrUndoPageChangeMasterPage::Redo() +{ + // restore new values + if(mbNewHadMasterPage) + { + mxPage->TRG_ClearMasterPage(); + mxPage->TRG_SetMasterPage(*mxPage->getSdrModelFromSdrPage().GetMasterPage(maNewMasterPageNumber)); + mxPage->TRG_SetMasterPageVisibleLayers(maNewSet); + } +} + +OUString SdrUndoPageChangeMasterPage::GetComment() const +{ + return ImpGetDescriptionStr(STR_UndoChgPageMasterDscr); +} + + +SdrUndoFactory::~SdrUndoFactory(){} + +// shapes + +std::unique_ptr SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject, const Size& rDist ) +{ + return std::make_unique( rObject, rDist ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoGeoObject( SdrObject& rObject ) +{ + return std::make_unique( rObject ); +} + +// Diagram ModelData changes +std::unique_ptr SdrUndoFactory::CreateUndoDiagramModelData( SdrObject& rObject, std::shared_ptr< svx::diagram::DiagramDataState >& rStartState ) +{ + return std::make_unique( rObject, rStartState ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1, bool bSaveText ) +{ + return std::make_unique( rObject, bStyleSheet1, bSaveText ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoRemoveObject(SdrObject& rObject) +{ + return std::make_unique(rObject); +} + +std::unique_ptr SdrUndoFactory::CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect ) +{ + return std::make_unique( rObject, bOrdNumDirect ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect ) +{ + return std::make_unique( rObject, bOrdNumDirect ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect ) +{ + return std::make_unique( rObject, bOrdNumDirect ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect ) +{ + return std::make_unique( rObject, bOrdNumDirect ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1) +{ + return std::make_unique( rObject, nOldOrdNum1, nNewOrdNum1 ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoSort(SdrPage & rPage, ::std::vector const& rSortOrder) +{ + return std::make_unique(rPage, rSortOrder); +} + +std::unique_ptr SdrUndoFactory::CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject ) +{ + return std::make_unique( rOldObject, rNewObject ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer ) +{ + return std::make_unique( rObject, aOldLayer, aNewLayer ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText ) +{ + return std::make_unique( rNewObj, nText ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoObjectStrAttr( SdrObject& rObject, + SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType, + const OUString& sOldStr, + const OUString& sNewStr ) +{ + return std::make_unique( rObject, eObjStrAttrType, sOldStr, sNewStr ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoObjectDecorative( + SdrObject& rObject, bool const WasDecorative) +{ + return std::make_unique(rObject, WasDecorative); +} + + +// layer +std::unique_ptr SdrUndoFactory::CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) +{ + return std::make_unique( nLayerNum, rNewLayerAdmin, rNewModel ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) +{ + return std::make_unique( nLayerNum, rNewLayerAdmin, rNewModel ); +} + +// page +std::unique_ptr SdrUndoFactory::CreateUndoDeletePage(SdrPage& rPage) +{ + return std::make_unique(rPage); +} + +std::unique_ptr SdrUndoFactory::CreateUndoNewPage(SdrPage& rPage) +{ + return std::make_unique( rPage ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoCopyPage(SdrPage& rPage) +{ + return std::make_unique( rPage ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1) +{ + return std::make_unique( rNewPg, nOldPageNum1, nNewPageNum1 ); +} + // master page +std::unique_ptr SdrUndoFactory::CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage) +{ + return std::make_unique( rChangedPage ); +} + +std::unique_ptr SdrUndoFactory::CreateUndoPageChangeMasterPage(SdrPage& rChangedPage) +{ + return std::make_unique(rChangedPage); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdview.cxx b/svx/source/svdraw/svdview.cxx new file mode 100644 index 0000000000..27233a6435 --- /dev/null +++ b/svx/source/svdraw/svdview.cxx @@ -0,0 +1,1553 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +SdrViewEvent::SdrViewEvent() + : mpHdl(nullptr), + mpObj(nullptr), + mpRootObj(nullptr), + mpPV(nullptr), + mpURLField(nullptr), + meHit(SdrHitKind::NONE), + meEvent(SdrEventKind::NONE), + mnMouseClicks(0), + mnMouseMode(MouseEventModifiers::NONE), + mnMouseCode(0), + mnHlplIdx(0), + mnGlueId(0), + mbMouseDown(false), + mbMouseUp(false), + mbIsAction(false), + mbIsTextEdit(false), + mbAddMark(false), + mbUnmark(false), + mbPrevNextMark(false), + mbMarkPrev(false) +{ +} + +// helper class for all D&D overlays + +void SdrDropMarkerOverlay::ImplCreateOverlays( + const SdrView& rView, + const basegfx::B2DPolyPolygon& rLinePolyPolygon) +{ + 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 pNew(new sdr::overlay::OverlayPolyPolygonStripedAndFilled( + rLinePolyPolygon)); + + xTargetOverlay->add(*pNew); + maObjects.append(std::move(pNew)); + } + } +} + +SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const SdrObject& rObject) +{ + ImplCreateOverlays( + rView, + rObject.TakeXorPoly()); +} + +SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const tools::Rectangle& rRectangle) +{ + basegfx::B2DPolygon aB2DPolygon; + + aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Top())); + aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Top())); + aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Bottom())); + aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Bottom())); + aB2DPolygon.setClosed(true); + + ImplCreateOverlays( + rView, + basegfx::B2DPolyPolygon(aB2DPolygon)); +} + +SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Point& rStart, const Point& rEnd) +{ + basegfx::B2DPolygon aB2DPolygon; + + aB2DPolygon.append(basegfx::B2DPoint(rStart.X(), rStart.Y())); + aB2DPolygon.append(basegfx::B2DPoint(rEnd.X(), rEnd.Y())); + aB2DPolygon.setClosed(true); + + ImplCreateOverlays( + rView, + basegfx::B2DPolyPolygon(aB2DPolygon)); +} + +SdrDropMarkerOverlay::~SdrDropMarkerOverlay() +{ + // 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. +} + +SdrView::SdrView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: SdrCreateView(rSdrModel, pOut), + mbNoExtendedMouseDispatcher(false), + mbNoExtendedKeyDispatcher(false), + mbMasterPagePaintCaching(false) +{ + maAccessibilityOptions.AddListener(this); + onAccessibilityOptionsChanged(); +} + +SdrView::~SdrView() +{ + maAccessibilityOptions.RemoveListener(this); +} + +bool SdrView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin) +{ + SetActualWin(pWin ? pWin->GetOutDev() : nullptr); + bool bRet = SdrCreateView::KeyInput(rKEvt,pWin); + if (!bRet && !IsExtendedKeyInputDispatcherEnabled()) { + bRet = true; + switch (rKEvt.GetKeyCode().GetFullFunction()) { + case KeyFuncType::DELETE: DeleteMarked(); break; + case KeyFuncType::UNDO: GetModel().Undo(); break; + case KeyFuncType::REDO: GetModel().Redo(); break; + default: { + switch (rKEvt.GetKeyCode().GetFullCode()) { + case KEY_ESCAPE: { + if (IsTextEdit()) SdrEndTextEdit(); + if (IsAction()) BrkAction(); + if (pWin!=nullptr) pWin->ReleaseMouse(); + } break; + case KEY_DELETE: DeleteMarked(); break; + case KEY_UNDO: case KEY_BACKSPACE+KEY_MOD2: GetModel().Undo(); break; + case KEY_BACKSPACE+KEY_MOD2+KEY_SHIFT: GetModel().Redo(); break; + case KEY_REPEAT: case KEY_BACKSPACE+KEY_MOD2+KEY_MOD1: GetModel().Repeat(*this); break; + case KEY_MOD1+KEY_A: MarkAll(); break; + default: bRet=false; + } // switch + } + } // switch + if (bRet && pWin!=nullptr) { + pWin->SetPointer(GetPreferredPointer( + pWin->PixelToLogic(pWin->ScreenToOutputPixel( pWin->GetPointerPosPixel() ) ), + pWin->GetOutDev(), + rKEvt.GetKeyCode().GetModifier())); + } + } + return bRet; +} + +bool SdrView::MouseButtonDown(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + SetActualWin(pWin); + if (rMEvt.IsLeft()) maDragStat.SetMouseDown(true); + bool bRet = SdrCreateView::MouseButtonDown(rMEvt,pWin); + if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) { + SdrViewEvent aVEvt; + PickAnything(rMEvt,SdrMouseEventKind::BUTTONDOWN,aVEvt); + bRet = DoMouseEvent(aVEvt); + } + return bRet; +} + +bool SdrView::MouseButtonUp(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + SetActualWin(pWin); + if (rMEvt.IsLeft()) maDragStat.SetMouseDown(false); + bool bAction = IsAction(); + bool bRet = !bAction && SdrCreateView::MouseButtonUp(rMEvt,pWin); + if (!bRet && !IsExtendedMouseEventDispatcherEnabled()) { + SdrViewEvent aVEvt; + PickAnything(rMEvt,SdrMouseEventKind::BUTTONUP,aVEvt); + bRet = DoMouseEvent(aVEvt); + } + return bRet; +} + +bool SdrView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) +{ + SetActualWin(pWin); + maDragStat.SetMouseDown(rMEvt.IsLeft()); + bool bRet = SdrCreateView::MouseMove(rMEvt,pWin); + if (!IsExtendedMouseEventDispatcherEnabled() && !IsTextEditInSelectionMode()) { + SdrViewEvent aVEvt; + PickAnything(rMEvt,SdrMouseEventKind::MOVE,aVEvt); + if (DoMouseEvent(aVEvt)) bRet=true; + } + + return bRet; +} + +bool SdrView::Command(const CommandEvent& rCEvt, vcl::Window* pWin) +{ + SetActualWin(pWin->GetOutDev()); + bool bRet = SdrCreateView::Command(rCEvt,pWin); + return bRet; +} + +void SdrView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const +{ + SdrCreateView::GetAttributes(rTargetSet, bOnlyHardAttr); +} + +SdrHitKind SdrView::PickAnything(const MouseEvent& rMEvt, SdrMouseEventKind nEventKind, SdrViewEvent& rVEvt) const +{ + rVEvt.mbMouseDown = nEventKind==SdrMouseEventKind::BUTTONDOWN; + rVEvt.mbMouseUp = nEventKind==SdrMouseEventKind::BUTTONUP; + rVEvt.mnMouseClicks = rMEvt.GetClicks(); + rVEvt.mnMouseMode = rMEvt.GetMode(); + rVEvt.mnMouseCode = rMEvt.GetButtons() | rMEvt.GetModifier(); + const OutputDevice* pOut=mpActualOutDev; + if (pOut==nullptr) + { + pOut = GetFirstOutputDevice(); + } + Point aPnt(rMEvt.GetPosPixel()); + if (pOut!=nullptr) aPnt=pOut->PixelToLogic(aPnt); + + if (mbNegativeX) + { + // Shape's x coordinates are all negated, + // Hence negate mouse event's x coord to match. + aPnt.setX(-aPnt.X()); + } + + rVEvt.maLogicPos = aPnt; + return PickAnything(aPnt,rVEvt); +} + +// Dragging with the Mouse (Move) +// Example when creating a rectangle: MouseDown has to happen without a ModKey, +// else we usually force a selection (see below). +// When pressing Shift, Ctrl and Alt at the same time while doing a MouseMove, +// a centered, not snapped square is created. +// The dual allocation of Ortho and Shift won't usually create a problem, as the +// two functions are in most cases mutually exclusive. Only shearing (the kind +// that happens when contorting, not when rotating) can use both functions at +// the same time. To get around this, the user can use e. g. help lines. +#define MODKEY_NoSnap bCtrl /* temporarily disable snapping */ +#define MODKEY_Ortho bShift /* ortho */ +#define MODKEY_Center bAlt /* create/resize centeredly */ +#define MODKEY_AngleSnap bShift +#define MODKEY_CopyDrag bCtrl /* drag and copy */ + +// click somewhere (MouseDown) +#define MODKEY_PolyPoly bAlt /* new Poly at InsPt and at Create */ +#define MODKEY_MultiMark bShift /* MarkObj without doing UnmarkAll first */ +#define MODKEY_Unmark bAlt /* deselect with a dragged frame */ +#define MODKEY_ForceMark bCtrl /* force dragging a frame, even if there's an object at cursor position */ +#define MODKEY_DeepMark bAlt /* MarkNextObj */ +#define MODKEY_DeepBackw bShift /* MarkNextObj but backwards */ + +SdrHitKind SdrView::PickAnything(const Point& rLogicPos, SdrViewEvent& rVEvt) const +{ + const OutputDevice* pOut=mpActualOutDev; + if (pOut==nullptr) + { + pOut = GetFirstOutputDevice(); + } + + // #i73628# Use a non-changeable copy of he logic position + const Point aLocalLogicPosition(rLogicPos); + + bool bEditMode=IsEditMode(); + bool bPointMode=bEditMode && HasMarkablePoints(); + bool bGluePointMode=IsGluePointEditMode(); + bool bInsPolyPt=bPointMode && IsInsObjPointMode() && IsInsObjPointPossible(); + bool bInsGluePt=bGluePointMode && IsInsGluePointMode() && IsInsGluePointPossible(); + bool bIsTextEdit=IsTextEdit(); + bool bTextEditHit=IsTextEditHit(aLocalLogicPosition); + bool bTextEditSel=IsTextEditInSelectionMode(); + bool bShift = (rVEvt.mnMouseCode & KEY_SHIFT) != 0; + bool bCtrl = (rVEvt.mnMouseCode & KEY_MOD1) != 0; + bool bAlt = (rVEvt.mnMouseCode & KEY_MOD2) != 0; + SdrHitKind eHit=SdrHitKind::NONE; + SdrHdl* pHdl=pOut!=nullptr && !bTextEditSel ? PickHandle(aLocalLogicPosition) : nullptr; + SdrPageView* pPV=nullptr; + SdrObject* pObj=nullptr; + SdrObject* pHitObj=nullptr; + bool bHitPassDirect=true; + sal_uInt16 nHlplIdx=0; + sal_uInt16 nGlueId=0; + if (bTextEditHit || bTextEditSel) + { + eHit=SdrHitKind::TextEdit; + } + else if (pHdl!=nullptr) + { + eHit=SdrHitKind::Handle; // handle is hit: highest priority + } + else if (bEditMode && IsHlplVisible() && IsHlplFront() && pOut!=nullptr && PickHelpLine(aLocalLogicPosition,mnHitTolLog,*pOut,nHlplIdx,pPV)) + { + eHit=SdrHitKind::HelpLine; // help line in the foreground hit: can be moved now + } + else if (bGluePointMode && PickGluePoint(aLocalLogicPosition,pObj,nGlueId,pPV)) + { + eHit=SdrHitKind::Gluepoint; // deselected gluepoint hit + } + else if ((pHitObj = PickObj(aLocalLogicPosition,mnHitTolLog,pPV,SdrSearchOptions::DEEP|SdrSearchOptions::MARKED,&pObj,&bHitPassDirect))) + { + eHit=SdrHitKind::MarkedObject; + sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pObj ); + if( pTableObj ) + { + sal_Int32 nX = 0, nY = 0; + switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY ) ) + { + case sdr::table::TableHitKind::Cell: + eHit = SdrHitKind::Cell; + break; + case sdr::table::TableHitKind::CellTextArea: + eHit = SdrHitKind::TextEditObj; + break; + default: + break; + } + } + } + else if ((pHitObj = PickObj(aLocalLogicPosition,mnHitTolLog,pPV,SdrSearchOptions::DEEP|SdrSearchOptions::ALSOONMASTER|SdrSearchOptions::WHOLEPAGE,&pObj,&bHitPassDirect))) + { + // MasterPages and WholePage for Macro and URL + eHit=SdrHitKind::UnmarkedObject; + sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pObj ); + if( pTableObj ) + { + sal_Int32 nX = 0, nY = 0; + switch( pTableObj->CheckTableHit( aLocalLogicPosition, nX, nY, mnHitTolLog ) ) + { + case sdr::table::TableHitKind::Cell: + eHit = SdrHitKind::Cell; + break; + case sdr::table::TableHitKind::CellTextArea: + // Keep state on UnmarkedObject to allow the below + // 'check for URL field' to be executed, else popups + // for e.g. URL links when hoovering and clicking + // them will not work. Tried several other changes, + // but this one safely keeps existing behaviour as-is. + // Except for the LOK. LOK doesn't have hoovering popup + // feature. + eHit = comphelper::LibreOfficeKit::isActive() ? SdrHitKind::TextEditObj : SdrHitKind::UnmarkedObject; + break; + default: + break; + } + } + } + else if (bEditMode && IsHlplVisible() && !IsHlplFront() && pOut!=nullptr && PickHelpLine(aLocalLogicPosition,mnHitTolLog,*pOut,nHlplIdx,pPV)) + { + eHit=SdrHitKind::HelpLine; // help line in foreground hit: can be moved now + } + if (eHit==SdrHitKind::UnmarkedObject) + { + bool bRoot=pObj->HasMacro(); + bool bDeep=pObj!=pHitObj && pHitObj->HasMacro(); + bool bMid=false; // Have we hit upon a grouped group with a macro? + SdrObject* pMidObj=nullptr; + if (pObj!=pHitObj) + { + SdrObject* pObjTmp=pHitObj->getParentSdrObjectFromSdrObject(); + if (pObjTmp==pObj) pObjTmp=nullptr; + while (pObjTmp!=nullptr) + { + if (pObjTmp->HasMacro()) + { + bMid=true; + pMidObj=pObjTmp; + } + pObjTmp=pObjTmp->getParentSdrObjectFromSdrObject(); + if (pObjTmp==pObj) pObjTmp=nullptr; + } + } + + if (bDeep || bMid || bRoot) + { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos=aLocalLogicPosition; + aHitRec.nTol=mnHitTolLog; + aHitRec.pVisiLayer=&pPV->GetVisibleLayers(); + aHitRec.pPageView=pPV; + if (bDeep) bDeep=pHitObj->IsMacroHit(aHitRec); + if (bMid ) bMid =pMidObj->IsMacroHit(aHitRec); + if (bRoot) bRoot=pObj->IsMacroHit(aHitRec); + if (bRoot || bMid || bDeep) + { + // Priorities: 1. Root, 2. Mid, 3. Deep + rVEvt.mpRootObj = pObj; + if (!bRoot) pObj=pMidObj; + if (!bRoot && !bMid) pObj=pHitObj; + eHit=SdrHitKind::Macro; + } + } + } + // check for URL field + if (eHit==SdrHitKind::UnmarkedObject) + { + SdrTextObj* pTextObj=DynCastSdrTextObj( pHitObj ); + if (pTextObj!=nullptr && pTextObj->HasText()) + { + // use the primitive-based HitTest which is more accurate anyways. It + // will correctly handle rotated/mirrored/sheared/scaled text and can + // now return a HitContainer containing the primitive hierarchy of the + // primitive that triggered the hit. The first entry is that primitive, + // the others are the full stack of primitives leading to that one which + // includes grouping primitives (like TextHierarchyPrimitives we deed here) + // but also all decomposed ones which lead to the creation of that primitive + drawinglayer::primitive2d::Primitive2DContainer aHitContainer; + const bool bTEHit(pPV && SdrObjectPrimitiveHit(*pTextObj, aLocalLogicPosition, {0, 0}, *pPV, &pPV->GetVisibleLayers(), true, &aHitContainer)); + + if (bTEHit && !aHitContainer.empty()) + { + // search for TextHierarchyFieldPrimitive2D which contains the needed information + // about a possible URLField + const drawinglayer::primitive2d::TextHierarchyFieldPrimitive2D* pTextHierarchyFieldPrimitive2D = nullptr; + + for (const drawinglayer::primitive2d::Primitive2DReference& xReference : aHitContainer) + { + auto pBasePrimitive = xReference.get(); + if (pBasePrimitive && pBasePrimitive->getPrimitive2DID() == PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D) + { + pTextHierarchyFieldPrimitive2D = static_cast(pBasePrimitive); + break; + } + } + + if (nullptr != pTextHierarchyFieldPrimitive2D) + { + if (drawinglayer::primitive2d::FieldType::FIELD_TYPE_URL == pTextHierarchyFieldPrimitive2D->getType()) + { + // problem with the old code is that a *pointer* to an instance of + // SvxURLField is set in the Event which is per se not good since that + // data comes from a temporary EditEngine's data and could vanish any + // moment. Have to replace for now with a static instance that gets + // filled/initialized from the original data held in the TextHierarchyField- + // Primitive2D (see impTextBreakupHandler::impCheckFieldPrimitive). + // Unfortunately things like 'TargetFrame' are still used in Calc, so this + // can currently not get replaced. For the future the Name/Value vector or + // the TextHierarchyFieldPrimitive2D itself should/will be used for handling + // that data + static SvxURLField aSvxURLField; + + aSvxURLField.SetURL(pTextHierarchyFieldPrimitive2D->getValue("URL")); + aSvxURLField.SetRepresentation(pTextHierarchyFieldPrimitive2D->getValue("Representation")); + aSvxURLField.SetTargetFrame(pTextHierarchyFieldPrimitive2D->getValue("TargetFrame")); + const OUString aFormat(pTextHierarchyFieldPrimitive2D->getValue("SvxURLFormat")); + + if (!aFormat.isEmpty()) + { + aSvxURLField.SetFormat(static_cast(aFormat.toInt32())); + } + + // set HitKind and pointer to local static instance in the Event + // to comply to old stuff + eHit = SdrHitKind::UrlField; + rVEvt.mpURLField = &aSvxURLField; + } + } + } + } + if (eHit==SdrHitKind::UnmarkedObject && !pHitObj->getHyperlink().isEmpty()) + { + static SvxURLField aSvxURLField; + aSvxURLField.SetURL(pHitObj->getHyperlink()); + rVEvt.mpURLField = &aSvxURLField; + eHit = SdrHitKind::UrlField; + } + } + + if (bHitPassDirect && + (eHit==SdrHitKind::MarkedObject || eHit==SdrHitKind::UnmarkedObject) && + (IsTextTool() || (IsEditMode() && IsQuickTextEditMode())) && pHitObj->HasTextEdit()) + { + auto pTextObj = DynCastSdrTextObj(pHitObj); + + // Around the TextEditArea there's a border to select without going into text edit mode. + tools::Rectangle aBoundRect; + const GeoStat& rGeo = pTextObj->GetGeoStat(); + if (pTextObj && !rGeo.m_nRotationAngle && !rGeo.m_nShearAngle) + { + pTextObj->TakeTextEditArea(nullptr, nullptr, &aBoundRect, nullptr); + } + else + aBoundRect = pHitObj->GetCurrentBoundRect(); + + // Force to SnapRect when Fontwork + if( pTextObj && pTextObj->IsFontwork() ) + aBoundRect = pHitObj->GetSnapRect(); + + sal_Int32 nTolerance(mnHitTolLog); + bool bBoundRectHit(false); + + if(pOut) + { + nTolerance = pOut->PixelToLogic(Size(2, 0)).Width(); + } + + if( (aLocalLogicPosition.X() >= aBoundRect.Left() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Left() + nTolerance) + || (aLocalLogicPosition.X() >= aBoundRect.Right() - nTolerance && aLocalLogicPosition.X() <= aBoundRect.Right() + nTolerance) + || (aLocalLogicPosition.Y() >= aBoundRect.Top() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Top() + nTolerance) + || (aLocalLogicPosition.Y() >= aBoundRect.Bottom() - nTolerance && aLocalLogicPosition.Y() <= aBoundRect.Bottom() + nTolerance)) + { + bBoundRectHit = true; + } + + if(!bBoundRectHit && aBoundRect.Contains(aLocalLogicPosition)) + { + bool bTEHit(pPV + && SdrObjectPrimitiveHit(*pHitObj, aLocalLogicPosition, { 2000.0, 0.0 }, + *pPV, &pPV->GetVisibleLayers(), true)); + + // TextEdit attached to an object in a locked layer + if (bTEHit && pPV->GetLockedLayers().IsSet(pHitObj->GetLayer())) + { + bTEHit=false; + } + + if (bTEHit) + { + rVEvt.mpRootObj=pObj; + pObj=pHitObj; + eHit=SdrHitKind::TextEditObj; + } + } + } + if (!bHitPassDirect && eHit==SdrHitKind::UnmarkedObject) { + eHit=SdrHitKind::NONE; + pObj=nullptr; + pPV=nullptr; + } + bool bMouseLeft = (rVEvt.mnMouseCode & MOUSE_LEFT) != 0; + bool bMouseRight = (rVEvt.mnMouseCode & MOUSE_RIGHT) != 0; + bool bMouseDown = rVEvt.mbMouseDown; + bool bMouseUp = rVEvt.mbMouseUp; + SdrEventKind eEvent=SdrEventKind::NONE; + bool bIsAction=IsAction(); + + if (bIsAction) + { + if (bMouseDown) + { + if (bMouseRight) eEvent=SdrEventKind::BackAction; + } + else if (bMouseUp) + { + if (bMouseLeft) + { + eEvent=SdrEventKind::EndAction; + if (IsDragObj()) + { + eEvent=SdrEventKind::EndDrag; + } + else if (IsCreateObj() || IsInsObjPoint()) + { + eEvent=IsCreateObj() ? SdrEventKind::EndCreate : SdrEventKind::EndInsertObjPoint; + } + else if (IsMarking()) + { + eEvent=SdrEventKind::EndMark; + if (!maDragStat.IsMinMoved()) + { + eEvent=SdrEventKind::BrkMark; + rVEvt.mbAddMark = MODKEY_MultiMark; + } + } + } + } + else + { + eEvent=SdrEventKind::MoveAction; + } + } + else if (eHit==SdrHitKind::TextEdit) + { + eEvent=SdrEventKind::TextEdit; + } + else if (bMouseDown && bMouseLeft) + { + if (rVEvt.mnMouseClicks == 2 && rVEvt.mnMouseCode == MOUSE_LEFT && pObj!=nullptr && pHitObj!=nullptr && pHitObj->HasTextEdit() && eHit==SdrHitKind::MarkedObject) + { + rVEvt.mpRootObj = pObj; + pObj=pHitObj; + eEvent=SdrEventKind::BeginTextEdit; + } + else if (MODKEY_ForceMark && eHit!=SdrHitKind::UrlField) + { + eEvent=SdrEventKind::BeginMark; // AddMark,Unmark */ + } + else if (eHit==SdrHitKind::HelpLine) + { + eEvent=SdrEventKind::BeginDragHelpline; // nothing, actually + } + else if (eHit==SdrHitKind::Gluepoint) + { + eEvent=SdrEventKind::MarkGluePoint; // AddMark+Drag + rVEvt.mbAddMark = MODKEY_MultiMark || MODKEY_DeepMark; // if not hit with Deep + } + else if (eHit==SdrHitKind::Handle) + { + eEvent=SdrEventKind::BeginDragObj; // Mark+Drag,AddMark+Drag,DeepMark+Drag,Unmark + bool bGlue=pHdl->GetKind()==SdrHdlKind::Glue; + bool bPoly=!bGlue && IsPointMarkable(*pHdl); + bool bMarked=bGlue || (bPoly && pHdl->IsSelected()); + if (bGlue || bPoly) + { + eEvent=bGlue ? SdrEventKind::MarkGluePoint : SdrEventKind::MarkPoint; + if (MODKEY_DeepMark) + { + rVEvt.mbAddMark = true; + rVEvt.mbPrevNextMark = true; + rVEvt.mbMarkPrev = MODKEY_DeepBackw; + } + else if (MODKEY_MultiMark) + { + rVEvt.mbAddMark = true; + rVEvt.mbUnmark = bMarked; // Toggle + if (bGlue) + { + pObj=pHdl->GetObj(); + nGlueId=static_cast(pHdl->GetObjHdlNum()); + } + } + else if (bMarked) + { + eEvent=SdrEventKind::BeginDragObj; // don't change MarkState, only change Drag + } + } + } + else if (bInsPolyPt && (MODKEY_PolyPoly || (!MODKEY_MultiMark && !MODKEY_DeepMark))) + { + eEvent=SdrEventKind::BeginInsertObjPoint; + } + else if (bInsGluePt && !MODKEY_MultiMark && !MODKEY_DeepMark) + { + eEvent=SdrEventKind::BeginInsertGluePoint; + } + else if (eHit==SdrHitKind::TextEditObj) + { + eEvent=SdrEventKind::BeginTextEdit; // AddMark+Drag,DeepMark+Drag,Unmark + if (MODKEY_MultiMark || MODKEY_DeepMark) + { // if not hit with Deep + eEvent=SdrEventKind::MarkObj; + } + } + else if (eHit==SdrHitKind::Macro) + { + eEvent=SdrEventKind::BeginMacroObj; // AddMark+Drag + if (MODKEY_MultiMark || MODKEY_DeepMark) + { // if not hit with Deep + eEvent=SdrEventKind::MarkObj; + } + } + else if (eHit==SdrHitKind::UrlField) + { + eEvent=SdrEventKind::ExecuteUrl; // AddMark+Drag + if (MODKEY_MultiMark || MODKEY_DeepMark) + { // if not hit with Deep + eEvent=SdrEventKind::MarkObj; + } + } + else if (eHit==SdrHitKind::MarkedObject) + { + eEvent=SdrEventKind::BeginDragObj; // DeepMark+Drag,Unmark + + if (MODKEY_MultiMark || MODKEY_DeepMark) + { // if not hit with Deep + eEvent=SdrEventKind::MarkObj; + } + } + else if (IsCreateMode()) + { + eEvent=SdrEventKind::BeginCreateObj; // nothing, actually + } + else if (eHit==SdrHitKind::UnmarkedObject) + { + eEvent=SdrEventKind::MarkObj; // AddMark+Drag + } + else + { + eEvent=SdrEventKind::BeginMark; + } + + if (eEvent==SdrEventKind::MarkObj) + { + rVEvt.mbAddMark = MODKEY_MultiMark || MODKEY_DeepMark; // if not hit with Deep + rVEvt.mbPrevNextMark = MODKEY_DeepMark; + rVEvt.mbMarkPrev = MODKEY_DeepMark && MODKEY_DeepBackw; + } + if (eEvent==SdrEventKind::BeginMark) + { + rVEvt.mbAddMark = MODKEY_MultiMark; + rVEvt.mbUnmark = MODKEY_Unmark; + } + } + rVEvt.mbIsAction = bIsAction; + rVEvt.mbIsTextEdit = bIsTextEdit; + rVEvt.maLogicPos = aLocalLogicPosition; + rVEvt.mpHdl = pHdl; + rVEvt.mpObj = pObj; + if (rVEvt.mpRootObj == nullptr) + rVEvt.mpRootObj = pObj; + rVEvt.mpPV = pPV; + rVEvt.mnHlplIdx = nHlplIdx; + rVEvt.mnGlueId = nGlueId; + rVEvt.meHit = eHit; + rVEvt.meEvent = eEvent; +#ifdef DGB_UTIL + if (rVEvt.mpRootObj != nullptr) + { + if (rVEvt.mpRootObj->getParentSdrObjListFromSdrObject() != rVEvt.mpPV->GetObjList()) + { + OSL_FAIL("SdrView::PickAnything(): pRootObj->getParentSdrObjListFromSdrObject()!=pPV->GetObjList() !"); + } + } +#endif + return eHit; +} + +bool SdrView::DoMouseEvent(const SdrViewEvent& rVEvt) +{ + bool bRet=false; + SdrHitKind eHit = rVEvt.meHit; + Point aLogicPos(rVEvt.maLogicPos); + + bool bShift = (rVEvt.mnMouseCode & KEY_SHIFT) != 0; + bool bCtrl = (rVEvt.mnMouseCode & KEY_MOD1) != 0; + bool bAlt = (rVEvt.mnMouseCode & KEY_MOD2) != 0; + bool bMouseLeft = (rVEvt.mnMouseCode & MOUSE_LEFT) != 0; + bool bMouseDown = rVEvt.mbMouseDown; + bool bMouseUp = rVEvt.mbMouseUp; + if (bMouseDown) { + if (bMouseLeft) maDragStat.SetMouseDown(true); + } else if (bMouseUp) { + if (bMouseLeft) maDragStat.SetMouseDown(false); + } else { // else, MouseMove + maDragStat.SetMouseDown(bMouseLeft); + } + +#ifdef MODKEY_NoSnap + SetSnapEnabled(!MODKEY_NoSnap); +#endif +#ifdef MODKEY_Ortho + SetOrtho(MODKEY_Ortho!=IsOrthoDesired()); +#endif +#ifdef MODKEY_AngleSnap + SetAngleSnapEnabled(MODKEY_AngleSnap); +#endif +#ifdef MODKEY_CopyDrag + SetDragWithCopy(MODKEY_CopyDrag); +#endif +#ifdef MODKEY_Center + SetCreate1stPointAsCenter(MODKEY_Center); + SetResizeAtCenter(MODKEY_Center); + SetCrookAtCenter(MODKEY_Center); +#endif + if (bMouseLeft && bMouseDown && rVEvt.mbIsTextEdit && (eHit==SdrHitKind::UnmarkedObject || eHit==SdrHitKind::NONE)) { + SdrEndTextEdit(); // User has clicked beneath object, exit edit mode. + // pHdl is invalid, then, that shouldn't matter, though, as we expect + // pHdl==NULL (because of eHit). + } + switch (rVEvt.meEvent) + { + case SdrEventKind::NONE: bRet=false; break; + case SdrEventKind::TextEdit: bRet=false; break; // Events handled by the OutlinerView are not taken into account here. + case SdrEventKind::MoveAction: MovAction(aLogicPos); bRet=true; break; + case SdrEventKind::EndAction: EndAction(); bRet=true; break; + case SdrEventKind::BackAction: BckAction(); bRet=true; break; + case SdrEventKind::EndMark : EndAction(); bRet=true; break; + case SdrEventKind::BrkMark : { + BrkAction(); + if (!MarkObj(aLogicPos, mnHitTolLog, rVEvt.mbAddMark)) + { + // No object hit. Do the following: + // 1. deselect any selected gluepoints + // 2. deselect any selected polygon points + // 3. deselect any selected objects + if (!rVEvt.mbAddMark) UnmarkAll(); + } + bRet=true; + } break; + case SdrEventKind::EndCreate: { // if necessary, MarkObj + SdrCreateCmd eCmd=SdrCreateCmd::NextPoint; + if (MODKEY_PolyPoly) eCmd=SdrCreateCmd::NextObject; + if (rVEvt.mnMouseClicks > 1) eCmd=SdrCreateCmd::ForceEnd; + if (!EndCreateObj(eCmd)) { // Don't evaluate event for Create? -> Select + if (eHit==SdrHitKind::UnmarkedObject || eHit==SdrHitKind::TextEdit) { + MarkObj(rVEvt.mpRootObj, rVEvt.mpPV); + if (eHit==SdrHitKind::TextEdit) + { + bool bRet2(mpActualOutDev && OUTDEV_WINDOW == mpActualOutDev->GetOutDevType() && + SdrBeginTextEdit(rVEvt.mpObj, rVEvt.mpPV, mpActualOutDev->GetOwnerWindow())); + + if(bRet2) + { + MouseEvent aMEvt(mpActualOutDev->LogicToPixel(aLogicPos), 1, + rVEvt.mnMouseMode,rVEvt.mnMouseCode,rVEvt.mnMouseCode); + + OutlinerView* pOLV=GetTextEditOutlinerView(); + if (pOLV!=nullptr) { + pOLV->MouseButtonDown(aMEvt); // event for the Outliner, but without double-click + pOLV->MouseButtonUp(aMEvt); // event for the Outliner, but without double-click + } + } + } + bRet=true; // object is selected and (if necessary) TextEdit is started + } else bRet=false; // canceled Create, nothing else + } else bRet=true; // return true for EndCreate + } break; + case SdrEventKind::EndDrag: { + bRet=EndDragObj(IsDragWithCopy()); + ForceMarkedObjToAnotherPage(); // TODO: Undo+bracing missing! + } break; + case SdrEventKind::MarkObj: { // + (if applicable) BegDrag + if (!rVEvt.mbAddMark) UnmarkAllObj(); + bool bUnmark = rVEvt.mbUnmark; + if (rVEvt.mbPrevNextMark) { + bRet=MarkNextObj(aLogicPos, mnHitTolLog, rVEvt.mbMarkPrev); + } else { + SortMarkedObjects(); + const size_t nCount0=GetMarkedObjectCount(); + bRet=MarkObj(aLogicPos, mnHitTolLog, rVEvt.mbAddMark); + SortMarkedObjects(); + const size_t nCount1=GetMarkedObjectCount(); + bUnmark=nCount1 1) eCmd = SdrCreateCmd::ForceEnd; + EndInsObjPoint(eCmd); + bRet=true; + } break; + case SdrEventKind::BeginInsertGluePoint: bRet=BegInsGluePoint(aLogicPos); break; + case SdrEventKind::BeginDragHelpline: bRet = BegDragHelpLine(rVEvt.mnHlplIdx,rVEvt.mpPV); break; + case SdrEventKind::BeginDragObj: bRet=BegDragObj(aLogicPos, nullptr, rVEvt.mpHdl, mnMinMovLog); break; + case SdrEventKind::BeginCreateObj: { + if (mnCurrentInvent==SdrInventor::Default && mnCurrentIdent==SdrObjKind::Caption) { + tools::Long nHgt=SdrEngineDefaults::GetFontHeight(); + bRet=BegCreateCaptionObj(aLogicPos,Size(5*nHgt,2*nHgt)); + } else bRet=BegCreateObj(aLogicPos); + } break; + case SdrEventKind::BeginMacroObj: { + BegMacroObj(aLogicPos, mnHitTolLog, rVEvt.mpObj, rVEvt.mpPV, mpActualOutDev->GetOwnerWindow()); + bRet=false; + } break; + case SdrEventKind::BeginTextEdit: { + if (!IsObjMarked(rVEvt.mpObj)) { + UnmarkAllObj(); + MarkObj(rVEvt.mpRootObj,rVEvt.mpPV); + } + + bRet = mpActualOutDev && OUTDEV_WINDOW == mpActualOutDev->GetOutDevType()&& + SdrBeginTextEdit(rVEvt.mpObj, rVEvt.mpPV, mpActualOutDev->GetOwnerWindow()); + + if(bRet) + { + MouseEvent aMEvt(mpActualOutDev->LogicToPixel(aLogicPos), + 1, rVEvt.mnMouseMode, rVEvt.mnMouseCode, rVEvt.mnMouseCode); + OutlinerView* pOLV=GetTextEditOutlinerView(); + if (pOLV!=nullptr) pOLV->MouseButtonDown(aMEvt); // event for the Outliner, but without double-click + } + } break; + default: break; + } // switch + if (bRet && mpActualOutDev && mpActualOutDev->GetOutDevType()==OUTDEV_WINDOW) { + vcl::Window* pWin=mpActualOutDev->GetOwnerWindow(); + // left mouse button pressed? + bool bLeftDown = (rVEvt.mnMouseCode & MOUSE_LEFT) != 0 && rVEvt.mbMouseDown; + // left mouse button released? + bool bLeftUp = (rVEvt.mnMouseCode & MOUSE_LEFT) != 0 && rVEvt.mbMouseUp; + // left mouse button pressed or held? + bool bLeftDown1=(rVEvt.mnMouseCode & MOUSE_LEFT) != 0 && !rVEvt.mbMouseUp; + pWin->SetPointer(GetPreferredPointer(rVEvt.maLogicPos, pWin->GetOutDev(), + rVEvt.mnMouseCode & (KEY_SHIFT|KEY_MOD1|KEY_MOD2),bLeftDown1)); + bool bAction=IsAction(); + if (bLeftDown && bAction) + pWin->CaptureMouse(); + else if (bLeftUp || (rVEvt.mbIsAction && !bAction)) + pWin->ReleaseMouse(); + } + return bRet; +} + +PointerStyle SdrView::GetPreferredPointer(const Point& rMousePos, const OutputDevice* pOut, sal_uInt16 nModifier, bool bLeftDown) const +{ + // Actions + if (IsCreateObj()) + { + return mpCurrentCreate->GetCreatePointer(); + } + if (mpCurrentSdrDragMethod) + { + return mpCurrentSdrDragMethod->GetSdrDragPointer(); + } + if (IsMarkObj() || IsMarkPoints() || IsMarkGluePoints() || IsSetPageOrg()) return PointerStyle::Arrow; + if (IsDragHelpLine()) return GetDraggedHelpLinePointer(); + if (IsMacroObj()) { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos=pOut->LogicToPixel(rMousePos); + aHitRec.nTol=nMacroTol; + aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers(); + aHitRec.pPageView=pMacroPV; + return pMacroObj->GetMacroPointer(aHitRec); + } + + // TextEdit, ObjEdit, Macro + if (IsTextEdit() && (IsTextEditInSelectionMode() || IsTextEditHit(rMousePos))) + { + if(!pOut || IsTextEditInSelectionMode()) + { + if (mpTextEditOutliner->IsVertical()) + return PointerStyle::TextVertical; + else + return PointerStyle::Text; + } + // Outliner should return something here... + Point aPos(pOut->LogicToPixel(rMousePos)); + PointerStyle aPointer(mpTextEditOutlinerView->GetPointer(aPos)); + if (aPointer==PointerStyle::Arrow) + { + if (mpTextEditOutliner->IsVertical()) + aPointer = PointerStyle::TextVertical; + else + aPointer = PointerStyle::Text; + } + return aPointer; + } + + SdrViewEvent aVEvt; + aVEvt.mnMouseCode = (nModifier&(KEY_SHIFT|KEY_MOD1|KEY_MOD2))|MOUSE_LEFT; // to see what would happen on MouseLeftDown + aVEvt.mbMouseDown = !bLeftDown; // What if ..? + aVEvt.mbMouseUp = bLeftDown; // What if ..? + if (pOut!=nullptr) + const_cast(this)->SetActualWin(pOut); + SdrHitKind eHit=PickAnything(rMousePos,aVEvt); + SdrEventKind eEvent = aVEvt.meEvent; + switch (eEvent) + { + case SdrEventKind::BeginCreateObj: + return maCurrentCreatePointer; + case SdrEventKind::MarkObj: + return PointerStyle::Move; + case SdrEventKind::BeginMark: + return PointerStyle::Arrow; + case SdrEventKind::MarkPoint: + case SdrEventKind::MarkGluePoint: + return PointerStyle::MovePoint; + case SdrEventKind::BeginInsertObjPoint: + case SdrEventKind::BeginInsertGluePoint: + return PointerStyle::Cross; + case SdrEventKind::ExecuteUrl: + return PointerStyle::RefHand; + case SdrEventKind::BeginMacroObj: + { + SdrObjMacroHitRec aHitRec; + aHitRec.aPos = aVEvt.maLogicPos; + aHitRec.nTol=mnHitTolLog; + aHitRec.pVisiLayer = &aVEvt.mpPV->GetVisibleLayers(); + aHitRec.pPageView = aVEvt.mpPV; + return aVEvt.mpObj->GetMacroPointer(aHitRec); + } + default: break; + } // switch + + switch(eHit) + { + case SdrHitKind::Cell: + return PointerStyle::Arrow; + case SdrHitKind::HelpLine : + return aVEvt.mpPV->GetHelpLines()[aVEvt.mnHlplIdx].GetPointer(); + case SdrHitKind::Gluepoint: + return PointerStyle::MovePoint; + case SdrHitKind::TextEdit : + case SdrHitKind::TextEditObj: + { + SdrTextObj* pText = DynCastSdrTextObj(aVEvt.mpObj); + if(pText && pText->HasText()) + { + OutlinerParaObject* pParaObj = pText->GetOutlinerParaObject(); + if(pParaObj && pParaObj->IsEffectivelyVertical()) + return PointerStyle::TextVertical; + } + return PointerStyle::Text; + } + default: break; + } + + bool bMarkHit=eHit==SdrHitKind::MarkedObject; + SdrHdl* pHdl = aVEvt.mpHdl; + // now check the pointers for dragging + if (pHdl!=nullptr || bMarkHit) { + SdrHdlKind eHdl= pHdl!=nullptr ? pHdl->GetKind() : SdrHdlKind::Move; + bool bCorner=pHdl!=nullptr && pHdl->IsCornerHdl(); + bool bVertex=pHdl!=nullptr && pHdl->IsVertexHdl(); + bool bMov=eHdl==SdrHdlKind::Move; + if (bMov && (meDragMode==SdrDragMode::Move || meDragMode==SdrDragMode::Resize || mbMarkedHitMovesAlways)) { + if (!IsMoveAllowed()) return PointerStyle::Arrow; // because double click or drag & drop is possible + return PointerStyle::Move; + } + switch (meDragMode) { + case SdrDragMode::Rotate: { + if ((bCorner || bMov) && !IsRotateAllowed(true)) + return PointerStyle::NotAllowed; + + // are 3D objects selected? + bool b3DObjSelected = false; + for (size_t a=0; !b3DObjSelected && aGetPos()-pH1->GetPos(); + b90=(aDif.X()==0) || aDif.Y()==0; + b45=b90 || (std::abs(aDif.X())==std::abs(aDif.Y())); + } + bool bNo=false; + if (!IsMirrorAllowed(true,true)) bNo=true; // any mirroring is forbidden + if (!IsMirrorAllowed() && !b45) bNo=true; // mirroring freely is forbidden + if (!IsMirrorAllowed(true) && !b90) bNo=true; // mirroring horizontally/vertically is allowed + if (bNo) return PointerStyle::NotAllowed; + if (b90) { + return PointerStyle::Mirror; + } + return PointerStyle::Mirror; + } + } break; + + case SdrDragMode::Transparence: + { + if(!IsTransparenceAllowed()) + return PointerStyle::NotAllowed; + + return PointerStyle::RefHand; + } + + case SdrDragMode::Gradient: + { + if(!IsGradientAllowed()) + return PointerStyle::NotAllowed; + + return PointerStyle::RefHand; + } + + case SdrDragMode::Crook: { + if (bCorner || bVertex || bMov) { + if (!IsCrookAllowed(true) && !IsCrookAllowed()) return PointerStyle::NotAllowed; + return PointerStyle::Crook; + } + break; + } + + case SdrDragMode::Crop: + { + return PointerStyle::Crop; + } + + default: { + if ((bCorner || bVertex) && !IsResizeAllowed(true)) return PointerStyle::NotAllowed; + } + } + if (pHdl!=nullptr) return pHdl->GetPointer(); + if (bMov) { + if (!IsMoveAllowed()) return PointerStyle::Arrow; // because double click or drag & drop is possible + return PointerStyle::Move; + } + } + if (meEditMode==SdrViewEditMode::Create) return maCurrentCreatePointer; + return PointerStyle::Arrow; +} + +constexpr OUString STR_NOTHING = u"nothing"_ustr; +OUString SdrView::GetStatusText() +{ + OUString aName; + OUString aStr = STR_NOTHING; + + if (mpCurrentCreate!=nullptr) + { + aStr=mpCurrentCreate->getSpecialDragComment(maDragStat); + + if(aStr.isEmpty()) + { + aName = mpCurrentCreate->TakeObjNameSingul(); + aStr = SvxResId(STR_ViewCreateObj); + } + } + else if (mpCurrentSdrDragMethod) + { + if (mbInsPolyPoint || IsInsertGluePoint()) + { + aStr=maInsPointUndoStr; + } + else + { + if (maDragStat.IsMinMoved()) + { + SAL_INFO( + "svx.svdraw", + "(" << this << ") " << mpCurrentSdrDragMethod.get()); + aStr = mpCurrentSdrDragMethod->GetSdrDragComment(); + } + } + } + else if(IsMarkObj()) + { + if(AreObjectsMarked()) + { + aStr = SvxResId(STR_ViewMarkMoreObjs); + } + else + { + aStr = SvxResId(STR_ViewMarkObjs); + } + } + else if(IsMarkPoints()) + { + if(HasMarkedPoints()) + { + aStr = SvxResId(STR_ViewMarkMorePoints); + } + else + { + aStr = SvxResId(STR_ViewMarkPoints); + } + } else if (IsMarkGluePoints()) + { + if(HasMarkedGluePoints()) + { + aStr = SvxResId(STR_ViewMarkMoreGluePoints); + } + else + { + aStr = SvxResId(STR_ViewMarkGluePoints); + } + } + else if (IsTextEdit() && mpTextEditOutlinerView != nullptr) { + aStr=SvxResId(STR_ViewTextEdit); // "TextEdit - Row y, Column x"; + ESelection aSel(mpTextEditOutlinerView->GetSelection()); + tools::Long nPar = aSel.nEndPara,nLin=0,nCol=aSel.nEndPos; + if (aSel.nEndPara>0) { + for (sal_Int32 nParaNum=0; nParaNumGetLineCount(nParaNum); + } + } + // A little imperfection: + // At the end of a line of any multi-line paragraph, we display the + // position of the next line of the same paragraph, if there is one. + sal_uInt16 nParaLine = 0; + sal_uLong nParaLineCount = mpTextEditOutliner->GetLineCount(aSel.nEndPara); + bool bBrk = false; + while (!bBrk) + { + sal_uInt16 nLen = mpTextEditOutliner->GetLineLen(aSel.nEndPara, nParaLine); + bool bLastLine = (nParaLine == nParaLineCount - 1); + if (nCol>nLen || (!bLastLine && nCol == nLen)) + { + nCol -= nLen; + nLin++; + nParaLine++; + } + else + bBrk = true; + + if (nLen == 0) + bBrk = true; // to be sure + } + + aStr = aStr.replaceFirst("%1", OUString::number(nPar + 1)); + aStr = aStr.replaceFirst("%2", OUString::number(nLin + 1)); + aStr = aStr.replaceFirst("%3", OUString::number(nCol + 1)); + +#ifdef DBG_UTIL + aStr += ", Level " + OUString::number(mpTextEditOutliner->GetDepth( aSel.nEndPara )); +#endif + } + + if(aStr == STR_NOTHING) + { + if (AreObjectsMarked()) { + aStr = ImpGetDescriptionString(STR_ViewMarked); + if (IsGluePointEditMode()) { + if (HasMarkedGluePoints()) { + aStr = ImpGetDescriptionString(STR_ViewMarked, ImpGetDescriptionOptions::GLUEPOINTS); + } + } else { + if (HasMarkedPoints()) { + aStr = ImpGetDescriptionString(STR_ViewMarked, ImpGetDescriptionOptions::POINTS); + } + } + } else { + aStr.clear(); + } + } + else if(!aName.isEmpty()) + { + aStr = aStr.replaceFirst("%1", aName); + } + + if(!aStr.isEmpty()) + { + // capitalize first letter + aStr = aStr.replaceAt(0, 1, OUString(aStr[0]).toAsciiUpperCase()); + } + return aStr; +} + +SdrViewContext SdrView::GetContext() const +{ + if( IsGluePointEditMode() ) + return SdrViewContext::GluePointEdit; + + const size_t nMarkCount = GetMarkedObjectCount(); + + if( HasMarkablePoints() && !IsFrameHandles() ) + { + bool bPath=true; + for( size_t nMarkNum = 0; nMarkNum < nMarkCount && bPath; ++nMarkNum ) + if (dynamic_cast(GetMarkedObjectByIndex(nMarkNum)) == nullptr) + bPath=false; + + if( bPath ) + return SdrViewContext::PointEdit; + } + + if( GetMarkedObjectCount() ) + { + bool bGraf = true, bMedia = true, bTable = true; + + for( size_t nMarkNum = 0; nMarkNum < nMarkCount && ( bGraf || bMedia ); ++nMarkNum ) + { + const SdrObject* pMarkObj = GetMarkedObjectByIndex( nMarkNum ); + DBG_ASSERT( pMarkObj, "SdrView::GetContext(), null pointer in mark list!" ); + + if( !pMarkObj ) + continue; + + if( dynamic_cast( pMarkObj) == nullptr ) + bGraf = false; + + if( dynamic_cast( pMarkObj) == nullptr ) + bMedia = false; + + if( dynamic_cast( pMarkObj ) == nullptr ) + bTable = false; + } + + if( bGraf ) + return SdrViewContext::Graphic; + else if( bMedia ) + return SdrViewContext::Media; + else if( bTable ) + return SdrViewContext::Table; + } + + return SdrViewContext::Standard; +} + +void SdrView::MarkAll() +{ + if (IsTextEdit()) { + GetTextEditOutlinerView()->SetSelection(ESelection(0,0,EE_PARA_ALL,EE_TEXTPOS_ALL)); + } else if (IsGluePointEditMode()) MarkAllGluePoints(); + else if (HasMarkablePoints()) MarkAllPoints(); + else { + // check for table + bool bMarkAll = true; + const SdrMarkList& rMarkList = GetMarkedObjectList(); + if (rMarkList.GetMarkCount() == 1) + { + const SdrObject* pObj(rMarkList.GetMark(0)->GetMarkedSdrObj()); + SdrView* pView = this; + if (pObj && pView && (pObj->GetObjInventor() == SdrInventor::Default) + && (pObj->GetObjIdentifier() == SdrObjKind::Table)) + { + mxSelectionController.clear(); + mxSelectionController = sdr::table::CreateTableController( + *pView, static_cast(*pObj), + mxLastSelectionController); + + if (mxSelectionController.is()) + { + mxLastSelectionController.clear(); + mxSelectionController->onSelectAll(); + bMarkAll = false; + } + } + } + if ( bMarkAll ) + MarkAllObj(); + } +} + +void SdrView::UnmarkAll() +{ + if (IsTextEdit()) { + ESelection eSel=GetTextEditOutlinerView()->GetSelection(); + eSel.nStartPara=eSel.nEndPara; + eSel.nStartPos=eSel.nEndPos; + GetTextEditOutlinerView()->SetSelection(eSel); + } else if (HasMarkedGluePoints()) UnmarkAllGluePoints(); + else if (HasMarkedPoints()) UnmarkAllPoints(); // Marked, not Markable! + else UnmarkAllObj(); +} + +const tools::Rectangle& SdrView::GetMarkedRect() const +{ + if (IsGluePointEditMode() && HasMarkedGluePoints()) { + return GetMarkedGluePointsRect(); + } + if (HasMarkedPoints()) { + return GetMarkedPointsRect(); + } + return GetMarkedObjRect(); +} + +void SdrView::DeleteMarked() +{ + if (IsTextEdit()) + { + SdrObjEditView::KeyInput(KeyEvent(0, vcl::KeyCode(KeyFuncType::DELETE)), mpTextEditWin); + } + else + { + if( mxSelectionController.is() && mxSelectionController->DeleteMarked() ) + { + // action already performed by current selection controller, do nothing + } + else if (IsGluePointEditMode() && HasMarkedGluePoints()) + { + DeleteMarkedGluePoints(); + } + else if (GetContext()==SdrViewContext::PointEdit && HasMarkedPoints()) + { + DeleteMarkedPoints(); + } + else + { + DeleteMarkedObj(); + } + } +} + +bool SdrView::BegMark(const Point& rPnt, bool bAddMark, bool bUnmark) +{ + if (bUnmark) bAddMark=true; + if (IsGluePointEditMode()) { + if (!bAddMark) UnmarkAllGluePoints(); + return BegMarkGluePoints(rPnt,bUnmark); + } else if (HasMarkablePoints()) { + if (!bAddMark) UnmarkAllPoints(); + return BegMarkPoints(rPnt,bUnmark); + } else { + if (!bAddMark) UnmarkAllObj(); + BegMarkObj(rPnt,bUnmark); + return true; + } +} + +bool SdrView::MoveShapeHandle(const sal_uInt32 handleNum, const Point& aEndPoint, const sal_Int32 aObjectOrdNum) +{ + if (GetHdlList().IsMoveOutside()) + return false; + + if (!GetMarkedObjectList().GetMarkCount()) + return false; + + SdrHdl * pHdl = GetHdlList().GetHdl(handleNum); + if (pHdl == nullptr) + return false; + + SdrDragStat& rDragStat = const_cast(GetDragStat()); + // start dragging + BegDragObj(pHdl->GetPos(), nullptr, pHdl, 0); + if (!IsDragObj()) + return false; + + bool bWasNoSnap = rDragStat.IsNoSnap(); + bool bWasSnapEnabled = IsSnapEnabled(); + + // switch snapping off + if(!bWasNoSnap) + rDragStat.SetNoSnap(); + if(bWasSnapEnabled) + SetSnapEnabled(false); + + if (aObjectOrdNum != -1) + { + rDragStat.GetGlueOptions().objectOrdNum = aObjectOrdNum; + } + MovDragObj(aEndPoint); + EndDragObj(); + + // Clear Glue Options + rDragStat.GetGlueOptions().objectOrdNum = -1; + + if (!bWasNoSnap) + rDragStat.SetNoSnap(bWasNoSnap); + if (bWasSnapEnabled) + SetSnapEnabled(bWasSnapEnabled); + + return true; +} + +void SdrView::ConfigurationChanged( ::utl::ConfigurationBroadcaster*p, ConfigurationHints nHint) +{ + onAccessibilityOptionsChanged(); + SdrCreateView::ConfigurationChanged(p, nHint); +} + + +/** method is called whenever the global SvtAccessibilityOptions is changed */ +void SdrView::onAccessibilityOptionsChanged() +{ +} + +void SdrView::SetMasterPagePaintCaching(bool bOn) +{ + if(mbMasterPagePaintCaching == bOn) + return; + + mbMasterPagePaintCaching = bOn; + + // reset at all SdrPageWindows + SdrPageView* pPageView = GetSdrPageView(); + + if(!pPageView) + return; + + for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++) + { + SdrPageWindow* pPageWindow = pPageView->GetPageWindow(b); + assert(pPageWindow && "SdrView::SetMasterPagePaintCaching: Corrupt SdrPageWindow list (!)"); + + // force deletion of ObjectContact, so at re-display all VOCs + // will be re-created with updated flag setting + pPageWindow->ResetObjectContact(); + } + + // force redraw of this view + pPageView->InvalidateAllWin(); +} + +// Default ObjectContact is ObjectContactOfPageView +sdr::contact::ObjectContact* SdrView::createViewSpecificObjectContact( + SdrPageWindow& rPageWindow, + const char* pDebugName) const +{ + return new sdr::contact::ObjectContactOfPageView(rPageWindow, pDebugName); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdviter.cxx b/svx/source/svdraw/svdviter.cxx new file mode 100644 index 0000000000..65450efb42 --- /dev/null +++ b/svx/source/svdraw/svdviter.cxx @@ -0,0 +1,126 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include + +static bool ImpCheckPageView(const SdrPage* pPage, const SdrObject* pObject, SdrPageView const* pPV) +{ + if (!pPage) + return true; + + bool bMaster(pPage->IsMasterPage()); + SdrPage* pPg = pPV->GetPage(); + + if (pPg == pPage) + { + if (pObject) + { + // Looking for an object? First, determine if it visible in + // this PageView. + return pObject->isVisibleOnAnyOfTheseLayers(pPV->GetVisibleLayers()); + } + else + { + return true; + } + } + else if (bMaster && (!pObject || !pObject->IsNotVisibleAsMaster())) + { + if (pPg->TRG_HasMasterPage()) + { + SdrPage& rMasterPage = pPg->TRG_GetMasterPage(); + + if (&rMasterPage == pPage) + { + // the page we're looking for is a master page in this PageView + if (pObject) + { + // Looking for an object? First, determine if it visible in + // this PageView. + SdrLayerIDSet aObjLay = pPV->GetVisibleLayers(); + aObjLay &= pPg->TRG_GetMasterPageVisibleLayers(); + if (pObject->isVisibleOnAnyOfTheseLayers(aObjLay)) + { + return true; + } // else, look at the next master page of this page... + } + else + { + return true; + } + } + } + } + + // master page forbidden or no fitting master page found + return false; +} + +namespace SdrViewIter +{ +void ForAllViews(const SdrPage* pPage, std::function f) +{ + if (!pPage) + return; + const SdrModel* pModel = &pPage->getSdrModelFromSdrPage(); + + pModel->ForAllListeners([&pPage, &f](SfxListener* pLs) { + if (!pLs->IsSdrView()) + return false; + SdrView* pCurrentView = static_cast(pLs); + SdrPageView* pPV = pCurrentView->GetSdrPageView(); + + if (pPV && ImpCheckPageView(pPage, nullptr, pPV)) + { + f(pCurrentView); + } + return false; + }); +} + +void ForAllViews(const SdrObject* pObject, std::function f) +{ + if (!pObject) + return; + const SdrModel* pModel = &pObject->getSdrModelFromSdrObject(); + const SdrPage* pPage = pObject->getSdrPageFromSdrObject(); + if (!pPage) + return; + + pModel->ForAllListeners([&pPage, &pObject, &f](SfxListener* pLs) { + if (!pLs->IsSdrView()) + return false; + SdrView* pCurrentView = static_cast(pLs); + SdrPageView* pPV = pCurrentView->GetSdrPageView(); + + if (pPV && ImpCheckPageView(pPage, pObject, pPV)) + { + f(pCurrentView); + } + return false; + }); +} +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/svdxcgv.cxx b/svx/source/svdraw/svdxcgv.cxx new file mode 100644 index 0000000000..050a997077 --- /dev/null +++ b/svx/source/svdraw/svdxcgv.cxx @@ -0,0 +1,791 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star; + +SdrExchangeView::SdrExchangeView( + SdrModel& rSdrModel, + OutputDevice* pOut) +: SdrObjEditView(rSdrModel, pOut) +{ +} + +bool SdrExchangeView::ImpLimitToWorkArea(Point& rPt) const +{ + bool bRet(false); + + if(!maMaxWorkArea.IsEmpty()) + { + if(rPt.X()maMaxWorkArea.Right()) + { + rPt.setX( maMaxWorkArea.Right() ); + bRet = true; + } + + if(rPt.Y()maMaxWorkArea.Bottom()) + { + rPt.setY( maMaxWorkArea.Bottom() ); + bRet = true; + } + } + return bRet; +} + +void SdrExchangeView::ImpGetPasteObjList(Point& /*rPos*/, SdrObjList*& rpLst) +{ + if (rpLst==nullptr) + { + SdrPageView* pPV = GetSdrPageView(); + + if (pPV!=nullptr) { + rpLst=pPV->GetObjList(); + } + } +} + +bool SdrExchangeView::ImpGetPasteLayer(const SdrObjList* pObjList, SdrLayerID& rLayer) const +{ + bool bRet=false; + rLayer=SdrLayerID(0); + if (pObjList!=nullptr) { + const SdrPage* pPg=pObjList->getSdrPageFromSdrObjList(); + if (pPg!=nullptr) { + rLayer=pPg->GetLayerAdmin().GetLayerID(maActualLayer); + if (rLayer==SDRLAYER_NOTFOUND) rLayer=SdrLayerID(0); + SdrPageView* pPV = GetSdrPageView(); + if (pPV!=nullptr) { + bRet=!pPV->GetLockedLayers().IsSet(rLayer) && pPV->GetVisibleLayers().IsSet(rLayer); + } + } + } + return bRet; +} + +bool SdrExchangeView::Paste(const OUString& rStr, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions) +{ + if (rStr.isEmpty()) + return false; + + Point aPos(rPos); + ImpGetPasteObjList(aPos,pLst); + ImpLimitToWorkArea( aPos ); + if (pLst==nullptr) return false; + SdrLayerID nLayer; + if (!ImpGetPasteLayer(pLst,nLayer)) return false; + bool bUnmark = (nOptions & (SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit(); + if (bUnmark) UnmarkAllObj(); + tools::Rectangle aTextRect(0,0,500,500); + SdrPage* pPage=pLst->getSdrPageFromSdrObjList(); + if (pPage!=nullptr) { + aTextRect.SetSize(pPage->GetSize()); + } + rtl::Reference pObj = new SdrRectObj( + getSdrModelFromSdrView(), + SdrObjKind::Text, + aTextRect); + + pObj->SetLayer(nLayer); + pObj->NbcSetText(rStr); // SetText before SetAttr, else SetAttr doesn't work! + if (mpDefaultStyleSheet!=nullptr) pObj->NbcSetStyleSheet(mpDefaultStyleSheet, false); + + pObj->SetMergedItemSet(maDefaultAttr); + + SfxItemSet aTempAttr(GetModel().GetItemPool()); // no fill, no line + aTempAttr.Put(XLineStyleItem(drawing::LineStyle_NONE)); + aTempAttr.Put(XFillStyleItem(drawing::FillStyle_NONE)); + + pObj->SetMergedItemSet(aTempAttr); + + pObj->FitFrameToTextSize(); + Size aSiz(pObj->GetLogicRect().GetSize()); + MapUnit eMap = GetModel().GetScaleUnit(); + ImpPasteObject(pObj.get(), *pLst, aPos, aSiz, MapMode(eMap), nOptions); + return true; +} + +bool SdrExchangeView::Paste(SvStream& rInput, EETextFormat eFormat, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions) +{ + Point aPos(rPos); + ImpGetPasteObjList(aPos,pLst); + ImpLimitToWorkArea( aPos ); + if (pLst==nullptr) return false; + SdrLayerID nLayer; + if (!ImpGetPasteLayer(pLst,nLayer)) return false; + bool bUnmark=(nOptions&(SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit(); + if (bUnmark) UnmarkAllObj(); + tools::Rectangle aTextRect(0,0,500,500); + SdrPage* pPage=pLst->getSdrPageFromSdrObjList(); + if (pPage!=nullptr) { + aTextRect.SetSize(pPage->GetSize()); + } + rtl::Reference pObj = new SdrRectObj( + getSdrModelFromSdrView(), + SdrObjKind::Text, + aTextRect); + + pObj->SetLayer(nLayer); + if (mpDefaultStyleSheet!=nullptr) pObj->NbcSetStyleSheet(mpDefaultStyleSheet, false); + + pObj->SetMergedItemSet(maDefaultAttr); + + SfxItemSet aTempAttr(GetModel().GetItemPool()); // no fill, no line + aTempAttr.Put(XLineStyleItem(drawing::LineStyle_NONE)); + aTempAttr.Put(XFillStyleItem(drawing::FillStyle_NONE)); + + pObj->SetMergedItemSet(aTempAttr); + + pObj->NbcSetText(rInput,OUString(),eFormat); + pObj->FitFrameToTextSize(); + Size aSiz(pObj->GetLogicRect().GetSize()); + MapUnit eMap = GetModel().GetScaleUnit(); + ImpPasteObject(pObj.get(), *pLst, aPos, aSiz, MapMode(eMap), nOptions); + + // b4967543 + if(pObj->GetOutlinerParaObject()) + { + SdrOutliner& rOutliner = pObj->getSdrModelFromSdrObject().GetHitTestOutliner(); + rOutliner.SetText(*pObj->GetOutlinerParaObject()); + + if(1 == rOutliner.GetParagraphCount()) + { + SfxStyleSheet* pCandidate = rOutliner.GetStyleSheet(0); + + if(pCandidate) + { + if(pObj->getSdrModelFromSdrObject().GetStyleSheetPool() == pCandidate->GetPool()) + { + pObj->NbcSetStyleSheet(pCandidate, true); + } + } + } + } + + return true; +} + +bool SdrExchangeView::Paste( + const SdrModel& rMod, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions) +{ + const SdrModel* pSrcMod=&rMod; + if (pSrcMod == &GetModel()) + return false; // this can't work, right? + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(SvxResId(STR_ExchangePaste)); + + if( mxSelectionController.is() && mxSelectionController->PasteObjModel( rMod ) ) + { + if( bUndo ) + EndUndo(); + return true; + } + + Point aPos(rPos); + ImpGetPasteObjList(aPos,pLst); + SdrPageView* pMarkPV=nullptr; + SdrPageView* pPV = GetSdrPageView(); + + if(pPV && pPV->GetObjList() == pLst ) + pMarkPV=pPV; + + ImpLimitToWorkArea( aPos ); + if (pLst==nullptr) + return false; + + bool bUnmark=(nOptions&(SdrInsertFlags::DONTMARK|SdrInsertFlags::ADDMARK))==SdrInsertFlags::NONE && !IsTextEdit(); + if (bUnmark) + UnmarkAllObj(); + + // Rescale, if the Model uses a different MapUnit. + // Calculate the necessary factors first. + MapUnit eSrcUnit = pSrcMod->GetScaleUnit(); + MapUnit eDstUnit = GetModel().GetScaleUnit(); + bool bResize=eSrcUnit!=eDstUnit; + Fraction aXResize,aYResize; + Point aPt0; + if (bResize) + { + FrPair aResize(GetMapFactor(eSrcUnit,eDstUnit)); + aXResize=aResize.X(); + aYResize=aResize.Y(); + } + SdrObjList* pDstLst=pLst; + sal_uInt16 nPg,nPgCount=pSrcMod->GetPageCount(); + for (nPg=0; nPgGetPage(nPg); + + // Use SnapRect, not BoundRect here + tools::Rectangle aR=pSrcPg->GetAllObjSnapRect(); + + if (bResize) + ResizeRect(aR,aPt0,aXResize,aYResize); + Point aDist(aPos-aR.Center()); + Size aSiz(aDist.X(),aDist.Y()); + size_t nCloneErrCnt = 0; + const size_t nObjCount = pSrcPg->GetObjCount(); + bool bMark = pMarkPV!=nullptr && !IsTextEdit() && (nOptions&SdrInsertFlags::DONTMARK)==SdrInsertFlags::NONE; + + // #i13033# + // New mechanism to re-create the connections of cloned connectors + CloneList aCloneList; + std::unordered_set aNameSet; + for (size_t nOb=0; nObGetObj(nOb); + + rtl::Reference pNewObj(pSrcOb->CloneSdrObject(GetModel())); + + if (pNewObj!=nullptr) + { + if(bResize) + { + pNewObj->getSdrModelFromSdrObject().SetPasteResize(true); + pNewObj->NbcResize(aPt0,aXResize,aYResize); + pNewObj->getSdrModelFromSdrObject().SetPasteResize(false); + } + + // #i39861# + pNewObj->NbcMove(aSiz); + + const SdrPage* pPg = pDstLst->getSdrPageFromSdrObjList(); + + if(pPg) + { + // #i72535# + const SdrLayerAdmin& rAd = pPg->GetLayerAdmin(); + SdrLayerID nLayer(0); + + if(dynamic_cast( pNewObj.get()) != nullptr) + { + // for FormControls, force to form layer + nLayer = rAd.GetLayerID(rAd.GetControlLayerName()); + } + else + { + nLayer = rAd.GetLayerID(maActualLayer); + } + + if(SDRLAYER_NOTFOUND == nLayer) + { + nLayer = SdrLayerID(0); + } + + pNewObj->SetLayer(nLayer); + } + + pDstLst->InsertObjectThenMakeNameUnique(pNewObj.get(), aNameSet); + + if( bUndo ) + AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoNewObject(*pNewObj)); + + if (bMark) { + // Don't already set Markhandles! + // That is instead being done by ModelHasChanged in MarkView. + MarkObj(pNewObj.get(),pMarkPV,false,true); + } + + // #i13033# + aCloneList.AddPair(pSrcOb, pNewObj.get()); + } + else + { + nCloneErrCnt++; + } + } + + // #i13033# + // New mechanism to re-create the connections of cloned connectors + aCloneList.CopyConnections(); + + if(0 != nCloneErrCnt) + { +#ifdef DBG_UTIL + OStringBuffer aStr("SdrExchangeView::Paste(): Error when cloning "); + + if(nCloneErrCnt == 1) + { + aStr.append("a drawing object."); + } + else + { + aStr.append(OString::number(static_cast(nCloneErrCnt)) + + " drawing objects."); + } + + aStr.append(" Not copying object connectors."); + + OSL_FAIL(aStr.getStr()); +#endif + } + } + + if( bUndo ) + EndUndo(); + + return true; +} + +void SdrExchangeView::ImpPasteObject(SdrObject* pObj, SdrObjList& rLst, const Point& rCenter, const Size& rSiz, const MapMode& rMap, SdrInsertFlags nOptions) +{ + BigInt nSizX(rSiz.Width()); + BigInt nSizY(rSiz.Height()); + MapUnit eSrcMU=rMap.GetMapUnit(); + MapUnit eDstMU = GetModel().GetScaleUnit(); + FrPair aMapFact(GetMapFactor(eSrcMU,eDstMU)); + nSizX *= double(aMapFact.X() * rMap.GetScaleX()); + nSizY *= double(aMapFact.Y() * rMap.GetScaleY()); + tools::Long xs=nSizX; + tools::Long ys=nSizY; + // set the pos to 0, 0 for online case + bool isLOK = comphelper::LibreOfficeKit::isActive(); + Point aPos(isLOK ? 0 : rCenter.X()-xs/2, isLOK ? 0 : rCenter.Y()-ys/2); + tools::Rectangle aR(aPos.X(),aPos.Y(),aPos.X()+xs,aPos.Y()+ys); + pObj->SetLogicRect(aR); + rLst.InsertObject(pObj, SAL_MAX_SIZE); + + if( IsUndoEnabled() ) + AddUndo(getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoNewObject(*pObj)); + + SdrPageView* pMarkPV=nullptr; + SdrPageView* pPV = GetSdrPageView(); + + if(pPV && pPV->GetObjList()==&rLst) + pMarkPV=pPV; + + bool bMark = pMarkPV!=nullptr && !IsTextEdit() && (nOptions&SdrInsertFlags::DONTMARK)==SdrInsertFlags::NONE; + if (bMark) + { // select object the first PageView we found + MarkObj(pObj,pMarkPV); + } +} + +BitmapEx SdrExchangeView::GetMarkedObjBitmapEx(bool bNoVDevIfOneBmpMarked, const sal_uInt32 nMaximumQuadraticPixels, const std::optional& rTargetDPI) const +{ + BitmapEx aBmp; + + if( AreObjectsMarked() ) + { + if(1 == GetMarkedObjectCount()) + { + if(bNoVDevIfOneBmpMarked) + { + SdrObject* pGrafObjTmp = GetMarkedObjectByIndex( 0 ); + SdrGrafObj* pGrafObj = dynamic_cast( pGrafObjTmp ); + + if( pGrafObj && ( pGrafObj->GetGraphicType() == GraphicType::Bitmap ) ) + { + aBmp = pGrafObj->GetTransformedGraphic().GetBitmapEx(); + } + } + else + { + const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(GetMarkedObjectByIndex(0)); + + if(pSdrGrafObj && pSdrGrafObj->isEmbeddedVectorGraphicData()) + { + aBmp = pSdrGrafObj->GetGraphic().getVectorGraphicData()->getReplacement(); + } + } + } + + if( aBmp.IsEmpty() ) + { + // choose conversion directly using primitives to bitmap to avoid + // rendering errors with tiled bitmap fills (these will be tiled in a + // in-between metafile, but tend to show 'gaps' since the target is *no* + // bitmap rendering) + ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects()); + const sal_uInt32 nCount(aSdrObjects.size()); + + if(nCount) + { + // collect sub-primitives as group objects, thus no expensive append + // to existing sequence is needed + drawinglayer::primitive2d::Primitive2DContainer xPrimitives(nCount); + + for(sal_uInt32 a(0); a < nCount; a++) + { + SdrObject* pCandidate = aSdrObjects[a]; + SdrGrafObj* pSdrGrafObj = dynamic_cast< SdrGrafObj* >(pCandidate); + + if(pSdrGrafObj) + { + // #122753# To ensure existence of graphic content, force swap in + pSdrGrafObj->ForceSwapIn(); + } + + drawinglayer::primitive2d::Primitive2DContainer xRetval; + pCandidate->GetViewContact().getViewIndependentPrimitive2DContainer(xRetval); + xPrimitives[a] = new drawinglayer::primitive2d::GroupPrimitive2D( + std::move(xRetval)); + } + + // get logic range + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + const basegfx::B2DRange aRange(xPrimitives.getB2DRange(aViewInformation2D)); + + if(!aRange.isEmpty()) + { + o3tl::Length eRangeUnit = o3tl::Length::mm100; + + if (GetModel().IsWriter()) + { + eRangeUnit = o3tl::Length::twip; + } + + // if we have geometry and it has a range, convert to BitmapEx using + // common tooling + aBmp = drawinglayer::convertPrimitive2DContainerToBitmapEx( + std::move(xPrimitives), + aRange, + nMaximumQuadraticPixels, + eRangeUnit, + rTargetDPI); + } + } + } + } + + return aBmp; +} + + +GDIMetaFile SdrExchangeView::GetMarkedObjMetaFile(bool bNoVDevIfOneMtfMarked) const +{ + GDIMetaFile aMtf; + + if( AreObjectsMarked() ) + { + tools::Rectangle aBound( GetMarkedObjBoundRect() ); + Size aBoundSize( aBound.GetWidth(), aBound.GetHeight() ); + MapMode aMap(GetModel().GetScaleUnit()); + + if( bNoVDevIfOneMtfMarked ) + { + SdrObject* pGrafObjTmp = GetMarkedObjectByIndex( 0 ); + SdrGrafObj* pGrafObj = ( GetMarkedObjectCount() ==1 ) ? dynamic_cast( pGrafObjTmp ) : nullptr; + + if( pGrafObj ) + { + Graphic aGraphic( pGrafObj->GetTransformedGraphic() ); + + // #119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically + aMtf = aGraphic.GetGDIMetaFile(); + } + } + + if( !aMtf.GetActionSize() ) + { + ScopedVclPtrInstance< VirtualDevice > pOut; + const Size aDummySize(2, 2); + + pOut->SetOutputSizePixel(aDummySize); + pOut->EnableOutput(false); + pOut->SetMapMode(aMap); + aMtf.Clear(); + aMtf.Record(pOut); + + DrawMarkedObj(*pOut); + + aMtf.Stop(); + aMtf.WindStart(); + + // moving the result is more reliable then setting a relative MapMode at the VDev (used + // before), also see #i99268# in GetObjGraphic() below. Some draw actions at + // the OutDev are simply not handled correctly when a MapMode is set at the + // target device, e.g. MetaFloatTransparentAction. Even the Move for this action + // was missing the manipulation of the embedded Metafile + aMtf.Move(-aBound.Left(), -aBound.Top()); + + aMtf.SetPrefMapMode( aMap ); + + // removed PrefSize extension. It is principally wrong to set a reduced size at + // the created MetaFile. The mentioned errors occur at output time since the integer + // MapModes from VCL lead to errors. It is now corrected in the VCLRenderer for + // primitives (and may later be done in breaking up a MetaFile to primitives) + aMtf.SetPrefSize(aBoundSize); + } + } + + return aMtf; +} + + +Graphic SdrExchangeView::GetAllMarkedGraphic() const +{ + Graphic aRet; + + if( AreObjectsMarked() ) + { + if( ( 1 == GetMarkedObjectCount() ) && GetSdrMarkByIndex( 0 ) ) + aRet = SdrExchangeView::GetObjGraphic(*GetMarkedObjectByIndex(0)); + else + aRet = GetMarkedObjMetaFile(); + } + + return aRet; +} + + +// tdf#155479 bSVG: need to know it's SVG export, default is false +Graphic SdrExchangeView::GetObjGraphic(const SdrObject& rSdrObject, bool bSVG) +{ + Graphic aRet; + + // try to get a graphic from the object first + const SdrGrafObj* pSdrGrafObj(dynamic_cast< const SdrGrafObj* >(&rSdrObject)); + const SdrOle2Obj* pSdrOle2Obj(dynamic_cast< const SdrOle2Obj* >(&rSdrObject)); + + if(pSdrGrafObj) + { + if(pSdrGrafObj->isEmbeddedVectorGraphicData()) + { + // get Metafile for Svg content + aRet = pSdrGrafObj->getMetafileFromEmbeddedVectorGraphicData(); + } + else + { + // Make behaviour coherent with metafile + // recording below (which of course also takes + // view-transformed objects) + aRet = pSdrGrafObj->GetTransformedGraphic(); + } + } + else if(pSdrOle2Obj) + { + if(pSdrOle2Obj->GetGraphic()) + { + aRet = *pSdrOle2Obj->GetGraphic(); + } + } + else + { + // Support extracting a snapshot from video media, if possible. + const SdrMediaObj* pSdrMediaObj = dynamic_cast(&rSdrObject); + if (pSdrMediaObj) + { + const css::uno::Reference& xGraphic + = pSdrMediaObj->getSnapshot(); + if (xGraphic.is()) + aRet = Graphic(xGraphic); + } + } + + // if graphic could not be retrieved => go the hard way and create a MetaFile + if((GraphicType::NONE == aRet.GetType()) || (GraphicType::Default == aRet.GetType())) + { + ScopedVclPtrInstance< VirtualDevice > pOut; + GDIMetaFile aMtf; + const tools::Rectangle aBoundRect(rSdrObject.GetCurrentBoundRect()); + const MapMode aMap(rSdrObject.getSdrModelFromSdrObject().GetScaleUnit()); + + pOut->EnableOutput(false); + pOut->SetMapMode(aMap); + aMtf.Record(pOut); + aMtf.setSVG(bSVG); + rSdrObject.SingleObjectPainter(*pOut); + aMtf.Stop(); + aMtf.WindStart(); + + // #i99268# replace the original offset from using XOutDev's SetOffset + // NOT (as tried with #i92760#) with another MapMode which gets recorded + // by the Metafile itself (what always leads to problems), but by + // moving the result directly + aMtf.Move(-aBoundRect.Left(), -aBoundRect.Top()); + aMtf.SetPrefMapMode(aMap); + aMtf.SetPrefSize(aBoundRect.GetSize()); + + if(aMtf.GetActionSize()) + { + aRet = aMtf; + } + } + + return aRet; +} + + +::std::vector< SdrObject* > SdrExchangeView::GetMarkedObjects() const +{ + SortMarkedObjects(); + ::std::vector< SdrObject* > aRetval; + + ::std::vector< ::std::vector< SdrMark* > > aObjVectors( 2 ); + ::std::vector< SdrMark* >& rObjVector1 = aObjVectors[ 0 ]; + ::std::vector< SdrMark* >& rObjVector2 = aObjVectors[ 1 ]; + const SdrLayerAdmin& rLayerAdmin = GetModel().GetLayerAdmin(); + const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID( rLayerAdmin.GetControlLayerName() ); + + for( size_t n = 0, nCount = GetMarkedObjectCount(); n < nCount; ++n ) + { + SdrMark* pMark = GetSdrMarkByIndex( n ); + + // paint objects on control layer on top of all other objects + if( nControlLayerId == pMark->GetMarkedSdrObj()->GetLayer() ) + rObjVector2.push_back( pMark ); + else + rObjVector1.push_back( pMark ); + } + + for(const std::vector & rObjVector : aObjVectors) + { + for(SdrMark* pMark : rObjVector) + { + aRetval.push_back(pMark->GetMarkedSdrObj()); + } + } + + return aRetval; +} + + +void SdrExchangeView::DrawMarkedObj(OutputDevice& rOut) const +{ + ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects()); + + if(!aSdrObjects.empty()) + { + sdr::contact::ObjectContactOfObjListPainter aPainter(rOut, std::move(aSdrObjects), aSdrObjects[0]->getSdrPageFromSdrObject()); + sdr::contact::DisplayInfo aDisplayInfo; + + // do processing + aPainter.ProcessDisplay(aDisplayInfo); + } +} + +std::unique_ptr SdrExchangeView::CreateMarkedObjModel() const +{ + // Sorting the MarkList here might be problematic in the future, so + // use a copy. + SortMarkedObjects(); + std::unique_ptr pNewModel(GetModel().AllocModel()); + rtl::Reference pNewPage = pNewModel->AllocPage(false); + pNewModel->InsertPage(pNewPage.get()); + ::std::vector< SdrObject* > aSdrObjects(GetMarkedObjects()); + + // #i13033# + // New mechanism to re-create the connections of cloned connectors + CloneList aCloneList; + + for(SdrObject* pObj : aSdrObjects) + { + rtl::Reference pNewObj; + + if(nullptr != dynamic_cast< const SdrPageObj* >(pObj)) + { + // convert SdrPageObj's to a graphic representation, because + // virtual connection to referenced page gets lost in new model + pNewObj = new SdrGrafObj( + *pNewModel, + GetObjGraphic(*pObj), + pObj->GetLogicRect()); + } + else if(nullptr != dynamic_cast< const sdr::table::SdrTableObj* >(pObj)) + { + // check if we have a valid selection *different* from whole table + // being selected + if(mxSelectionController.is()) + { + pNewObj = mxSelectionController->GetMarkedSdrObjClone(*pNewModel); + } + } + + if(!pNewObj) + { + // not cloned yet + if(pObj->GetObjIdentifier() == SdrObjKind::OLE2 && nullptr == GetModel().GetPersist()) + { + // tdf#125520 - former fix was wrong, the SdrModel + // has to have a GetPersist() already, see task. + // We can still warn here when this is not the case + SAL_WARN( "svx", "OLE gets cloned Persist, EmbeddedObjectContainer will not be copied" ); + } + + // use default way + pNewObj = pObj->CloneSdrObject(*pNewModel); + } + + if(pNewObj) + { + pNewPage->InsertObject(pNewObj.get(), SAL_MAX_SIZE); + + // #i13033# + aCloneList.AddPair(pObj, pNewObj.get()); + } + } + + // #i13033# + // New mechanism to re-create the connections of cloned connectors + aCloneList.CopyConnections(); + + return pNewModel; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/textchain.cxx b/svx/source/svdraw/textchain.cxx new file mode 100644 index 0000000000..32c1f9b4e3 --- /dev/null +++ b/svx/source/svdraw/textchain.cxx @@ -0,0 +1,128 @@ +/* -*- 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 +#include + +/* + * Definition of Properties Interface +*/ + +CursorChainingEvent const & TextChain::GetCursorEvent(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aCursorEvent; +} +void TextChain::SetCursorEvent(const SdrTextObj *pTarget, CursorChainingEvent const & rPropParam) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aCursorEvent = rPropParam; +} + +bool TextChain::GetNilChainingEvent(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aNilChainingEvent; +} +void TextChain::SetNilChainingEvent(const SdrTextObj *pTarget, bool b) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aNilChainingEvent = b; +} + +ESelection const & TextChain::GetPreChainingSel(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aPreChainingSel; +} +void TextChain::SetPreChainingSel(const SdrTextObj *pTarget, ESelection const & rPropParam) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aPreChainingSel = rPropParam; +} + +ESelection const & TextChain::GetPostChainingSel(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aPostChainingSel; +} +void TextChain::SetPostChainingSel(const SdrTextObj *pTarget, ESelection const & rPropParam) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aPostChainingSel = rPropParam; +} + +bool TextChain::GetIsPartOfLastParaInNextLink(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aIsPartOfLastParaInNextLink; +} +void TextChain::SetIsPartOfLastParaInNextLink(const SdrTextObj *pTarget, bool b) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aIsPartOfLastParaInNextLink = b; +} + +bool TextChain::GetSwitchingToNextBox(const SdrTextObj *pTarget) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + return pLinkProperties->aSwitchingToNextBox; +} +void TextChain::SetSwitchingToNextBox(const SdrTextObj *pTarget, bool b) +{ + ImpChainLinkProperties *pLinkProperties = GetLinkProperties(pTarget); + pLinkProperties->aSwitchingToNextBox = b; +} + +/* End Definition of Properties Interface */ + +/* TextChain */ + +// NOTE: All getters in the class assume that the guy is in the chain + +TextChain::TextChain() +{ +} + +TextChain::~TextChain() +{ + // XXX: Should free all LinkProperties +} + +namespace { + +ChainLinkId GetId(const SdrTextObj *pLink) +{ + return pLink->GetName(); +} + +} + +ImpChainLinkProperties *TextChain::GetLinkProperties(const SdrTextObj *pLink) +{ + // if the guy does not already have properties in the map make them + ChainLinkId aLinkId = GetId(pLink); + if (maLinkPropertiesMap.find(aLinkId) == maLinkPropertiesMap.end()) { + maLinkPropertiesMap[aLinkId] = new ImpChainLinkProperties; + } + + return maLinkPropertiesMap[aLinkId]; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/textchaincursor.cxx b/svx/source/svdraw/textchaincursor.cxx new file mode 100644 index 0000000000..51c4d1d8ef --- /dev/null +++ b/svx/source/svdraw/textchaincursor.cxx @@ -0,0 +1,203 @@ +/* -*- 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 +#include +#include +#include +#include + +// XXX: Possible duplication of code in behavior with stuff in ImpEditView (or ImpEditEngine) and OutlinerView + +// XXX: We violate Demeter's Law several times here, I'm afraid + +TextChainCursorManager::TextChainCursorManager(SdrObjEditView *pEditView, const SdrTextObj *pTextObj) : + mpEditView(pEditView), + mpTextObj(pTextObj), + mbHandlingDel(false) +{ + assert(mpEditView); + assert(mpTextObj); + +} + +bool TextChainCursorManager::HandleKeyEvent( const KeyEvent& rKEvt ) +{ + ESelection aNewSel; + CursorChainingEvent aCursorEvent; + + // check what the cursor/event situation looks like + bool bCompletelyHandled = false; + impDetectEvent(rKEvt, aCursorEvent, aNewSel, bCompletelyHandled); + + if (aCursorEvent == CursorChainingEvent::NULL_EVENT) + return false; + else { + HandleCursorEvent(aCursorEvent, aNewSel); + // return value depends on the situation we are in + return bCompletelyHandled; + } +} + +void TextChainCursorManager::impDetectEvent(const KeyEvent& rKEvt, + CursorChainingEvent& rOutCursorEvt, + ESelection& rOutSel, + bool& rOutHandled) +{ + SdrOutliner *pOutl = mpEditView->GetTextEditOutliner(); + OutlinerView *pOLV = mpEditView->GetTextEditOutlinerView(); + + SdrTextObj *pNextLink = mpTextObj->GetNextLinkInChain(); + SdrTextObj *pPrevLink = mpTextObj->GetPrevLinkInChain(); + + KeyFuncType eFunc = rKEvt.GetKeyCode().GetFunction(); + + // We need to have this KeyFuncType + if (eFunc != KeyFuncType::DONTKNOW && eFunc != KeyFuncType::DELETE) + { + rOutCursorEvt = CursorChainingEvent::NULL_EVENT; + return; + } + + sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode(); + ESelection aCurSel = pOLV->GetSelection(); + + ESelection aEndSelPrevBox(100000, 100000); + + sal_Int32 nLastPara = pOutl->GetParagraphCount()-1; + OUString aLastParaText = pOutl->GetText(pOutl->GetParagraph(nLastPara)); + sal_Int32 nLastParaLen = aLastParaText.getLength(); + + ESelection aEndSel(nLastPara, nLastParaLen); + bool bAtEndOfTextContent = aCurSel == aEndSel; + + // Possibility: Are we "pushing" at the end of the object? + if (nCode == KEY_RIGHT && bAtEndOfTextContent && pNextLink) + { + rOutCursorEvt = CursorChainingEvent::TO_NEXT_LINK; + // Selection unchanged: we are at the beginning of the box + rOutHandled = true; // Nothing more to do than move cursor + return; + } + + // Possibility: Are we "pushing" at the end of the object? + if (eFunc == KeyFuncType::DELETE && bAtEndOfTextContent && pNextLink) + { + rOutCursorEvt = CursorChainingEvent::TO_NEXT_LINK; + // Selection unchanged: we are at the beginning of the box + rOutHandled = false; // We still need to delete the characters + mbHandlingDel = true; + return; + } + + ESelection aStartSel(0, 0); + bool bAtStartOfTextContent = aCurSel == aStartSel; + + // Possibility: Are we "pushing" at the start of the object? + if (nCode == KEY_LEFT && bAtStartOfTextContent && pPrevLink) + { + rOutCursorEvt = CursorChainingEvent::TO_PREV_LINK; + rOutSel = aEndSelPrevBox; // Set at end of selection + rOutHandled = true; // Nothing more to do than move cursor + return; + } + + // Possibility: Are we "pushing" at the start of the object and deleting left? + if (nCode == KEY_BACKSPACE && bAtStartOfTextContent && pPrevLink) + { + rOutCursorEvt = CursorChainingEvent::TO_PREV_LINK; + rOutSel = aEndSelPrevBox; // Set at end of selection + rOutHandled = false; // We need to delete characters after moving cursor + return; + } + + // If arrived here there is no event detected + rOutCursorEvt = CursorChainingEvent::NULL_EVENT; + +} + +void TextChainCursorManager::HandleCursorEventAfterChaining( + const CursorChainingEvent aCurEvt, + const ESelection& aNewSel) + +{ + // Special case for DELETE handling: we need to get back at the end of the prev box + if (mbHandlingDel) { + // reset flag + mbHandlingDel = false; + + // Move to end of prev box + SdrTextObj *pPrevLink = mpTextObj->GetPrevLinkInChain(); + ESelection aEndSel(100000, 100000); + impChangeEditingTextObj(pPrevLink, aEndSel); + return; + } + + // Standard handling + HandleCursorEvent(aCurEvt, aNewSel); +} + + +void TextChainCursorManager::HandleCursorEvent( + const CursorChainingEvent aCurEvt, + const ESelection& aNewSel) + +{ + + OutlinerView* pOLV = mpEditView->GetTextEditOutlinerView(); + SdrTextObj *pNextLink = mpTextObj->GetNextLinkInChain(); + SdrTextObj *pPrevLink = mpTextObj->GetPrevLinkInChain(); + + + switch ( aCurEvt ) { + case CursorChainingEvent::UNCHANGED: + // Set same selection as before the chaining (which is saved as PostChainingSel) + // We need an explicit set because the Outliner is messed up + // after text transfer and otherwise it brings us at arbitrary positions. + pOLV->SetSelection(aNewSel); + break; + case CursorChainingEvent::TO_NEXT_LINK: + mpTextObj->GetTextChain()->SetSwitchingToNextBox(mpTextObj, true); + impChangeEditingTextObj(pNextLink, aNewSel); + break; + case CursorChainingEvent::TO_PREV_LINK: + impChangeEditingTextObj(pPrevLink, aNewSel); + break; + case CursorChainingEvent::NULL_EVENT: + // Do nothing here + break; + } + +} + +void TextChainCursorManager::impChangeEditingTextObj(SdrTextObj *pTargetTextObj, ESelection aNewSel) +{ + assert(pTargetTextObj); + + mpEditView->SdrEndTextEdit(); + mpEditView->SdrBeginTextEdit(pTargetTextObj); + // OutlinerView has changed, so we update the pointer + OutlinerView *pOLV = mpEditView->GetTextEditOutlinerView(); + pOLV->SetSelection(aNewSel); + + // Update reference text obj + mpTextObj = pTargetTextObj; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/svdraw/textchainflow.cxx b/svx/source/svdraw/textchainflow.cxx new file mode 100644 index 0000000000..9763ea5015 --- /dev/null +++ b/svx/source/svdraw/textchainflow.cxx @@ -0,0 +1,314 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include + +TextChainFlow::TextChainFlow(SdrTextObj *pChainTarget) + : mpTargetLink(pChainTarget) +{ + SAL_INFO("svx.chaining", "[TEXTCHAINFLOW] Creating a new TextChainFlow"); + + mpTextChain = mpTargetLink->GetTextChain(); + mpNextLink = mpTargetLink->GetNextLinkInChain(); + + bUnderflow = bOverflow = false; + + mbOFisUFinduced = false; + + mpOverflChText = nullptr; + mpUnderflChText = nullptr; + + mbPossiblyCursorOut = false; +} + + +TextChainFlow::~TextChainFlow() +{ + mpOverflChText.reset(); + mpUnderflChText.reset(); +} + +void TextChainFlow::impSetFlowOutlinerParams(SdrOutliner *, SdrOutliner *) +{ + // Nothing to do if not in editing mode +} + +/* + * Check for overflow in the state of pFlowOutl. + * If pParamOutl is not NULL sets some parameters from there. + * This is useful in case the outliner is not set for overflow + * (e.g. in editing mode we check for overflow in drawing outl but + * parameters come from editing outliner) +*/ +void TextChainFlow::impCheckForFlowEvents(SdrOutliner *pFlowOutl, SdrOutliner *pParamOutl) +{ + bool bOldUpdateMode = pFlowOutl->IsUpdateLayout(); + + // XXX: This could be reorganized moving most of this stuff inside EditingTextChainFlow + if (pParamOutl != nullptr) + { + // We need this since it's required to check overflow + pFlowOutl->SetUpdateLayout(true); + + // XXX: does this work if you do it before setting the text? Seems so. + impSetFlowOutlinerParams(pFlowOutl, pParamOutl); + } + + bool bIsPageOverflow = pFlowOutl->IsPageOverflow(); + + // NOTE: overflow and underflow cannot be both true + bOverflow = bIsPageOverflow && mpNextLink; + bUnderflow = !bIsPageOverflow && mpNextLink && mpNextLink->HasText(); + + // Get old state on whether to merge para-s or not + // NOTE: We handle UF/OF using the _old_ state. The new one is simply saved + bool bMustMergeParaAmongLinks = GetTextChain()->GetIsPartOfLastParaInNextLink(mpTargetLink); + + // Set (Non)OverflowingTxt here (if any) + + // If we had an underflow before we have to deep merge paras anyway + bool bMustMergeParaOF = bMustMergeParaAmongLinks || mbOFisUFinduced; + + mpOverflChText.reset( bOverflow ? + new OFlowChainedText(pFlowOutl, bMustMergeParaOF) : + nullptr ); + + // Set current underflowing text (if any) + mpUnderflChText.reset( bUnderflow ? + new UFlowChainedText(pFlowOutl, bMustMergeParaAmongLinks) : + nullptr ); + + // Reset update mode // Reset it here because we use WriteRTF (needing updatemode = true) in the two constructors above + if (!bOldUpdateMode) // Reset only if the old value was false + pFlowOutl->SetUpdateLayout(bOldUpdateMode); + + // NOTE: Must be called after mp*ChText abd b*flow have been set but before mbOFisUFinduced is reset + impUpdateCursorInfo(); + + // To check whether an overflow is underflow induced or not (useful in cursor checking) + mbOFisUFinduced = bUnderflow; +} + +void TextChainFlow::impUpdateCursorInfo() +{ + // XXX: Maybe we can get rid of mbOFisUFinduced by not allowing handling of more than one event by the same TextChainFlow + // if this is not an OF triggered during an UF + + mbPossiblyCursorOut = bOverflow; + + if(mbPossiblyCursorOut ) { + maOverflowPosSel = mpOverflChText->GetOverflowPointSel(); + ESelection aSelAtUFTime = GetTextChain()->GetPreChainingSel(GetLinkTarget()); + // Might be an invalid selection if the cursor at UF time was before + // the (possibly UF-induced) Overflowing point but we don't use it in that case + maPostChainingSel = ESelection(aSelAtUFTime.nStartPara-maOverflowPosSel.nStartPara, + aSelAtUFTime.nStartPos-maOverflowPosSel.nStartPos ); + } + + // XXX: It may not be necessary anymore to keep this method separated from EditingTextChainFlow::impBroadcastCursorInfo +} + +void TextChainFlow::CheckForFlowEvents(SdrOutliner *pFlowOutl) +{ + impCheckForFlowEvents(pFlowOutl, nullptr); +} + + +bool TextChainFlow::IsOverflow() const +{ + return bOverflow; +} + +bool TextChainFlow::IsUnderflow() const +{ + return bUnderflow; +} + + +// XXX: In editing mode you need to get "underflowing" text from editing outliner, so it's kinda separate from the drawing one! + +// XXX:Would it be possible to unify underflow and its possibly following overflow? +void TextChainFlow::ExecuteUnderflow(SdrOutliner *pOutl) +{ + //GetTextChain()->SetNilChainingEvent(mpTargetLink, true); + // making whole text + // merges underflowing text with the one in the next box + std::optional pNewText = mpUnderflChText->CreateMergedUnderflowParaObject(pOutl, mpNextLink->GetOutlinerParaObject()); + + // Set the other box empty; it will be replaced by the rest of the text if overflow occurs + if (!mpTargetLink->GetPreventChainable()) + mpNextLink->NbcSetOutlinerParaObject(pOutl->GetEmptyParaObject()); + + // We store the size since NbcSetOutlinerParaObject can change it + //Size aOldSize = pOutl->GetMaxAutoPaperSize(); + + // This should not be done in editing mode!! //XXX + if (!mpTargetLink->IsInEditMode()) + { + mpTargetLink->NbcSetOutlinerParaObject(pNewText); + } + + // Restore size and set new text + //pOutl->SetMaxAutoPaperSize(aOldSize); // XXX (it seems to be working anyway without this) + pOutl->SetText(*pNewText); + + //GetTextChain()->SetNilChainingEvent(mpTargetLink, false); + + // Check for new overflow + CheckForFlowEvents(pOutl); +} + +void TextChainFlow::ExecuteOverflow(SdrOutliner *pNonOverflOutl, SdrOutliner *pOverflOutl) +{ + //GetTextChain()->SetNilChainingEvent(mpTargetLink, true); + // Leave only non overflowing text + impLeaveOnlyNonOverflowingText(pNonOverflOutl); + + // Transfer of text to next link + if (!mpTargetLink->GetPreventChainable() ) // we don't transfer text while dragging because of resizing + { + impMoveChainedTextToNextLink(pOverflOutl); + } + + //GetTextChain()->SetNilChainingEvent(mpTargetLink, false); +} + +void TextChainFlow::impLeaveOnlyNonOverflowingText(SdrOutliner *pNonOverflOutl) +{ + std::optional pNewText = mpOverflChText->RemoveOverflowingText(pNonOverflOutl); + + SAL_INFO("svx.chaining", "[TEXTCHAINFLOW - OF] SOURCE box set to " + << pNewText->GetTextObject().GetParagraphCount() << " paras"); + + // adds it to current outliner anyway (useful in static decomposition) + pNonOverflOutl->SetText(*pNewText); + + mpTargetLink->NbcSetOutlinerParaObject(std::move(pNewText)); + // For some reason the paper size is lost after last instruction, so we set it. + pNonOverflOutl->SetPaperSize(Size(pNonOverflOutl->GetPaperSize().Width(), + pNonOverflOutl->GetTextHeight())); + +} + +void TextChainFlow::impMoveChainedTextToNextLink(SdrOutliner *pOverflOutl) +{ + // prevent copying text in same box + if ( mpNextLink == mpTargetLink ) { + SAL_INFO("svx.chaining", "[CHAINING] Trying to copy text for next link in same object"); + return; + } + + std::optional pNewText = + mpOverflChText->InsertOverflowingText(pOverflOutl, + mpNextLink->GetOutlinerParaObject()); + SAL_INFO("svx.chaining", "[TEXTCHAINFLOW - OF] DEST box set to " + << pNewText->GetTextObject().GetParagraphCount() << " paras"); + + if (pNewText) + mpNextLink->NbcSetOutlinerParaObject(std::move(pNewText)); + + // Set Deep Merge status + SAL_INFO("svx.chaining", "[DEEPMERGE] Setting deepMerge to " + << mpOverflChText->IsLastParaInterrupted()); + GetTextChain()->SetIsPartOfLastParaInNextLink( + mpTargetLink, + mpOverflChText->IsLastParaInterrupted()); +} + +SdrTextObj *TextChainFlow::GetLinkTarget() const +{ + return mpTargetLink; +} + +TextChain *TextChainFlow::GetTextChain() const +{ + return mpTextChain; +} + +// EditingTextChainFlow + +EditingTextChainFlow::EditingTextChainFlow(SdrTextObj *pLinkTarget) : + TextChainFlow(pLinkTarget) +{ + SAL_INFO("svx.chaining", "[TEXTCHAINFLOW] Creating a new EditingTextChainFlow"); +} + +void EditingTextChainFlow::CheckForFlowEvents(SdrOutliner *pFlowOutl) +{ + // if this is editing outliner no need to set parameters + if (pFlowOutl == GetLinkTarget()->mpEditingOutliner) + impCheckForFlowEvents(pFlowOutl, nullptr); + else + impCheckForFlowEvents(pFlowOutl, GetLinkTarget()->mpEditingOutliner); + + // Broadcast events for cursor handling + impBroadcastCursorInfo(); +} + +void EditingTextChainFlow::impLeaveOnlyNonOverflowingText(SdrOutliner *pNonOverflOutl) +{ + mpOverflChText->RemoveOverflowingText(pNonOverflOutl); + //impSetTextForEditingOutliner(pNewText); //XXX: Don't call it since we do everything with NonOverflowingText::ToParaObject // XXX: You may need this for Underflow + + // XXX: I'm not sure whether we need this (after all operations such as Paste don't change this - as far as I understand) + //GetLinkTarget()->NbcSetOutlinerParaObject(pNewText); +} + +void EditingTextChainFlow::impSetFlowOutlinerParams(SdrOutliner *pFlowOutl, SdrOutliner *pParamOutl) +{ + // Set right size for overflow + pFlowOutl->SetMaxAutoPaperSize(pParamOutl->GetMaxAutoPaperSize()); + pFlowOutl->SetMinAutoPaperSize(pParamOutl->GetMinAutoPaperSize()); + pFlowOutl->SetPaperSize(pParamOutl->GetPaperSize()); +} + +void EditingTextChainFlow::impBroadcastCursorInfo() const +{ + ESelection aPreChainingSel = GetTextChain()->GetPreChainingSel(GetLinkTarget()) ; + + // Test whether the cursor is out of the box. + bool bCursorOut = mbPossiblyCursorOut && maOverflowPosSel < aPreChainingSel; + + // NOTE: I handled already the stuff for the comments below. They will be kept temporarily till stuff settles down. + // Possibility: 1) why don't we stop passing the actual event to the TextChain and instead we pass + // the overflow pos and mbPossiblyCursorOut + // 2) We pass the current selection before anything happens and we make impBroadcastCursorInfo compute it. + + + if (bCursorOut) { + //maCursorEvent = CursorChainingEvent::TO_NEXT_LINK; + GetTextChain()->SetPostChainingSel(GetLinkTarget(), maPostChainingSel); + GetTextChain()->SetCursorEvent(GetLinkTarget(), CursorChainingEvent::TO_NEXT_LINK); + } else { + //maCursorEvent = CursorChainingEvent::UNCHANGED; + GetTextChain()->SetPostChainingSel(GetLinkTarget(), aPreChainingSel); + GetTextChain()->SetCursorEvent(GetLinkTarget(), CursorChainingEvent::UNCHANGED); + } + + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3