/* -*- 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 namespace com::sun::star::embed { class XEmbeddedObject; } #define DET_ARROW_OFFSET 1000 using namespace ::com::sun::star; static E3dObjFactory* pF3d = nullptr; static sal_uInt16 nInst = 0; SfxObjectShell* ScDrawLayer::pGlobalDrawPersist = nullptr; bool bDrawIsInUndo = false; //TODO: Member ScUndoObjData::ScUndoObjData( SdrObject* pObjP, const ScAddress& rOS, const ScAddress& rOE, const ScAddress& rNS, const ScAddress& rNE ) : SdrUndoObj( *pObjP ), aOldStt( rOS ), aOldEnd( rOE ), aNewStt( rNS ), aNewEnd( rNE ) { } ScUndoObjData::~ScUndoObjData() { } void ScUndoObjData::Undo() { ScDrawObjData* pData = ScDrawLayer::GetObjData( pObj ); OSL_ENSURE(pData,"ScUndoObjData: Data missing"); if (pData) { pData->maStart = aOldStt; pData->maEnd = aOldEnd; } // Undo also an untransformed anchor pData = ScDrawLayer::GetNonRotatedObjData( pObj ); if (pData) { pData->maStart = aOldStt; pData->maEnd = aOldEnd; } } void ScUndoObjData::Redo() { ScDrawObjData* pData = ScDrawLayer::GetObjData( pObj ); OSL_ENSURE(pData,"ScUndoObjData: Data missing"); if (pData) { pData->maStart = aNewStt; pData->maEnd = aNewEnd; } // Redo also an untransformed anchor pData = ScDrawLayer::GetNonRotatedObjData( pObj ); if (pData) { pData->maStart = aNewStt; pData->maEnd = aNewEnd; } } ScUndoAnchorData::ScUndoAnchorData( SdrObject* pObjP, ScDocument* pDoc, SCTAB nTab ) : SdrUndoObj( *pObjP ), mpDoc( pDoc ), mnTab( nTab ) { mbWasCellAnchored = ScDrawLayer::IsCellAnchored( *pObjP ); mbWasResizeWithCell = ScDrawLayer::IsResizeWithCell( *pObjP ); } ScUndoAnchorData::~ScUndoAnchorData() { } void ScUndoAnchorData::Undo() { // Trigger Object Change if (pObj->IsInserted() && pObj->getSdrPageFromSdrObject()) { SdrHint aHint(SdrHintKind::ObjectChange, *pObj); pObj->getSdrModelFromSdrObject().Broadcast(aHint); } if (mbWasCellAnchored) ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *mpDoc, mnTab, mbWasResizeWithCell); else ScDrawLayer::SetPageAnchored( *pObj ); } void ScUndoAnchorData::Redo() { if (mbWasCellAnchored) ScDrawLayer::SetPageAnchored( *pObj ); else ScDrawLayer::SetCellAnchoredFromPosition(*pObj, *mpDoc, mnTab, mbWasResizeWithCell); // Trigger Object Change if (pObj->IsInserted() && pObj->getSdrPageFromSdrObject()) { SdrHint aHint(SdrHintKind::ObjectChange, *pObj); pObj->getSdrModelFromSdrObject().Broadcast(aHint); } } ScTabDeletedHint::ScTabDeletedHint( SCTAB nTabNo ) : nTab( nTabNo ) { } ScTabDeletedHint::~ScTabDeletedHint() { } ScTabSizeChangedHint::ScTabSizeChangedHint( SCTAB nTabNo ) : nTab( nTabNo ) { } ScTabSizeChangedHint::~ScTabSizeChangedHint() { } #define MAXMM 10000000 static void lcl_ReverseTwipsToMM( tools::Rectangle& rRect ) { rRect = o3tl::convert(rRect, o3tl::Length::mm100, o3tl::Length::twip); } static ScRange lcl_getClipRangeFromClipDoc(ScDocument* pClipDoc, SCTAB nClipTab) { if (!pClipDoc) return ScRange(); SCCOL nClipStartX; SCROW nClipStartY; SCCOL nClipEndX; SCROW nClipEndY; pClipDoc->GetClipStart(nClipStartX, nClipStartY); pClipDoc->GetClipArea(nClipEndX, nClipEndY, true); nClipEndX = nClipEndX + nClipStartX; nClipEndY += nClipStartY; // GetClipArea returns the difference return ScRange(nClipStartX, nClipStartY, nClipTab, nClipEndX, nClipEndY, nClipTab); } ScDrawLayer::ScDrawLayer( ScDocument* pDocument, const OUString& rName ) : FmFormModel( nullptr, pGlobalDrawPersist ? pGlobalDrawPersist : (pDocument ? pDocument->GetDocumentShell() : nullptr)), aName( rName ), pDoc( pDocument ), bRecording( false ), bAdjustEnabled( true ), bHyphenatorSet( false ) { SetVOCInvalidationIsReliable(true); pGlobalDrawPersist = nullptr; // Only use once SfxObjectShell* pObjSh = pDocument ? pDocument->GetDocumentShell() : nullptr; XColorListRef pXCol = XColorList::GetStdColorList(); if ( pObjSh ) { SetObjectShell( pObjSh ); // set color table const SvxColorListItem* pColItem = pObjSh->GetItem( SID_COLOR_TABLE ); if ( pColItem ) pXCol = pColItem->GetColorList(); } SetPropertyList( static_cast (pXCol.get()) ); SetSwapGraphics(); SetScaleUnit(MapUnit::Map100thMM); SfxItemPool& rPool = GetItemPool(); rPool.SetDefaultMetric(MapUnit::Map100thMM); SvxFrameDirectionItem aModeItem( SvxFrameDirection::Environment, EE_PARA_WRITINGDIR ); rPool.SetPoolDefaultItem( aModeItem ); // #i33700# // Set shadow distance defaults as PoolDefaultItems. Details see bug. rPool.SetPoolDefaultItem(makeSdrShadowXDistItem(300)); rPool.SetPoolDefaultItem(makeSdrShadowYDistItem(300)); // default for script spacing depends on locale, see SdDrawDocument ctor in sd LanguageType eOfficeLanguage = Application::GetSettings().GetLanguageTag().getLanguageType(); if (MsLangId::isKorean(eOfficeLanguage) || eOfficeLanguage == LANGUAGE_JAPANESE) { // secondary is edit engine pool rPool.GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) ); } rPool.FreezeIdRanges(); // the pool is also used directly SdrLayerAdmin& rAdmin = GetLayerAdmin(); rAdmin.NewLayer("vorne", SC_LAYER_FRONT.get()); rAdmin.NewLayer("hinten", SC_LAYER_BACK.get()); rAdmin.NewLayer("intern", SC_LAYER_INTERN.get()); // tdf#140252 use same name as in ctor of SdrLayerAdmin rAdmin.NewLayer(rAdmin.GetControlLayerName(), SC_LAYER_CONTROLS.get()); rAdmin.NewLayer("hidden", SC_LAYER_HIDDEN.get()); // Set link for URL-Fields ScModule* pScMod = SC_MOD(); Outliner& rOutliner = GetDrawOutliner(); rOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) ); Outliner& rHitOutliner = GetHitTestOutliner(); rHitOutliner.SetCalcFieldValueHdl( LINK( pScMod, ScModule, CalcFieldValueHdl ) ); // set FontHeight pool defaults without changing static SdrEngineDefaults SfxItemPool* pOutlinerPool = rOutliner.GetEditTextObjectPool(); if ( pOutlinerPool ) { m_pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt m_pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CJK )); // 12Pt m_pItemPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CTL )); // 12Pt } SfxItemPool* pHitOutlinerPool = rHitOutliner.GetEditTextObjectPool(); if ( pHitOutlinerPool ) { pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT )); // 12Pt pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CJK )); // 12Pt pHitOutlinerPool->SetPoolDefaultItem(SvxFontHeightItem( 423, 100, EE_CHAR_FONTHEIGHT_CTL )); // 12Pt } // initial undo mode as in Calc document if( pDoc ) EnableUndo( pDoc->IsUndoEnabled() ); // URL-Buttons have no handler anymore, all is done by themselves if( !nInst++ ) { pF3d = new E3dObjFactory; } } ScDrawLayer::~ScDrawLayer() { Broadcast(SdrHint(SdrHintKind::ModelCleared)); ClearModel(true); pUndoGroup.reset(); if( !--nInst ) { delete pF3d; pF3d = nullptr; } } void ScDrawLayer::UseHyphenator() { if (!bHyphenatorSet) { css::uno::Reference< css::linguistic2::XHyphenator > xHyphenator = LinguMgr::GetHyphenator(); GetDrawOutliner().SetHyphenator( xHyphenator ); GetHitTestOutliner().SetHyphenator( xHyphenator ); bHyphenatorSet = true; } } rtl::Reference ScDrawLayer::AllocPage(bool bMasterPage) { return new ScDrawPage(*this, bMasterPage); } bool ScDrawLayer::HasObjects() const { bool bFound = false; sal_uInt16 nCount = GetPageCount(); for (sal_uInt16 i=0; iGetObjCount()) bFound = true; return bFound; } SdrModel* ScDrawLayer::AllocModel() const { // Allocated model (for clipboard etc) must not have a pointer // to the original model's document, pass NULL as document: return new ScDrawLayer( nullptr, aName ); } bool ScDrawLayer::ScAddPage( SCTAB nTab ) { if (bDrawIsInUndo) return false; // not inserted rtl::Reference pPage = static_cast(AllocPage( false ).get()); InsertPage(pPage.get(), static_cast(nTab)); if (bRecording) AddCalcUndo(std::make_unique(*pPage)); ResetTab(nTab, pDoc->GetTableCount()-1); return true; // inserted } void ScDrawLayer::ScRemovePage( SCTAB nTab ) { if (bDrawIsInUndo) return; Broadcast( ScTabDeletedHint( nTab ) ); if (bRecording) { SdrPage* pPage = GetPage(static_cast(nTab)); AddCalcUndo(std::make_unique(*pPage)); // Undo-Action becomes the page owner RemovePage( static_cast(nTab) ); // just deliver, not deleting } else DeletePage( static_cast(nTab) ); // just get rid of it ResetTab(nTab, pDoc->GetTableCount()-1); } void ScDrawLayer::ScRenamePage( SCTAB nTab, const OUString& rNewName ) { ScDrawPage* pPage = static_cast( GetPage(static_cast(nTab)) ); if (pPage) pPage->SetName(rNewName); } void ScDrawLayer::ScMovePage( sal_uInt16 nOldPos, sal_uInt16 nNewPos ) { MovePage( nOldPos, nNewPos ); sal_uInt16 nMinPos = std::min(nOldPos, nNewPos); ResetTab(nMinPos, pDoc->GetTableCount()-1); } void ScDrawLayer::ScCopyPage( sal_uInt16 nOldPos, sal_uInt16 nNewPos ) { if (bDrawIsInUndo) return; SdrPage* pOldPage = GetPage(nOldPos); SdrPage* pNewPage = GetPage(nNewPos); // Copying if (pOldPage && pNewPage) { SCTAB nOldTab = static_cast(nOldPos); SCTAB nNewTab = static_cast(nNewPos); SdrObjListIter aIter( pOldPage, SdrIterMode::Flat ); SdrObject* pOldObject = aIter.Next(); while (pOldObject) { ScDrawObjData* pOldData = GetObjData(pOldObject); if (pOldData) { pOldData->maStart.SetTab(nOldTab); pOldData->maEnd.SetTab(nOldTab); } // Clone to target SdrModel SdrObject* pNewObject(pOldObject->CloneSdrObject(*this)); pNewObject->NbcMove(Size(0,0)); pNewPage->InsertObject( pNewObject ); ScDrawObjData* pNewData = GetObjData(pNewObject); if (pNewData) { pNewData->maStart.SetTab(nNewTab); pNewData->maEnd.SetTab(nNewTab); } if (bRecording) AddCalcUndo( std::make_unique( *pNewObject ) ); pOldObject = aIter.Next(); } } ResetTab(static_cast(nNewPos), pDoc->GetTableCount()-1); } void ScDrawLayer::ResetTab( SCTAB nStart, SCTAB nEnd ) { SCTAB nPageSize = static_cast(GetPageCount()); if (nPageSize < 0) // No drawing pages exist. return; if (nEnd >= nPageSize) // Avoid iterating beyond the last existing page. nEnd = nPageSize - 1; for (SCTAB i = nStart; i <= nEnd; ++i) { SdrPage* pPage = GetPage(static_cast(i)); if (!pPage) continue; SdrObjListIter aIter(pPage, SdrIterMode::Flat); for (SdrObject* pObj = aIter.Next(); pObj; pObj = aIter.Next()) { ScDrawObjData* pData = GetObjData(pObj); if (!pData) continue; pData->maStart.SetTab(i); pData->maEnd.SetTab(i); } } } static bool IsInBlock( const ScAddress& rPos, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2 ) { return rPos.Col() >= nCol1 && rPos.Col() <= nCol2 && rPos.Row() >= nRow1 && rPos.Row() <= nRow2; } void ScDrawLayer::MoveCells( SCTAB nTab, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2, SCCOL nDx,SCROW nDy, bool bUpdateNoteCaptionPos ) { SdrPage* pPage = GetPage(static_cast(nTab)); OSL_ENSURE(pPage,"Page not found"); if (!pPage) return; bool bNegativePage = pDoc && pDoc->IsNegativePage( nTab ); const size_t nCount = pPage->GetObjCount(); for ( size_t i = 0; i < nCount; ++i ) { SdrObject* pObj = pPage->GetObj( i ); ScDrawObjData* pData = GetObjDataTab( pObj, nTab ); if( pData ) { const ScAddress aOldStt = pData->maStart; const ScAddress aOldEnd = pData->maEnd; bool bChange = false; if ( aOldStt.IsValid() && IsInBlock( aOldStt, nCol1,nRow1, nCol2,nRow2 ) ) { pData->maStart.IncCol( nDx ); pData->maStart.IncRow( nDy ); bChange = true; } if ( aOldEnd.IsValid() && IsInBlock( aOldEnd, nCol1,nRow1, nCol2,nRow2 ) ) { pData->maEnd.IncCol( nDx ); pData->maEnd.IncRow( nDy ); bChange = true; } if (bChange) { if ( dynamic_cast( pObj) != nullptr && pData->maStart.IsValid() && pData->maEnd.IsValid() ) pData->maStart.PutInOrder( pData->maEnd ); // Update also an untransformed anchor that's what we stored ( and still do ) to xml ScDrawObjData* pNoRotatedAnchor = GetNonRotatedObjData( pObj ); if ( pNoRotatedAnchor ) { const ScAddress aOldSttNoRotatedAnchor = pNoRotatedAnchor->maStart; const ScAddress aOldEndNoRotatedAnchor = pNoRotatedAnchor->maEnd; if ( aOldSttNoRotatedAnchor.IsValid() && IsInBlock( aOldSttNoRotatedAnchor, nCol1,nRow1, nCol2,nRow2 ) ) { pNoRotatedAnchor->maStart.IncCol(nDx); pNoRotatedAnchor->maStart.IncRow(nDy); } if ( aOldEndNoRotatedAnchor.IsValid() && IsInBlock( aOldEndNoRotatedAnchor, nCol1,nRow1, nCol2,nRow2 ) ) { pNoRotatedAnchor->maEnd.IncCol(nDx); pNoRotatedAnchor->maEnd.IncRow(nDy); } } AddCalcUndo( std::make_unique( pObj, aOldStt, aOldEnd, pData->maStart, pData->maEnd ) ); RecalcPos( pObj, *pData, bNegativePage, bUpdateNoteCaptionPos ); } } } } void ScDrawLayer::SetPageSize(sal_uInt16 nPageNo, const Size& rSize, bool bUpdateNoteCaptionPos, const ScObjectHandling eObjectHandling) { SdrPage* pPage = GetPage(nPageNo); if (!pPage) return; if ( rSize != pPage->GetSize() ) { pPage->SetSize( rSize ); Broadcast( ScTabSizeChangedHint( static_cast(nPageNo) ) ); // SetWorkArea() on the views } // Do not call RecalcPos while loading, because row height is not finished, when SetPageSize // is called first time. Instead the objects are initialized from ScXMLImport::endDocument() and // RecalcPos is called from there. if (!pDoc || pDoc->IsImportingXML()) return; // Implement Detective lines (adjust to new heights / widths) // even if size is still the same // (individual rows/columns can have been changed)) bool bNegativePage = pDoc && pDoc->IsNegativePage( static_cast(nPageNo) ); // Disable mass broadcasts from drawing objects' position changes. bool bWasLocked = isLocked(); setLock(true); const size_t nCount = pPage->GetObjCount(); for ( size_t i = 0; i < nCount; ++i ) { SdrObject* pObj = pPage->GetObj( i ); ScDrawObjData* pData = GetObjDataTab( pObj, static_cast(nPageNo) ); if( pData ) // cell anchored { if (pData->meType == ScDrawObjData::DrawingObject || pData->meType == ScDrawObjData::ValidationCircle) { switch (eObjectHandling) { case ScObjectHandling::RecalcPosMode: RecalcPos(pObj, *pData, bNegativePage, bUpdateNoteCaptionPos); break; case ScObjectHandling::MoveRTLMode: MoveRTL(pObj); break; case ScObjectHandling::MirrorRTLMode: MirrorRTL(pObj); break; } } else // DetectiveArrow and CellNote RecalcPos(pObj, *pData, bNegativePage, bUpdateNoteCaptionPos); } else // page anchored { switch (eObjectHandling) { case ScObjectHandling::MoveRTLMode: MoveRTL(pObj); break; case ScObjectHandling::MirrorRTLMode: MirrorRTL(pObj); break; case ScObjectHandling::RecalcPosMode: // does not occur for page anchored shapes break; } } } setLock(bWasLocked); } namespace { //Can't have a zero width dimension tools::Rectangle lcl_makeSafeRectangle(const tools::Rectangle &rNew) { tools::Rectangle aRect = rNew; if (aRect.Bottom() == aRect.Top()) aRect.SetBottom( aRect.Top()+1 ); if (aRect.Right() == aRect.Left()) aRect.SetRight( aRect.Left()+1 ); return aRect; } Point lcl_calcAvailableDiff(const ScDocument &rDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, const Point &aWantedDiff) { Point aAvailableDiff(aWantedDiff); tools::Long nHeight = o3tl::convert(rDoc.GetRowHeight( nRow, nTab ), o3tl::Length::twip, o3tl::Length::mm100); tools::Long nWidth = o3tl::convert(rDoc.GetColWidth( nCol, nTab ), o3tl::Length::twip, o3tl::Length::mm100); if (aAvailableDiff.Y() > nHeight) aAvailableDiff.setY( nHeight ); if (aAvailableDiff.X() > nWidth) aAvailableDiff.setX( nWidth ); return aAvailableDiff; } tools::Rectangle lcl_UpdateCalcPoly(basegfx::B2DPolygon &rCalcPoly, int nWhichPoint, const Point &rPos) { rCalcPoly.setB2DPoint(nWhichPoint, basegfx::B2DPoint(rPos.X(), rPos.Y())); basegfx::B2DRange aRange(basegfx::utils::getRange(rCalcPoly)); return tools::Rectangle(static_cast(aRange.getMinX()), static_cast(aRange.getMinY()), static_cast(aRange.getMaxX()), static_cast(aRange.getMaxY())); } bool lcl_AreRectanglesApproxEqual(const tools::Rectangle& rRectA, const tools::Rectangle& rRectB) { // Twips <-> Hmm conversions introduce +-1 differences although there are no real changes in the object. // Therefore test with == is not appropriate in some cases. if (std::abs(rRectA.Left() - rRectB.Left()) > 1) return false; if (std::abs(rRectA.Top() - rRectB.Top()) > 1) return false; if (std::abs(rRectA.Right() - rRectB.Right()) > 1) return false; if (std::abs(rRectA.Bottom() - rRectB.Bottom()) > 1) return false; return true; } bool lcl_NeedsMirrorYCorrection(const SdrObject* pObj) { return pObj->GetObjIdentifier() == SdrObjKind::CustomShape && static_cast(pObj)->IsMirroredY(); } void lcl_SetLogicRectFromAnchor(SdrObject* pObj, const ScDrawObjData& rAnchor, const ScDocument* pDoc) { // This is only used during initialization. At that time, shape handling is always LTR. No need // to consider negative page. if (!pObj || !pDoc || !rAnchor.maEnd.IsValid() || !rAnchor.maStart.IsValid()) return; // In case of a vertical mirrored custom shape, LibreOffice uses internally an additional 180deg // in aGeo.nRotationAngle and in turn has a different logic rectangle position. We remove flip, // set the logic rectangle, and apply flip again. You cannot simple use a 180deg-rotated // rectangle, because custom shape mirroring is internally applied after the other // transformations. const bool bNeedsMirrorYCorrection = lcl_NeedsMirrorYCorrection(pObj); // remember state if (bNeedsMirrorYCorrection) { const tools::Rectangle aRect(pObj->GetSnapRect()); const Point aLeft(aRect.Left(), (aRect.Top() + aRect.Bottom()) >> 1); const Point aRight(aLeft.X() + 1000, aLeft.Y()); pObj->NbcMirror(aLeft, aRight); } // Build full sized logic rectangle from start and end given in anchor. const tools::Rectangle aStartCellRect( pDoc->GetMMRect(rAnchor.maStart.Col(), rAnchor.maStart.Row(), rAnchor.maStart.Col(), rAnchor.maStart.Row(), rAnchor.maStart.Tab(), false /*bHiddenAsZero*/)); Point aStartPoint(aStartCellRect.Left(), aStartCellRect.Top()); aStartPoint.AdjustX(rAnchor.maStartOffset.getX()); aStartPoint.AdjustY(rAnchor.maStartOffset.getY()); const tools::Rectangle aEndCellRect( pDoc->GetMMRect(rAnchor.maEnd.Col(), rAnchor.maEnd.Row(), rAnchor.maEnd.Col(), rAnchor.maEnd.Row(), rAnchor.maEnd.Tab(), false /*bHiddenAsZero*/)); Point aEndPoint(aEndCellRect.Left(), aEndCellRect.Top()); aEndPoint.AdjustX(rAnchor.maEndOffset.getX()); aEndPoint.AdjustY(rAnchor.maEndOffset.getY()); // Set this as new, full sized logical rectangle tools::Rectangle aNewRectangle(aStartPoint, aEndPoint); aNewRectangle.Justify(); if (!lcl_AreRectanglesApproxEqual(pObj->GetLogicRect(), aNewRectangle)) pObj->NbcSetLogicRect(lcl_makeSafeRectangle(aNewRectangle)); // The shape has the correct logical rectangle now. Reapply the above removed mirroring. if (bNeedsMirrorYCorrection) { const tools::Rectangle aRect(pObj->GetSnapRect()); const Point aLeft(aRect.Left(), (aRect.Top() + aRect.Bottom()) >> 1); const Point aRight(aLeft.X() + 1000, aLeft.Y()); pObj->NbcMirror(aLeft, aRight); } } } // namespace void ScDrawLayer::ResizeLastRectFromAnchor(const SdrObject* pObj, ScDrawObjData& rData, bool bNegativePage, bool bCanResize) { tools::Rectangle aRect = pObj->GetSnapRect(); SCCOL nCol1 = rData.maStart.Col(); SCROW nRow1 = rData.maStart.Row(); SCTAB nTab1 = rData.maStart.Tab(); SCCOL nCol2 = rData.maEnd.Col(); SCROW nRow2 = rData.maEnd.Row(); SCTAB nTab2 = rData.maEnd.Tab(); Point aPos(pDoc->GetColOffset(nCol1, nTab1, /*bHiddenAsZero*/true), pDoc->GetRowOffset(nRow1, nTab1, /*bHiddenAsZero*/true)); aPos.setX(convertTwipToMm100(aPos.X())); aPos.setY(convertTwipToMm100(aPos.Y())); aPos += lcl_calcAvailableDiff(*pDoc, nCol1, nRow1, nTab1, rData.maStartOffset); // this sets the needed changed position (translation) aRect.SetPos(aPos); if (bCanResize) { // all this stuff is additional stuff to evtl. not only translate the // range (Rectangle), but also check for and evtl. do corrections for it's size const tools::Rectangle aLastCellRect(rData.getLastCellRect()); // If the row was hidden before, or we don't have a valid cell rect, calculate the // new rect based on the end point. // Also when the end point is set, we need to consider it. if (rData.mbWasInHiddenRow || aLastCellRect.IsEmpty() || nRow1 != nRow2 || nCol1 != nCol2) { Point aEnd(pDoc->GetColOffset(nCol2, nTab2, /*bHiddenAsZero*/true), pDoc->GetRowOffset(nRow2, nTab2, /*bHiddenAsZero*/true)); aEnd.setX(convertTwipToMm100(aEnd.X())); aEnd.setY(convertTwipToMm100(aEnd.Y())); aEnd += lcl_calcAvailableDiff(*pDoc, nCol2, nRow2, nTab2, rData.maEndOffset); aRect = tools::Rectangle(aPos, aEnd); } else if (!aLastCellRect.IsEmpty()) { // We calculate based on the last cell rect to be able to scale the image // as much as the cell was scaled. // Still, we keep the image in its current cell (to keep start anchor == end anchor) const tools::Rectangle aCurrentCellRect(GetCellRect(*GetDocument(), rData.maStart, true)); tools::Long nCurrentWidth(aCurrentCellRect.GetWidth()); tools::Long nCurrentHeight(aCurrentCellRect.GetHeight()); const tools::Long nLastWidth(aLastCellRect.GetWidth()); const tools::Long nLastHeight(aLastCellRect.GetHeight()); // tdf#116931 Avoid and correct nifty numerical problems with the integer // based and converted values (GetCellRect uses multiplies with HMM_PER_TWIPS) if(nCurrentWidth + 1 == nLastWidth || nCurrentWidth == nLastWidth + 1) { nCurrentWidth = nLastWidth; } if(nCurrentHeight + 1 == nLastHeight || nCurrentHeight == nLastHeight + 1) { nCurrentHeight = nLastHeight; } // get initial ScalingFactors double fWidthFactor(nCurrentWidth == nLastWidth || 0 == nLastWidth ? 1.0 : static_cast(nCurrentWidth) / static_cast(nLastWidth)); double fHeightFactor(nCurrentHeight == nLastHeight || 0 == nLastHeight ? 1.0 : static_cast(nCurrentHeight) / static_cast(nLastHeight)); // check if we grow or shrink - and at all const bool bIsGrowing(nCurrentWidth > nLastWidth || nCurrentHeight > nLastHeight); const bool bIsShrinking(nCurrentWidth < nLastWidth || nCurrentHeight < nLastHeight); const bool bIsSizeChanged(bIsGrowing || bIsShrinking); // handle AspectRatio, only needed if size does change if(bIsSizeChanged && pObj->shouldKeepAspectRatio()) { tools::Rectangle aRectIncludingOffset = aRect; aRectIncludingOffset.setWidth(aRect.GetWidth() + rData.maStartOffset.X()); aRectIncludingOffset.setHeight(aRect.GetHeight() + rData.maStartOffset.Y()); tools::Long nWidth = aRectIncludingOffset.GetWidth(); assert(nWidth && "div-by-zero"); double fMaxWidthFactor = static_cast(nCurrentWidth) / static_cast(nWidth); tools::Long nHeight = aRectIncludingOffset.GetHeight(); assert(nHeight && "div-by-zero"); double fMaxHeightFactor = static_cast(nCurrentHeight) / static_cast(nHeight); double fMaxFactor = std::min(fMaxHeightFactor, fMaxWidthFactor); if(bIsGrowing) // cell is growing larger { // To actually grow the image, we need to take the max fWidthFactor = std::max(fWidthFactor, fHeightFactor); } else if(bIsShrinking) // cell is growing smaller, take the min { fWidthFactor = std::min(fWidthFactor, fHeightFactor); } // We don't want the image to become larger than the current cell fWidthFactor = fHeightFactor = std::min(fWidthFactor, fMaxFactor); } if(bIsSizeChanged) { // tdf#116931 re-organized scaling (if needed) // Check if we need to scale at all. Always scale on growing. bool bNeedToScale(bIsGrowing); if(!bNeedToScale && bIsShrinking) { // Check if original still fits into space. Do *not* forget to // compare with evtl. numerically corrected aCurrentCellRect const bool bFitsInX(aRect.Right() <= aCurrentCellRect.Left() + nCurrentWidth); const bool bFitsInY(aRect.Bottom() <= aCurrentCellRect.Top() + nCurrentHeight); // If the image still fits in the smaller cell, don't resize it at all bNeedToScale = (!bFitsInX || !bFitsInY); } if(bNeedToScale) { // tdf#116931 use transformations now. Translation is already applied // (see aRect.SetPos above), so only scale needs to be applied - relative // to *new* CellRect (which is aCurrentCellRect). // Prepare scale relative to top-left of aCurrentCellRect basegfx::B2DHomMatrix aChange; aChange.translate(-aCurrentCellRect.Left(), -aCurrentCellRect.Top()); aChange.scale(fWidthFactor, fHeightFactor); aChange.translate(aCurrentCellRect.Left(), aCurrentCellRect.Top()); // create B2DRange and transform by prepared scale basegfx::B2DRange aNewRange = vcl::unotools::b2DRectangleFromRectangle(aRect); aNewRange.transform(aChange); // apply to aRect aRect = tools::Rectangle( basegfx::fround(aNewRange.getMinX()), basegfx::fround(aNewRange.getMinY()), basegfx::fround(aNewRange.getMaxX()), basegfx::fround(aNewRange.getMaxY())); } } } } if (bNegativePage) MirrorRectRTL(aRect); rData.setShapeRect(GetDocument(), lcl_makeSafeRectangle(aRect), pObj->IsVisible()); } void ScDrawLayer::InitializeCellAnchoredObj(SdrObject* pObj, ScDrawObjData& rData) { // This is called from ScXMLImport::endDocument() if (!pDoc || !pObj) return; if (!rData.getShapeRect().IsEmpty()) return; // already initialized, should not happen if (rData.meType == ScDrawObjData::CellNote || rData.meType == ScDrawObjData::ValidationCircle || rData.meType == ScDrawObjData::DetectiveArrow) return; // handled in RecalcPos // Prevent multiple broadcasts during the series of changes. bool bWasLocked = pObj->getSdrModelFromSdrObject().isLocked(); pObj->getSdrModelFromSdrObject().setLock(true); // rNoRotatedAnchor refers in its start and end addresses and its start and end offsets to // the logic rectangle of the object. The values are so, as if no hidden columns and rows // exists and if it is a LTR sheet. These values are directly used for XML in ODF file. ScDrawObjData& rNoRotatedAnchor = *GetNonRotatedObjData(pObj, true /*bCreate*/); // From XML import, rData contains temporarily the anchor information as they are given in // XML. Copy it to rNoRotatedAnchor, where it belongs. rData will later contain the anchor // of the transformed object as visible on screen. rNoRotatedAnchor.maStart = rData.maStart; rNoRotatedAnchor.maEnd = rData.maEnd; rNoRotatedAnchor.maStartOffset = rData.maStartOffset; rNoRotatedAnchor.maEndOffset = rData.maEndOffset; SCCOL nCol1 = rNoRotatedAnchor.maStart.Col(); SCROW nRow1 = rNoRotatedAnchor.maStart.Row(); SCTAB nTab1 = rNoRotatedAnchor.maStart.Tab(); // Used as parameter several times // Object has coordinates relative to left/top of containing cell in XML. Change object to // absolute coordinates as internally used. const tools::Rectangle aRect( pDoc->GetMMRect(nCol1, nRow1, nCol1, nRow1, nTab1, false /*bHiddenAsZero*/)); const Size aShift(aRect.Left(), aRect.Top()); pObj->NbcMove(aShift); const ScAnchorType aAnchorType = ScDrawLayer::GetAnchorType(*pObj); if (aAnchorType == SCA_CELL_RESIZE) { if (pObj->GetObjIdentifier() == SdrObjKind::Line) { // Horizontal lines might have wrong start and end anchor because of erroneously applied // 180deg rotation (tdf#137446). Other lines have wrong end anchor. Coordinates in // object are correct. Use them for recreating the anchor. const basegfx::B2DPolygon aPoly( static_cast(pObj)->GetPathPoly().getB2DPolygon(0)); const basegfx::B2DPoint aB2DPoint0(aPoly.getB2DPoint(0)); const basegfx::B2DPoint aB2DPoint1(aPoly.getB2DPoint(1)); const Point aPointLT(FRound(std::min(aB2DPoint0.getX(), aB2DPoint1.getX())), FRound(std::min(aB2DPoint0.getY(), aB2DPoint1.getY()))); const Point aPointRB(FRound(std::max(aB2DPoint0.getX(), aB2DPoint1.getX())), FRound(std::max(aB2DPoint0.getY(), aB2DPoint1.getY()))); const tools::Rectangle aObjRect(aPointLT, aPointRB); GetCellAnchorFromPosition(aObjRect, rNoRotatedAnchor, *pDoc, nTab1, false /*bHiddenAsZero*/); } else if (pObj->GetObjIdentifier() == SdrObjKind::Measure) { // Measure lines might have got wrong start and end anchor from XML import. Recreate // anchor from start and end point. SdrMeasureObj* pMeasureObj = static_cast(pObj); // tdf#137576. The logic rectangle has likely no current values here, but only the // 1cm x 1cm default size. The call of TakeUnrotatedSnapRect is currently (LO 7.2) // the only way to force a recalc of the logic rectangle. tools::Rectangle aObjRect; pMeasureObj->TakeUnrotatedSnapRect(aObjRect); GetCellAnchorFromPosition(aObjRect, rNoRotatedAnchor, *pDoc, rData.maStart.Tab(), false /*bHiddenAsZero*/); } else { // In case there are hidden rows or cols, versions 7.0 and earlier have written width and // height in file so that hidden row or col are count as zero. XML import bases the // logical rectangle of the object on it. Shapes have at least wrong size, when row or col // are shown. We try to regenerate the logic rectangle as far as possible from the anchor. // ODF specifies anyway, that the size has to be ignored, if end cell attributes exist. lcl_SetLogicRectFromAnchor(pObj, rNoRotatedAnchor, pDoc); } } else // aAnchorType == SCA_CELL, other types will not occur here. { // XML has no end cell address in this case. We generate it from position. UpdateCellAnchorFromPositionEnd(*pObj, rNoRotatedAnchor, *pDoc, nTab1, true /*bUseLogicRect*/); } // Make sure maShapeRect of rNoRotatedAnchor is not empty. Method ScDrawView::Notify() // needs it to detect a change in object geometry. For example a 180deg rotation effects only // logic rect. rNoRotatedAnchor.setShapeRect(GetDocument(), pObj->GetLogicRect(), true); // Start and end addresses and offsets in rData refer to the actual snap rectangle of the // shape. We initialize them here based on the "full" sized object. Adaptation to reduced size // (by hidden row/col) is done later in RecalcPos. GetCellAnchorFromPosition(pObj->GetSnapRect(), rData, *pDoc, nTab1, false /*bHiddenAsZero*/); // As of ODF 1.3 strict there is no attribute to store whether an object is hidden. So a "visible" // object might actually be hidden by being in hidden row or column. We detect it here. // Note, that visibility by hidden row or column refers to the snap rectangle. if (pObj->IsVisible() && (pDoc->RowHidden(rData.maStart.Row(), rData.maStart.Tab()) || pDoc->ColHidden(rData.maStart.Col(), rData.maStart.Tab()))) pObj->SetVisible(false); // Set visibility. ToDo: Really used? rNoRotatedAnchor.setShapeRect(GetDocument(), pObj->GetLogicRect(), pObj->IsVisible()); // And set maShapeRect in rData. It stores not only the current rectangles, but currently, // existence of maShapeRect is the flag for initialization is done. rData.setShapeRect(GetDocument(), pObj->GetSnapRect(), pObj->IsVisible()); pObj->getSdrModelFromSdrObject().setLock(bWasLocked); } void ScDrawLayer::RecalcPos( SdrObject* pObj, ScDrawObjData& rData, bool bNegativePage, bool bUpdateNoteCaptionPos ) { OSL_ENSURE( pDoc, "ScDrawLayer::RecalcPos - missing document" ); if( !pDoc ) return; if (rData.meType == ScDrawObjData::CellNote) { OSL_ENSURE( rData.maStart.IsValid(), "ScDrawLayer::RecalcPos - invalid position for cell note" ); /* #i109372# On insert/remove rows/columns/cells: Updating the caption position must not be done, if the cell containing the note has not been moved yet in the document. The calling code now passes an additional boolean stating if the cells are already moved. */ /* tdf #152081 Do not change hidden objects. That would produce zero height or width and loss of caption.*/ if (bUpdateNoteCaptionPos && pObj->IsVisible()) { /* When inside an undo action, there may be pending note captions where cell note is already deleted (thus document cannot find the note object anymore). The caption will be deleted later with drawing undo. */ if( ScPostIt* pNote = pDoc->GetNote( rData.maStart ) ) pNote->UpdateCaptionPos( rData.maStart ); } return; } bool bValid1 = rData.maStart.IsValid(); SCCOL nCol1 = rData.maStart.Col(); SCROW nRow1 = rData.maStart.Row(); SCTAB nTab1 = rData.maStart.Tab(); bool bValid2 = rData.maEnd.IsValid(); SCCOL nCol2 = rData.maEnd.Col(); SCROW nRow2 = rData.maEnd.Row(); SCTAB nTab2 = rData.maEnd.Tab(); if (rData.meType == ScDrawObjData::ValidationCircle) { // Validation circle for detective. rData.setShapeRect(GetDocument(), pObj->GetLogicRect()); // rData.maStart should contain the address of the be validated cell. tools::Rectangle aRect = GetCellRect(*GetDocument(), rData.maStart, true); aRect.AdjustLeft( -250 ); aRect.AdjustRight(250 ); aRect.AdjustTop( -70 ); aRect.AdjustBottom(70 ); if ( bNegativePage ) MirrorRectRTL( aRect ); if ( pObj->GetLogicRect() != aRect ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); rData.setShapeRect(GetDocument(), lcl_makeSafeRectangle(aRect)); // maStart has the meaning of "to be validated cell" in a validation circle. For usual // drawing objects it has the meaning "left/top of logic/snap rect". Because the rectangle // is expanded above, SetLogicRect() will set maStart to one cell left and one cell above // of the to be validated cell. We need to backup the old value and restore it. ScAddress aBackup(rData.maStart); pObj->SetLogicRect(rData.getShapeRect()); rData.maStart = aBackup; } } else if (rData.meType == ScDrawObjData::DetectiveArrow) { rData.setShapeRect(GetDocument(), pObj->GetLogicRect()); basegfx::B2DPolygon aCalcPoly; Point aOrigStartPos(pObj->GetPoint(0)); Point aOrigEndPos(pObj->GetPoint(1)); aCalcPoly.append(basegfx::B2DPoint(aOrigStartPos.X(), aOrigStartPos.Y())); aCalcPoly.append(basegfx::B2DPoint(aOrigEndPos.X(), aOrigEndPos.Y())); //TODO: do not create multiple Undos for one object (last one can be omitted then) SCCOL nLastCol; SCROW nLastRow; if( bValid1 ) { Point aPos( pDoc->GetColOffset( nCol1, nTab1 ), pDoc->GetRowOffset( nRow1, nTab1 ) ); if (!pDoc->ColHidden(nCol1, nTab1, nullptr, &nLastCol)) aPos.AdjustX(pDoc->GetColWidth( nCol1, nTab1 ) / 4 ); if (!pDoc->RowHidden(nRow1, nTab1, nullptr, &nLastRow)) aPos.AdjustY(pDoc->GetRowHeight( nRow1, nTab1 ) / 2 ); aPos.setX(convertTwipToMm100(aPos.X())); aPos.setY(convertTwipToMm100(aPos.Y())); Point aStartPos = aPos; if ( bNegativePage ) aStartPos.setX( -aStartPos.X() ); // don't modify aPos - used below if ( pObj->GetPoint( 0 ) != aStartPos ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); rData.setShapeRect(GetDocument(), lcl_UpdateCalcPoly(aCalcPoly, 0, aStartPos)); pObj->SetPoint( aStartPos, 0 ); } if( !bValid2 ) { Point aEndPos( aPos.X() + DET_ARROW_OFFSET, aPos.Y() - DET_ARROW_OFFSET ); if (aEndPos.Y() < 0) aEndPos.AdjustY(2 * DET_ARROW_OFFSET); if ( bNegativePage ) aEndPos.setX( -aEndPos.X() ); if ( pObj->GetPoint( 1 ) != aEndPos ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); rData.setShapeRect(GetDocument(), lcl_UpdateCalcPoly(aCalcPoly, 1, aEndPos)); pObj->SetPoint( aEndPos, 1 ); } } } if( bValid2 ) { Point aPos( pDoc->GetColOffset( nCol2, nTab2 ), pDoc->GetRowOffset( nRow2, nTab2 ) ); if (!pDoc->ColHidden(nCol2, nTab2, nullptr, &nLastCol)) aPos.AdjustX(pDoc->GetColWidth( nCol2, nTab2 ) / 4 ); if (!pDoc->RowHidden(nRow2, nTab2, nullptr, &nLastRow)) aPos.AdjustY(pDoc->GetRowHeight( nRow2, nTab2 ) / 2 ); aPos.setX(convertTwipToMm100(aPos.X())); aPos.setY(convertTwipToMm100(aPos.Y())); Point aEndPos = aPos; if ( bNegativePage ) aEndPos.setX( -aEndPos.X() ); // don't modify aPos - used below if ( pObj->GetPoint( 1 ) != aEndPos ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); rData.setShapeRect(GetDocument(), lcl_UpdateCalcPoly(aCalcPoly, 1, aEndPos)); pObj->SetPoint( aEndPos, 1 ); } if( !bValid1 ) { Point aStartPos( aPos.X() - DET_ARROW_OFFSET, aPos.Y() - DET_ARROW_OFFSET ); if (aStartPos.X() < 0) aStartPos.AdjustX(2 * DET_ARROW_OFFSET); if (aStartPos.Y() < 0) aStartPos.AdjustY(2 * DET_ARROW_OFFSET); if ( bNegativePage ) aStartPos.setX( -aStartPos.X() ); if ( pObj->GetPoint( 0 ) != aStartPos ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); rData.setShapeRect(GetDocument(), lcl_UpdateCalcPoly(aCalcPoly, 0, aStartPos)); pObj->SetPoint( aStartPos, 0 ); } } } } // end ScDrawObjData::DetectiveArrow else // start ScDrawObjData::DrawingObject { // Do not change hidden objects. That would produce zero height or width and loss of offsets. if (!pObj->IsVisible()) return; // Prevent multiple broadcasts during the series of changes. bool bWasLocked = pObj->getSdrModelFromSdrObject().isLocked(); pObj->getSdrModelFromSdrObject().setLock(true); bool bCanResize = bValid2 && !pObj->IsResizeProtect() && rData.mbResizeWithCell; // update anchor with snap rect ResizeLastRectFromAnchor( pObj, rData, bNegativePage, bCanResize ); ScDrawObjData& rNoRotatedAnchor = *GetNonRotatedObjData( pObj, true /*bCreate*/); if( bCanResize ) { tools::Rectangle aNew = rData.getShapeRect(); tools::Rectangle aOld(pObj->GetSnapRect()); if (!lcl_AreRectanglesApproxEqual(aNew, aOld)) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); // ToDo: Implement NbcSetSnapRect of SdrMeasureObj. Then this can be removed. tools::Long nOldWidth = aOld.GetWidth(); tools::Long nOldHeight = aOld.GetHeight(); if (pObj->IsPolyObj() && nOldWidth && nOldHeight) { // Polyline objects need special treatment. Size aSizeMove(aNew.Left()-aOld.Left(), aNew.Top()-aOld.Top()); pObj->NbcMove(aSizeMove); double fXFrac = static_cast(aNew.GetWidth()) / static_cast(nOldWidth); double fYFrac = static_cast(aNew.GetHeight()) / static_cast(nOldHeight); pObj->NbcResize(aNew.TopLeft(), Fraction(fXFrac), Fraction(fYFrac)); } rData.setShapeRect(GetDocument(), lcl_makeSafeRectangle(rData.getShapeRect()), pObj->IsVisible()); if (pObj->GetObjIdentifier() == SdrObjKind::CustomShape) pObj->AdjustToMaxRect(rData.getShapeRect()); else pObj->SetSnapRect(rData.getShapeRect()); // The shape rectangle in the 'unrotated' anchor needs to be updated to the changed // object geometry. It is used in adjustAnchoredPosition() in ScDrawView::Notify(). rNoRotatedAnchor.setShapeRect(pDoc, pObj->GetLogicRect(), pObj->IsVisible()); } } else { const Point aPos(rData.getShapeRect().TopLeft()); if ( pObj->GetRelativePos() != aPos ) { if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); pObj->SetRelativePos( aPos ); rNoRotatedAnchor.setShapeRect(pDoc, pObj->GetLogicRect(), pObj->IsVisible()); } } /* * If we were not allowed resize the object, then the end cell anchor * is possibly incorrect now, and if the object has no end-cell (e.g. * missing in original .xml) we are also forced to generate one */ bool bEndAnchorIsBad = !bValid2 || pObj->IsResizeProtect(); if (bEndAnchorIsBad) { // update 'rotated' anchor ScDrawLayer::UpdateCellAnchorFromPositionEnd(*pObj, rData, *pDoc, nTab1, false); // update 'unrotated' anchor ScDrawLayer::UpdateCellAnchorFromPositionEnd(*pObj, rNoRotatedAnchor, *pDoc, nTab1 ); } // End prevent multiple broadcasts during the series of changes. pObj->getSdrModelFromSdrObject().setLock(bWasLocked); if (!bWasLocked) pObj->BroadcastObjectChange(); } // end ScDrawObjData::DrawingObject } bool ScDrawLayer::GetPrintArea( ScRange& rRange, bool bSetHor, bool bSetVer ) const { OSL_ENSURE( pDoc, "ScDrawLayer::GetPrintArea without document" ); if ( !pDoc ) return false; SCTAB nTab = rRange.aStart.Tab(); OSL_ENSURE( rRange.aEnd.Tab() == nTab, "GetPrintArea: Tab differ" ); bool bNegativePage = pDoc->IsNegativePage( nTab ); bool bAny = false; tools::Long nEndX = 0; tools::Long nEndY = 0; tools::Long nStartX = LONG_MAX; tools::Long nStartY = LONG_MAX; // Calculate borders if (!bSetHor) { nStartX = 0; SCCOL nStartCol = rRange.aStart.Col(); SCCOL i; for (i=0; iGetColWidth(i,nTab); nEndX = nStartX; SCCOL nEndCol = rRange.aEnd.Col(); for (i=nStartCol; i<=nEndCol; i++) nEndX += pDoc->GetColWidth(i,nTab); nStartX = convertTwipToMm100(nStartX); nEndX = convertTwipToMm100(nEndX); } if (!bSetVer) { nStartY = pDoc->GetRowHeight( 0, rRange.aStart.Row()-1, nTab); nEndY = nStartY + pDoc->GetRowHeight( rRange.aStart.Row(), rRange.aEnd.Row(), nTab); nStartY = convertTwipToMm100(nStartY); nEndY = convertTwipToMm100(nEndY); } if ( bNegativePage ) { nStartX = -nStartX; // positions are negative, swap start/end so the same comparisons work nEndX = -nEndX; ::std::swap( nStartX, nEndX ); } const SdrPage* pPage = GetPage(static_cast(nTab)); OSL_ENSURE(pPage,"Page not found"); if (pPage) { SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); while (pObject) { //TODO: test Flags (hidden?) tools::Rectangle aObjRect = pObject->GetCurrentBoundRect(); bool bFit = true; if ( !bSetHor && ( aObjRect.Right() < nStartX || aObjRect.Left() > nEndX ) ) bFit = false; if ( !bSetVer && ( aObjRect.Bottom() < nStartY || aObjRect.Top() > nEndY ) ) bFit = false; // #i104716# don't include hidden note objects if ( bFit && pObject->GetLayer() != SC_LAYER_HIDDEN ) { if (bSetHor) { if (aObjRect.Left() < nStartX) nStartX = aObjRect.Left(); if (aObjRect.Right() > nEndX) nEndX = aObjRect.Right(); } if (bSetVer) { if (aObjRect.Top() < nStartY) nStartY = aObjRect.Top(); if (aObjRect.Bottom() > nEndY) nEndY = aObjRect.Bottom(); } bAny = true; } pObject = aIter.Next(); } } if ( bNegativePage ) { nStartX = -nStartX; // reverse transformation, so the same cell address calculation works nEndX = -nEndX; ::std::swap( nStartX, nEndX ); } if (bAny) { OSL_ENSURE( nStartX<=nEndX && nStartY<=nEndY, "Start/End wrong in ScDrawLayer::GetPrintArea" ); if (bSetHor) { nStartX = o3tl::toTwips(nStartX, o3tl::Length::mm100); nEndX = o3tl::toTwips(nEndX, o3tl::Length::mm100); tools::Long nWidth; nWidth = 0; rRange.aStart.SetCol( 0 ); if (nWidth <= nStartX) { for (SCCOL nCol : pDoc->GetColumnsRange(nTab, 0, pDoc->MaxCol())) { nWidth += pDoc->GetColWidth(nCol,nTab); if (nWidth > nStartX) { rRange.aStart.SetCol( nCol ); break; } } } nWidth = 0; rRange.aEnd.SetCol( 0 ); if (nWidth <= nEndX) { for (SCCOL nCol : pDoc->GetColumnsRange(nTab, 0, pDoc->MaxCol())) //TODO: start at Start { nWidth += pDoc->GetColWidth(nCol,nTab); if (nWidth > nEndX) { rRange.aEnd.SetCol( nCol ); break; } } } } if (bSetVer) { nStartY = o3tl::toTwips(nStartY, o3tl::Length::mm100); nEndY = o3tl::toTwips(nEndY, o3tl::Length::mm100); SCROW nRow = pDoc->GetRowForHeight( nTab, nStartY); rRange.aStart.SetRow( nRow>0 ? (nRow-1) : 0); nRow = pDoc->GetRowForHeight( nTab, nEndY); rRange.aEnd.SetRow( nRow == pDoc->MaxRow() ? pDoc->MaxRow() : (nRow>0 ? (nRow-1) : 0)); } } else { if (bSetHor) { rRange.aStart.SetCol(0); rRange.aEnd.SetCol(0); } if (bSetVer) { rRange.aStart.SetRow(0); rRange.aEnd.SetRow(0); } } return bAny; } void ScDrawLayer::AddCalcUndo( std::unique_ptr pUndo ) { if (bRecording) { if (!pUndoGroup) pUndoGroup.reset(new SdrUndoGroup(*this)); pUndoGroup->AddAction( std::move(pUndo) ); } } void ScDrawLayer::BeginCalcUndo(bool bDisableTextEditUsesCommonUndoManager) { SetDisableTextEditUsesCommonUndoManager(bDisableTextEditUsesCommonUndoManager); pUndoGroup.reset(); bRecording = true; } std::unique_ptr ScDrawLayer::GetCalcUndo() { std::unique_ptr pRet = std::move(pUndoGroup); bRecording = false; SetDisableTextEditUsesCommonUndoManager(false); return pRet; } void ScDrawLayer::MoveArea( SCTAB nTab, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2, SCCOL nDx,SCROW nDy, bool bInsDel, bool bUpdateNoteCaptionPos ) { OSL_ENSURE( pDoc, "ScDrawLayer::MoveArea without document" ); if ( !pDoc ) return; if (!bAdjustEnabled) return; bool bNegativePage = pDoc->IsNegativePage( nTab ); tools::Rectangle aRect = pDoc->GetMMRect( nCol1, nRow1, nCol2, nRow2, nTab ); lcl_ReverseTwipsToMM( aRect ); //TODO: use twips directly? Point aMove; if (nDx > 0) for (SCCOL s=0; sGetColWidth(s+nCol1,nTab) ); else for (SCCOL s=-1; s>=nDx; s--) aMove.AdjustX( -(pDoc->GetColWidth(s+nCol1,nTab)) ); if (nDy > 0) aMove.AdjustY(pDoc->GetRowHeight( nRow1, nRow1+nDy-1, nTab) ); else aMove.AdjustY( -sal_Int16(pDoc->GetRowHeight( nRow1+nDy, nRow1-1, nTab)) ); if ( bNegativePage ) aMove.setX( -aMove.X() ); Point aTopLeft = aRect.TopLeft(); // Beginning when zoomed out if (bInsDel) { if ( aMove.X() != 0 && nDx < 0 ) // nDx counts cells, sign is independent of RTL aTopLeft.AdjustX(aMove.X() ); if ( aMove.Y() < 0 ) aTopLeft.AdjustY(aMove.Y() ); } // Detectiv arrows: Adjust cell position MoveCells( nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy, bUpdateNoteCaptionPos ); } bool ScDrawLayer::HasObjectsInRows( SCTAB nTab, SCROW nStartRow, SCROW nEndRow ) { OSL_ENSURE( pDoc, "ScDrawLayer::HasObjectsInRows without document" ); if ( !pDoc ) return false; SdrPage* pPage = GetPage(static_cast(nTab)); OSL_ENSURE(pPage,"Page not found"); if (!pPage) return false; // for an empty page, there's no need to calculate the row heights if (!pPage->GetObjCount()) return false; tools::Rectangle aTestRect; aTestRect.AdjustTop(pDoc->GetRowHeight( 0, nStartRow-1, nTab) ); if (nEndRow==pDoc->MaxRow()) aTestRect.SetBottom( MAXMM ); else { aTestRect.SetBottom( aTestRect.Top() ); aTestRect.AdjustBottom(pDoc->GetRowHeight( nStartRow, nEndRow, nTab) ); aTestRect.SetBottom(convertTwipToMm100(aTestRect.Bottom())); } aTestRect.SetTop(convertTwipToMm100(aTestRect.Top())); aTestRect.SetLeft( 0 ); aTestRect.SetRight( MAXMM ); bool bNegativePage = pDoc->IsNegativePage( nTab ); if ( bNegativePage ) MirrorRectRTL( aTestRect ); bool bFound = false; tools::Rectangle aObjRect; SdrObjListIter aIter( pPage ); SdrObject* pObject = aIter.Next(); while ( pObject && !bFound ) { aObjRect = pObject->GetSnapRect(); //TODO: GetLogicRect ? if (aTestRect.Contains(aObjRect.TopLeft()) || aTestRect.Contains(aObjRect.BottomLeft())) bFound = true; pObject = aIter.Next(); } return bFound; } void ScDrawLayer::DeleteObjectsInArea( SCTAB nTab, SCCOL nCol1,SCROW nRow1, SCCOL nCol2,SCROW nRow2, bool bAnchored ) { OSL_ENSURE( pDoc, "ScDrawLayer::DeleteObjectsInArea without document" ); if ( !pDoc ) return; SdrPage* pPage = GetPage(static_cast(nTab)); OSL_ENSURE(pPage,"Page ?"); if (!pPage) return; pPage->RecalcObjOrdNums(); const size_t nObjCount = pPage->GetObjCount(); if (!nObjCount) return; tools::Rectangle aDelRect = pDoc->GetMMRect( nCol1, nRow1, nCol2, nRow2, nTab ); tools::Rectangle aDelCircle = aDelRect; aDelCircle.AdjustLeft(-250); aDelCircle.AdjustRight(250); aDelCircle.AdjustTop(-70); aDelCircle.AdjustBottom(70); std::vector ppObj; ppObj.reserve(nObjCount); SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); while (pObject) { // do not delete note caption, they are always handled by the cell note // TODO: detective objects are still deleted, is this desired? if (!IsNoteCaption( pObject )) { tools::Rectangle aObjRect; ScDrawObjData* pObjData = ScDrawLayer::GetObjData(pObject); if (pObjData && pObjData->meType == ScDrawObjData::ValidationCircle) { aObjRect = pObject->GetLogicRect(); if(aDelCircle.Contains(aObjRect)) ppObj.push_back(pObject); } else { aObjRect = pObject->GetCurrentBoundRect(); if (aDelRect.Contains(aObjRect)) { if (bAnchored) { ScAnchorType aAnchorType = ScDrawLayer::GetAnchorType(*pObject); if (aAnchorType == SCA_CELL || aAnchorType == SCA_CELL_RESIZE) ppObj.push_back(pObject); } else ppObj.push_back(pObject); } } } pObject = aIter.Next(); } if (bRecording) for (auto p : ppObj) AddCalcUndo(std::make_unique(*p)); for (auto p : ppObj) pPage->RemoveObject(p->GetOrdNum()); } void ScDrawLayer::DeleteObjectsInSelection( const ScMarkData& rMark ) { OSL_ENSURE( pDoc, "ScDrawLayer::DeleteObjectsInSelection without document" ); if ( !pDoc ) return; if ( !rMark.IsMultiMarked() ) return; const ScRange& aMarkRange = rMark.GetMultiMarkArea(); SCTAB nTabCount = pDoc->GetTableCount(); for (const SCTAB nTab : rMark) { if (nTab >= nTabCount) break; SdrPage* pPage = GetPage(static_cast(nTab)); if (pPage) { pPage->RecalcObjOrdNums(); const size_t nObjCount = pPage->GetObjCount(); if (nObjCount) { // Rectangle around the whole selection tools::Rectangle aMarkBound = pDoc->GetMMRect( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), nTab ); std::vector ppObj; ppObj.reserve(nObjCount); SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); while (pObject) { // do not delete note caption, they are always handled by the cell note // TODO: detective objects are still deleted, is this desired? if (!IsNoteCaption( pObject )) { tools::Rectangle aObjRect = pObject->GetCurrentBoundRect(); ScRange aRange = pDoc->GetRange(nTab, aObjRect); bool bObjectInMarkArea = aMarkBound.Contains(aObjRect) && rMark.IsAllMarked(aRange); const ScDrawObjData* pObjData = ScDrawLayer::GetObjData(pObject); ScAnchorType aAnchorType = ScDrawLayer::GetAnchorType(*pObject); bool bObjectAnchoredToMarkedCell = ((aAnchorType == SCA_CELL || aAnchorType == SCA_CELL_RESIZE) && pObjData && pObjData->maStart.IsValid() && rMark.IsCellMarked(pObjData->maStart.Col(), pObjData->maStart.Row())); if (bObjectInMarkArea || bObjectAnchoredToMarkedCell) { ppObj.push_back(pObject); } } pObject = aIter.Next(); } // Delete objects (backwards) if (bRecording) for (auto p : ppObj) AddCalcUndo(std::make_unique(*p)); for (auto p : ppObj) pPage->RemoveObject(p->GetOrdNum()); } } else { OSL_FAIL("pPage?"); } } } void ScDrawLayer::CopyToClip( ScDocument* pClipDoc, SCTAB nTab, const tools::Rectangle& rRange ) { // copy everything in the specified range into the same page (sheet) in the clipboard doc SdrPage* pSrcPage = GetPage(static_cast(nTab)); if (!pSrcPage) return; ScDrawLayer* pDestModel = nullptr; SdrPage* pDestPage = nullptr; SdrObjListIter aIter( pSrcPage, SdrIterMode::Flat ); SdrObject* pOldObject = aIter.Next(); while (pOldObject) { tools::Rectangle aObjRect = pOldObject->GetCurrentBoundRect(); bool bObjectInArea = rRange.Contains(aObjRect); const ScDrawObjData* pObjData = ScDrawLayer::GetObjData(pOldObject); if (pObjData) { ScRange aClipRange = lcl_getClipRangeFromClipDoc(pClipDoc, nTab); bObjectInArea = bObjectInArea || aClipRange.Contains(pObjData->maStart); } // do not copy internal objects (detective) and note captions if (bObjectInArea && pOldObject->GetLayer() != SC_LAYER_INTERN && !IsNoteCaption(pOldObject)) { if ( !pDestModel ) { pDestModel = pClipDoc->GetDrawLayer(); // does the document already have a drawing layer? if ( !pDestModel ) { // allocate drawing layer in clipboard document only if there are objects to copy pClipDoc->InitDrawLayer(); //TODO: create contiguous pages pDestModel = pClipDoc->GetDrawLayer(); } if (pDestModel) pDestPage = pDestModel->GetPage( static_cast(nTab) ); } OSL_ENSURE( pDestPage, "no page" ); if (pDestPage) { // Clone to target SdrModel SdrObject* pNewObject(pOldObject->CloneSdrObject(*pDestModel)); uno::Reference< chart2::XChartDocument > xOldChart( ScChartHelper::GetChartFromSdrObject( pOldObject ) ); if(!xOldChart.is())//#i110034# do not move charts as they lose all their data references otherwise pNewObject->NbcMove(Size(0,0)); pDestPage->InsertObject( pNewObject ); // no undo needed in clipboard document // charts are not updated } } pOldObject = aIter.Next(); } } static bool lcl_IsAllInRange( const ::std::vector< ScRangeList >& rRangesVector, const ScRange& rClipRange ) { // check if every range of rRangesVector is completely in rClipRange for( const ScRangeList& rRanges : rRangesVector ) { for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ ) { const ScRange & rRange = rRanges[ i ]; if ( !rClipRange.Contains( rRange ) ) { return false; // at least one range is not valid } } } return true; // everything is fine } static bool lcl_MoveRanges( ::std::vector< ScRangeList >& rRangesVector, const ScRange& rSourceRange, const ScAddress& rDestPos, const ScDocument& rDoc ) { bool bChanged = false; ScRange aErrorRange( ScAddress::UNINITIALIZED ); for( ScRangeList& rRanges : rRangesVector ) { for ( size_t i = 0, nCount = rRanges.size(); i < nCount; i++ ) { ScRange & rRange = rRanges[ i ]; if ( rSourceRange.Contains( rRange ) ) { SCCOL nDiffX = rDestPos.Col() - rSourceRange.aStart.Col(); SCROW nDiffY = rDestPos.Row() - rSourceRange.aStart.Row(); SCTAB nDiffZ = rDestPos.Tab() - rSourceRange.aStart.Tab(); if (!rRange.Move( nDiffX, nDiffY, nDiffZ, aErrorRange, rDoc )) { assert(!"can't move range"); } bChanged = true; } } } return bChanged; } void ScDrawLayer::CopyFromClip( ScDrawLayer* pClipModel, SCTAB nSourceTab, const tools::Rectangle& rSourceRange, const ScAddress& rDestPos, const tools::Rectangle& rDestRange ) { OSL_ENSURE( pDoc, "ScDrawLayer::CopyFromClip without document" ); if ( !pDoc ) return; if (!pClipModel) return; if (bDrawIsInUndo) //TODO: can this happen? { OSL_FAIL("CopyFromClip, bDrawIsInUndo"); return; } bool bMirrorObj = ( rSourceRange.Left() < 0 && rSourceRange.Right() < 0 && rDestRange.Left() > 0 && rDestRange.Right() > 0 ) || ( rSourceRange.Left() > 0 && rSourceRange.Right() > 0 && rDestRange.Left() < 0 && rDestRange.Right() < 0 ); tools::Rectangle aMirroredSource = rSourceRange; if ( bMirrorObj ) MirrorRectRTL( aMirroredSource ); SCTAB nDestTab = rDestPos.Tab(); SdrPage* pSrcPage = pClipModel->GetPage(static_cast(nSourceTab)); SdrPage* pDestPage = GetPage(static_cast(nDestTab)); OSL_ENSURE( pSrcPage && pDestPage, "draw page missing" ); if ( !pSrcPage || !pDestPage ) return; SdrObjListIter aIter( pSrcPage, SdrIterMode::Flat ); SdrObject* pOldObject = aIter.Next(); ScDocument* pClipDoc = pClipModel->GetDocument(); // a clipboard document and its source share the same document item pool, // so the pointers can be compared to see if this is copy&paste within // the same document bool bSameDoc = pDoc && pClipDoc && pDoc->GetPool() == pClipDoc->GetPool(); bool bDestClip = pDoc && pDoc->IsClipboard(); //#i110034# charts need correct sheet names for xml range conversion during load //so the target sheet name is temporarily renamed (if we have any SdrObjects) OUString aDestTabName; bool bRestoreDestTabName = false; if( pOldObject && !bSameDoc && !bDestClip ) { if( pDoc && pClipDoc ) { OUString aSourceTabName; if( pClipDoc->GetName( nSourceTab, aSourceTabName ) && pDoc->GetName( nDestTab, aDestTabName ) ) { if( aSourceTabName != aDestTabName && pDoc->ValidNewTabName(aSourceTabName) ) { bRestoreDestTabName = pDoc->RenameTab( nDestTab, aSourceTabName ); } } } } // first mirror, then move Size aMove( rDestRange.Left() - aMirroredSource.Left(), rDestRange.Top() - aMirroredSource.Top() ); tools::Long nDestWidth = rDestRange.GetWidth(); tools::Long nDestHeight = rDestRange.GetHeight(); tools::Long nSourceWidth = rSourceRange.GetWidth(); tools::Long nSourceHeight = rSourceRange.GetHeight(); tools::Long nWidthDiff = nDestWidth - nSourceWidth; tools::Long nHeightDiff = nDestHeight - nSourceHeight; Fraction aHorFract(1,1); Fraction aVerFract(1,1); bool bResize = false; // sizes can differ by 1 from twips->1/100mm conversion for equal cell sizes, // don't resize to empty size when pasting into hidden columns or rows if ( std::abs(nWidthDiff) > 1 && nDestWidth > 1 && nSourceWidth > 1 ) { aHorFract = Fraction( nDestWidth, nSourceWidth ); bResize = true; } if ( std::abs(nHeightDiff) > 1 && nDestHeight > 1 && nSourceHeight > 1 ) { aVerFract = Fraction( nDestHeight, nSourceHeight ); bResize = true; } Point aRefPos = rDestRange.TopLeft(); // for resizing (after moving) while (pOldObject) { tools::Rectangle aObjRect = pOldObject->GetCurrentBoundRect(); // do not copy internal objects (detective) and note captions SCTAB nClipTab = bRestoreDestTabName ? nDestTab : nSourceTab; ScRange aClipRange = lcl_getClipRangeFromClipDoc(pClipDoc, nClipTab); bool bObjectInArea = rSourceRange.Contains(aObjRect); const ScDrawObjData* pObjData = ScDrawLayer::GetObjData(pOldObject); if (pObjData) // Consider images anchored to the copied cell bObjectInArea = bObjectInArea || aClipRange.Contains(pObjData->maStart); if (bObjectInArea && (pOldObject->GetLayer() != SC_LAYER_INTERN) && !IsNoteCaption(pOldObject)) { // Clone to target SdrModel SdrObject* pNewObject(pOldObject->CloneSdrObject(*this)); if ( bMirrorObj ) MirrorRTL( pNewObject ); // first mirror, then move pNewObject->NbcMove( aMove ); if ( bResize ) pNewObject->NbcResize( aRefPos, aHorFract, aVerFract ); pDestPage->InsertObject( pNewObject ); if (bRecording) AddCalcUndo( std::make_unique( *pNewObject ) ); //#i110034# handle chart data references (after InsertObject) if ( pNewObject->GetObjIdentifier() == SdrObjKind::OLE2 ) { uno::Reference< embed::XEmbeddedObject > xIPObj = static_cast(pNewObject)->GetObjRef(); uno::Reference< embed::XClassifiedObject > xClassified = xIPObj; SvGlobalName aObjectClassName; if ( xClassified.is() ) { try { aObjectClassName = SvGlobalName( xClassified->getClassID() ); } catch( uno::Exception& ) { // TODO: handle error? } } if ( xIPObj.is() && SotExchange::IsChart( aObjectClassName ) ) { uno::Reference< chart2::XChartDocument > xNewChart( ScChartHelper::GetChartFromSdrObject( pNewObject ) ); if( xNewChart.is() && !xNewChart->hasInternalDataProvider() ) { OUString aChartName = static_cast(pNewObject)->GetPersistName(); ::std::vector< ScRangeList > aRangesVector; pDoc->GetChartRanges( aChartName, aRangesVector, *pDoc ); if( !aRangesVector.empty() ) { bool bInSourceRange = false; if ( pClipDoc ) { bInSourceRange = lcl_IsAllInRange( aRangesVector, aClipRange ); } // always lose references when pasting into a clipboard document (transpose) if ( ( bInSourceRange || bSameDoc ) && !bDestClip ) { if ( bInSourceRange ) { if ( rDestPos != aClipRange.aStart ) { // update the data ranges to the new (copied) position if ( lcl_MoveRanges( aRangesVector, aClipRange, rDestPos, *pDoc ) ) pDoc->SetChartRanges( aChartName, aRangesVector ); } } else { // leave the ranges unchanged } } else { // pasting into a new document without the complete source data // -> break connection to source data and switch to own data uno::Reference< chart::XChartDocument > xOldChartDoc( ScChartHelper::GetChartFromSdrObject( pOldObject ), uno::UNO_QUERY ); uno::Reference< chart::XChartDocument > xNewChartDoc( xNewChart, uno::UNO_QUERY ); if( xOldChartDoc.is() && xNewChartDoc.is() ) xNewChartDoc->attachData( xOldChartDoc->getData() ); // (see ScDocument::UpdateChartListenerCollection, PastingDrawFromOtherDoc) } } } } } } pOldObject = aIter.Next(); } if( bRestoreDestTabName ) pDoc->RenameTab( nDestTab, aDestTabName ); } void ScDrawLayer::MirrorRTL( SdrObject* pObj ) { OSL_ENSURE( pDoc, "ScDrawLayer::MirrorRTL - missing document" ); if( !pDoc ) return; SdrObjKind nIdent = pObj->GetObjIdentifier(); // don't mirror OLE or graphics, otherwise ask the object // if it can be mirrored bool bCanMirror = ( nIdent != SdrObjKind::Graphic && nIdent != SdrObjKind::OLE2 ); if (bCanMirror) { SdrObjTransformInfoRec aInfo; pObj->TakeObjInfo( aInfo ); bCanMirror = aInfo.bMirror90Allowed; } if (bCanMirror) { ScDrawObjData* pData = GetObjData(pObj); if (pData) // cell anchored { // Remember values from positive side. const tools::Rectangle aOldSnapRect = pObj->GetSnapRect(); const tools::Rectangle aOldLogicRect = pObj->GetLogicRect(); // Generate noRotate anchor if missing. ScDrawObjData* pNoRotatedAnchor = GetNonRotatedObjData(pObj); if (!pNoRotatedAnchor) { ScDrawObjData aNoRotateAnchor; const tools::Rectangle aLogicRect(pObj->GetLogicRect()); GetCellAnchorFromPosition(aLogicRect, aNoRotateAnchor, *pDoc, pData->maStart.Tab()); aNoRotateAnchor.mbResizeWithCell = pData->mbResizeWithCell; SetNonRotatedAnchor(*pObj, aNoRotateAnchor); pNoRotatedAnchor = GetNonRotatedObjData(pObj); assert(pNoRotatedAnchor); } // Mirror object at vertical axis Point aRef1( 0, 0 ); Point aRef2( 0, 1 ); if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); pObj->Mirror( aRef1, aRef2 ); // Adapt offsets in pNoRotatedAnchor so, that object will be moved to current position in // save and reload. const tools::Long nInverseShift = aOldSnapRect.Left() + aOldSnapRect.Right(); const Point aLogicLT = pObj->GetLogicRect().TopLeft(); const Point aMirroredLogicLT = aLogicLT + Point(nInverseShift, 0); const Point aOffsetDiff = aMirroredLogicLT - aOldLogicRect.TopLeft(); // new Offsets pNoRotatedAnchor->maStartOffset += aOffsetDiff; pNoRotatedAnchor->maEndOffset += aOffsetDiff; } else // page anchored { Point aRef1( 0, 0 ); Point aRef2( 0, 1 ); if (bRecording) AddCalcUndo( std::make_unique( *pObj ) ); pObj->Mirror( aRef1, aRef2 ); } } else { // Move instead of mirroring: // New start position is negative of old end position // -> move by sum of start and end position tools::Rectangle aObjRect = pObj->GetSnapRect(); Size aMoveSize( -(aObjRect.Left() + aObjRect.Right()), 0 ); if (bRecording) AddCalcUndo( std::make_unique( *pObj, aMoveSize ) ); pObj->Move( aMoveSize ); } // for cell anchored objects adapt rectangles in anchors ScDrawObjData* pData = GetObjData(pObj); if (pData) { pData->setShapeRect(GetDocument(), pObj->GetSnapRect(), pObj->IsVisible()); ScDrawObjData* pNoRotatedAnchor = GetNonRotatedObjData(pObj, true /*bCreate*/); pNoRotatedAnchor->setShapeRect(GetDocument(), pObj->GetLogicRect(), pObj->IsVisible()); } } void ScDrawLayer::MoveRTL(SdrObject* pObj) { tools::Rectangle aObjRect = pObj->GetSnapRect(); Size aMoveSize( -(aObjRect.Left() + aObjRect.Right()), 0 ); if (bRecording) AddCalcUndo( std::make_unique( *pObj, aMoveSize ) ); pObj->Move( aMoveSize ); // for cell anchored objects adapt rectangles in anchors ScDrawObjData* pData = GetObjData(pObj); if (pData) { pData->setShapeRect(GetDocument(), pObj->GetSnapRect(), pObj->IsVisible()); ScDrawObjData* pNoRotatedAnchor = GetNonRotatedObjData(pObj, true /*bCreate*/); pNoRotatedAnchor->setShapeRect(GetDocument(), pObj->GetLogicRect(), pObj->IsVisible()); } } void ScDrawLayer::MirrorRectRTL( tools::Rectangle& rRect ) { // mirror and swap left/right tools::Long nTemp = rRect.Left(); rRect.SetLeft( -rRect.Right() ); rRect.SetRight( -nTemp ); } tools::Rectangle ScDrawLayer::GetCellRect( const ScDocument& rDoc, const ScAddress& rPos, bool bMergedCell ) { tools::Rectangle aCellRect; OSL_ENSURE( rDoc.ValidColRowTab( rPos.Col(), rPos.Row(), rPos.Tab() ), "ScDrawLayer::GetCellRect - invalid cell address" ); if( rDoc.ValidColRowTab( rPos.Col(), rPos.Row(), rPos.Tab() ) ) { // find top left position of passed cell address Point aTopLeft; for( SCCOL nCol = 0; nCol < rPos.Col(); ++nCol ) aTopLeft.AdjustX(rDoc.GetColWidth( nCol, rPos.Tab() ) ); if( rPos.Row() > 0 ) aTopLeft.AdjustY(rDoc.GetRowHeight( 0, rPos.Row() - 1, rPos.Tab() ) ); // find bottom-right position of passed cell address ScAddress aEndPos = rPos; if( bMergedCell ) { const ScMergeAttr* pMerge = rDoc.GetAttr( rPos, ATTR_MERGE ); if( pMerge->GetColMerge() > 1 ) aEndPos.IncCol( pMerge->GetColMerge() - 1 ); if( pMerge->GetRowMerge() > 1 ) aEndPos.IncRow( pMerge->GetRowMerge() - 1 ); } Point aBotRight = aTopLeft; for( SCCOL nCol = rPos.Col(); nCol <= aEndPos.Col(); ++nCol ) aBotRight.AdjustX(rDoc.GetColWidth( nCol, rPos.Tab() ) ); aBotRight.AdjustY(rDoc.GetRowHeight( rPos.Row(), aEndPos.Row(), rPos.Tab() ) ); // twips -> 1/100 mm aTopLeft = o3tl::convert(aTopLeft, o3tl::Length::twip, o3tl::Length::mm100); aBotRight = o3tl::convert(aBotRight, o3tl::Length::twip, o3tl::Length::mm100); aCellRect = tools::Rectangle( aTopLeft, aBotRight ); if( rDoc.IsNegativePage( rPos.Tab() ) ) MirrorRectRTL( aCellRect ); } return aCellRect; } OUString ScDrawLayer::GetVisibleName( const SdrObject* pObj ) { OUString aName = pObj->GetName(); if ( pObj->GetObjIdentifier() == SdrObjKind::OLE2 ) { // For OLE, the user defined name (GetName) is used // if it's not empty (accepting possibly duplicate names), // otherwise the persist name is used so every object appears // in the Navigator at all. if ( aName.isEmpty() ) aName = static_cast(pObj)->GetPersistName(); } return aName; } static bool IsNamedObject( const SdrObject* pObj, std::u16string_view rName ) { // sal_True if rName is the object's Name or PersistName // (used to find a named object) return ( pObj->GetName() == rName || ( pObj->GetObjIdentifier() == SdrObjKind::OLE2 && static_cast(pObj)->GetPersistName() == rName ) ); } SdrObject* ScDrawLayer::GetNamedObject( std::u16string_view rName, SdrObjKind nId, SCTAB& rFoundTab ) const { sal_uInt16 nTabCount = GetPageCount(); for (sal_uInt16 nTab=0; nTabGetObjIdentifier() == nId ) if ( IsNamedObject( pObject, rName ) ) { rFoundTab = static_cast(nTab); return pObject; } pObject = aIter.Next(); } } } return nullptr; } OUString ScDrawLayer::GetNewGraphicName( tools::Long* pnCounter ) const { OUString aBase = ScResId(STR_GRAPHICNAME) + " "; bool bThere = true; OUString aGraphicName; SCTAB nDummy; tools::Long nId = pnCounter ? *pnCounter : 0; while (bThere) { ++nId; aGraphicName = aBase + OUString::number( nId ); bThere = ( GetNamedObject( aGraphicName, SdrObjKind::NONE, nDummy ) != nullptr ); } if ( pnCounter ) *pnCounter = nId; return aGraphicName; } void ScDrawLayer::EnsureGraphicNames() { // make sure all graphic objects have names (after Excel import etc.) sal_uInt16 nTabCount = GetPageCount(); for (sal_uInt16 nTab=0; nTabGetObjIdentifier() == SdrObjKind::Graphic && pObject->GetName().isEmpty()) pObject->SetName( GetNewGraphicName( &nCounter ) ); pObject = aIter.Next(); } } } } namespace { SdrObjUserData* GetFirstUserDataOfType(const SdrObject *pObj, sal_uInt16 nId) { sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0; for( sal_uInt16 i = 0; i < nCount; i++ ) { SdrObjUserData* pData = pObj->GetUserData( i ); if( pData && pData->GetInventor() == SdrInventor::ScOrSwDraw && pData->GetId() == nId ) return pData; } return nullptr; } void DeleteFirstUserDataOfType(SdrObject *pObj, sal_uInt16 nId) { sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0; for( sal_uInt16 i = nCount; i > 0; i-- ) { SdrObjUserData* pData = pObj->GetUserData( i-1 ); if( pData && pData->GetInventor() == SdrInventor::ScOrSwDraw && pData->GetId() == nId ) pObj->DeleteUserData(i-1); } } } void ScDrawLayer::SetNonRotatedAnchor(SdrObject& rObj, const ScDrawObjData& rAnchor) { ScDrawObjData* pAnchor = GetNonRotatedObjData( &rObj, true ); pAnchor->maStart = rAnchor.maStart; pAnchor->maEnd = rAnchor.maEnd; pAnchor->maStartOffset = rAnchor.maStartOffset; pAnchor->maEndOffset = rAnchor.maEndOffset; pAnchor->mbResizeWithCell = rAnchor.mbResizeWithCell; } void ScDrawLayer::SetCellAnchored( SdrObject &rObj, const ScDrawObjData &rAnchor ) { ScDrawObjData* pAnchor = GetObjData( &rObj, true ); pAnchor->maStart = rAnchor.maStart; pAnchor->maEnd = rAnchor.maEnd; pAnchor->maStartOffset = rAnchor.maStartOffset; pAnchor->maEndOffset = rAnchor.maEndOffset; pAnchor->mbResizeWithCell = rAnchor.mbResizeWithCell; } void ScDrawLayer::SetCellAnchoredFromPosition( SdrObject &rObj, const ScDocument &rDoc, SCTAB nTab, bool bResizeWithCell ) { if (!rObj.IsVisible()) return; ScDrawObjData aAnchor; // set anchor in terms of the visual ( SnapRect ) // object ( e.g. for when object is rotated ) const tools::Rectangle aObjRect(rObj.GetSnapRect()); GetCellAnchorFromPosition( aObjRect, aAnchor, rDoc, nTab); aAnchor.mbResizeWithCell = bResizeWithCell; SetCellAnchored( rObj, aAnchor ); // absolutely necessary to set flag, ScDrawLayer::RecalcPos expects it. if ( ScDrawObjData* pAnchor = GetObjData( &rObj ) ) { pAnchor->setShapeRect(&rDoc, rObj.GetSnapRect()); } // - keep also an anchor in terms of the Logic ( untransformed ) object // because that's what we stored ( and still do ) to xml // Vertical flipped custom shapes need special treatment, see comment in // lcl_SetLogicRectFromAnchor tools::Rectangle aObjRect2; if (lcl_NeedsMirrorYCorrection(&rObj)) { const tools::Rectangle aRect(rObj.GetSnapRect()); const Point aLeft(aRect.Left(), (aRect.Top() + aRect.Bottom()) >> 1); const Point aRight(aLeft.X() + 1000, aLeft.Y()); rObj.NbcMirror(aLeft, aRight); aObjRect2 = rObj.GetLogicRect(); rObj.NbcMirror(aLeft, aRight); } else if (rObj.GetObjIdentifier() == SdrObjKind::Measure) { // tdf#137576. A SdrMeasureObj might have a wrong logic rect here. TakeUnrotatedSnapRect // calculates the current unrotated snap rectangle, sets logic rectangle and returns it. static_cast(rObj).TakeUnrotatedSnapRect(aObjRect2); } else aObjRect2 = rObj.GetLogicRect(); // Values in XML are so as if it is a LTR sheet. The object is shifted to negative page on loading // so that the snap rectangle appears mirrored. For transformed objects the shifted logic rectangle // is not the mirrored LTR rectangle. We calculate the mirrored LTR rectangle here. if (rDoc.IsNegativePage(nTab)) { const tools::Rectangle aSnapRect(rObj.GetSnapRect()); aObjRect2.Move(Size(-aSnapRect.Left() - aSnapRect.Right(), 0)); MirrorRectRTL(aObjRect2); } ScDrawObjData aNoRotatedAnchor; GetCellAnchorFromPosition( aObjRect2, aNoRotatedAnchor, rDoc, nTab); aNoRotatedAnchor.mbResizeWithCell = bResizeWithCell; SetNonRotatedAnchor( rObj, aNoRotatedAnchor); // And update maShapeRect. It is used in adjustAnchoredPosition() in ScDrawView::Notify(). if (ScDrawObjData* pAnchor = GetNonRotatedObjData(&rObj)) { pAnchor->setShapeRect(&rDoc, rObj.GetLogicRect()); } } void ScDrawLayer::GetCellAnchorFromPosition( const tools::Rectangle &rObjRect, ScDrawObjData &rAnchor, const ScDocument &rDoc, SCTAB nTab, bool bHiddenAsZero) { ScRange aRange = rDoc.GetRange( nTab, rObjRect, bHiddenAsZero ); tools::Rectangle aCellRect; rAnchor.maStart = aRange.aStart; aCellRect = rDoc.GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab(), bHiddenAsZero ); rAnchor.maStartOffset.setY( rObjRect.Top()-aCellRect.Top() ); if (!rDoc.IsNegativePage(nTab)) rAnchor.maStartOffset.setX( rObjRect.Left()-aCellRect.Left() ); else rAnchor.maStartOffset.setX( aCellRect.Right()-rObjRect.Right() ); rAnchor.maEnd = aRange.aEnd; aCellRect = rDoc.GetMMRect( aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab(), bHiddenAsZero ); if (!rObjRect.IsEmpty()) rAnchor.maEndOffset.setY( rObjRect.Bottom()-aCellRect.Top() ); if (!rDoc.IsNegativePage(nTab)) { if (!rObjRect.IsEmpty()) rAnchor.maEndOffset.setX( rObjRect.Right()-aCellRect.Left() ); } else rAnchor.maEndOffset.setX( aCellRect.Right()-rObjRect.Left() ); } void ScDrawLayer::UpdateCellAnchorFromPositionEnd( const SdrObject &rObj, ScDrawObjData &rAnchor, const ScDocument &rDoc, SCTAB nTab, bool bUseLogicRect ) { tools::Rectangle aObjRect(bUseLogicRect ? rObj.GetLogicRect() : rObj.GetSnapRect()); ScRange aRange = rDoc.GetRange( nTab, aObjRect ); ScDrawObjData* pAnchor = &rAnchor; pAnchor->maEnd = aRange.aEnd; tools::Rectangle aCellRect = rDoc.GetMMRect( aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab() ); pAnchor->maEndOffset.setY( aObjRect.Bottom()-aCellRect.Top() ); if (!rDoc.IsNegativePage(nTab)) pAnchor->maEndOffset.setX( aObjRect.Right()-aCellRect.Left() ); else pAnchor->maEndOffset.setX( aCellRect.Right()-aObjRect.Left() ); } bool ScDrawLayer::IsCellAnchored( const SdrObject& rObj ) { // Cell anchored object always has a user data, to store the anchor cell // info. If it doesn't then it's page-anchored. return GetFirstUserDataOfType(&rObj, SC_UD_OBJDATA) != nullptr; } bool ScDrawLayer::IsResizeWithCell( const SdrObject& rObj ) { // Cell anchored object always has a user data, to store the anchor cell // info. If it doesn't then it's page-anchored. ScDrawObjData* pDrawObjData = GetObjData(const_cast(&rObj)); if (!pDrawObjData) return false; return pDrawObjData->mbResizeWithCell; } void ScDrawLayer::SetPageAnchored( SdrObject &rObj ) { DeleteFirstUserDataOfType(&rObj, SC_UD_OBJDATA); DeleteFirstUserDataOfType(&rObj, SC_UD_OBJDATA); } ScAnchorType ScDrawLayer::GetAnchorType( const SdrObject &rObj ) { //If this object has a cell anchor associated with it //then it's cell-anchored, otherwise it's page-anchored const ScDrawObjData* pObjData = ScDrawLayer::GetObjData(const_cast(&rObj)); // When there is no cell anchor, it is page anchored. if (!pObjData) return SCA_PAGE; // It's cell-anchored, check if the object resizes with the cell if (pObjData->mbResizeWithCell) return SCA_CELL_RESIZE; return SCA_CELL; } std::vector ScDrawLayer::GetObjectsAnchoredToRows(SCTAB nTab, SCROW nStartRow, SCROW nEndRow) { SdrPage* pPage = GetPage(static_cast(nTab)); if (!pPage || pPage->GetObjCount() < 1) return std::vector(); std::vector aObjects; SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); ScRange aRange( 0, nStartRow, nTab, pDoc->MaxCol(), nEndRow, nTab); while (pObject) { ScDrawObjData* pObjData = GetObjData(pObject); if (pObjData && aRange.Contains(pObjData->maStart)) aObjects.push_back(pObject); pObject = aIter.Next(); } return aObjects; } std::map> ScDrawLayer::GetObjectsAnchoredToRange(SCTAB nTab, SCCOL nCol, SCROW nStartRow, SCROW nEndRow) { SdrPage* pPage = GetPage(static_cast(nTab)); if (!pPage || pPage->GetObjCount() < 1) return std::map>(); std::map> aRowObjects; SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); ScRange aRange( nCol, nStartRow, nTab, nCol, nEndRow, nTab); while (pObject) { if (!dynamic_cast(pObject)) // Caption objects are handled differently { ScDrawObjData* pObjData = GetObjData(pObject); if (pObjData && aRange.Contains(pObjData->maStart)) aRowObjects[pObjData->maStart.Row()].push_back(pObject); } pObject = aIter.Next(); } return aRowObjects; } bool ScDrawLayer::HasObjectsAnchoredInRange(const ScRange& rRange) { // This only works for one table at a time assert(rRange.aStart.Tab() == rRange.aEnd.Tab()); SdrPage* pPage = GetPage(static_cast(rRange.aStart.Tab())); if (!pPage || pPage->GetObjCount() < 1) return false; SdrObjListIter aIter( pPage, SdrIterMode::Flat ); SdrObject* pObject = aIter.Next(); while (pObject) { if (!dynamic_cast(pObject)) // Caption objects are handled differently { ScDrawObjData* pObjData = GetObjData(pObject); if (pObjData && rRange.Contains(pObjData->maStart)) // Object is in given range return true; } pObject = aIter.Next(); } return false; } std::vector ScDrawLayer::GetObjectsAnchoredToCols(SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol) { SdrPage* pPage = GetPage(static_cast(nTab)); if (!pPage || pPage->GetObjCount() < 1) return std::vector(); std::vector aObjects; SdrObjListIter aIter(pPage, SdrIterMode::Flat); SdrObject* pObject = aIter.Next(); ScRange aRange(nStartCol, 0, nTab, nEndCol, pDoc->MaxRow(), nTab); while (pObject) { ScDrawObjData* pObjData = GetObjData(pObject); if (pObjData && aRange.Contains(pObjData->maStart)) aObjects.push_back(pObject); pObject = aIter.Next(); } return aObjects; } void ScDrawLayer::MoveObject(SdrObject* pObject, const ScAddress& rNewPosition) { // Get anchor data ScDrawObjData* pObjData = GetObjData(pObject, false); if (!pObjData) return; const ScAddress aOldStart = pObjData->maStart; const ScAddress aOldEnd = pObjData->maEnd; // Set start address pObjData->maStart = rNewPosition; // Set end address const SCCOL nObjectColSpan = aOldEnd.Col() - aOldStart.Col(); const SCROW nObjectRowSpan = aOldEnd.Row() - aOldStart.Row(); ScAddress aNewEnd = rNewPosition; aNewEnd.IncRow(nObjectRowSpan); aNewEnd.IncCol(nObjectColSpan); pObjData->maEnd = aNewEnd; // Update draw object according to new anchor RecalcPos(pObject, *pObjData, false, false); } ScDrawObjData* ScDrawLayer::GetNonRotatedObjData( SdrObject* pObj, bool bCreate ) { sal_uInt16 nCount = pObj ? pObj->GetUserDataCount() : 0; sal_uInt16 nFound = 0; for( sal_uInt16 i = 0; i < nCount; i++ ) { SdrObjUserData* pData = pObj->GetUserData( i ); if( pData && pData->GetInventor() == SdrInventor::ScOrSwDraw && pData->GetId() == SC_UD_OBJDATA && ++nFound == 2 ) return static_cast(pData); } if( pObj && bCreate ) { ScDrawObjData* pData = new ScDrawObjData; pObj->AppendUserData(std::unique_ptr(pData)); return pData; } return nullptr; } ScDrawObjData* ScDrawLayer::GetObjData( SdrObject* pObj, bool bCreate ) { if (SdrObjUserData *pData = GetFirstUserDataOfType(pObj, SC_UD_OBJDATA)) return static_cast(pData); if( pObj && bCreate ) { ScDrawObjData* pData = new ScDrawObjData; pObj->AppendUserData(std::unique_ptr(pData)); return pData; } return nullptr; } ScDrawObjData* ScDrawLayer::GetObjDataTab( SdrObject* pObj, SCTAB nTab ) { ScDrawObjData* pData = GetObjData( pObj ); if ( pData ) { if ( pData->maStart.IsValid() ) pData->maStart.SetTab( nTab ); if ( pData->maEnd.IsValid() ) pData->maEnd.SetTab( nTab ); } return pData; } bool ScDrawLayer::IsNoteCaption( SdrObject* pObj ) { ScDrawObjData* pData = pObj ? GetObjData( pObj ) : nullptr; return pData && pData->meType == ScDrawObjData::CellNote; } ScDrawObjData* ScDrawLayer::GetNoteCaptionData( SdrObject* pObj, SCTAB nTab ) { ScDrawObjData* pData = pObj ? GetObjDataTab( pObj, nTab ) : nullptr; return (pData && pData->meType == ScDrawObjData::CellNote) ? pData : nullptr; } ScMacroInfo* ScDrawLayer::GetMacroInfo( SdrObject* pObj, bool bCreate ) { if (SdrObjUserData *pData = GetFirstUserDataOfType(pObj, SC_UD_MACRODATA)) return static_cast(pData); if ( bCreate ) { ScMacroInfo* pData = new ScMacroInfo; pObj->AppendUserData(std::unique_ptr(pData)); return pData; } return nullptr; } void ScDrawLayer::SetGlobalDrawPersist(SfxObjectShell* pPersist) { OSL_ENSURE(!pGlobalDrawPersist,"Multiple SetGlobalDrawPersist"); pGlobalDrawPersist = pPersist; } void ScDrawLayer::SetChanged( bool bFlg /* = true */ ) { if ( bFlg && pDoc ) pDoc->SetChartListenerCollectionNeedsUpdate( true ); FmFormModel::SetChanged( bFlg ); } css::uno::Reference< css::uno::XInterface > ScDrawLayer::createUnoModel() { css::uno::Reference< css::uno::XInterface > xRet; if( pDoc && pDoc->GetDocumentShell() ) xRet = pDoc->GetDocumentShell()->GetModel(); return xRet; } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */