diff options
Diffstat (limited to 'sc/source/core/data/postit.cxx')
| -rw-r--r-- | sc/source/core/data/postit.cxx | 1306 |
1 files changed, 1306 insertions, 0 deletions
diff --git a/sc/source/core/data/postit.cxx b/sc/source/core/data/postit.cxx new file mode 100644 index 000000000..cd8acfdce --- /dev/null +++ b/sc/source/core/data/postit.cxx @@ -0,0 +1,1306 @@ +/* -*- 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 <memory> +#include <postit.hxx> + +#include <rtl/ustrbuf.hxx> +#include <sal/log.hxx> +#include <unotools/useroptions.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdocapt.hxx> +#include <editeng/outlobj.hxx> +#include <editeng/editobj.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <osl/diagnose.h> +#include <comphelper/lok.hxx> + +#include <scitems.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/xlnstcit.hxx> +#include <svx/sxcecitm.hxx> +#include <svx/xflclit.hxx> +#include <svx/sdshitm.hxx> +#include <svx/sdsxyitm.hxx> +#include <svx/sdtditm.hxx> +#include <svx/sdtagitm.hxx> +#include <svx/sdtmfitm.hxx> +#include <tools/gen.hxx> + +#include <document.hxx> +#include <docpool.hxx> +#include <patattr.hxx> +#include <drwlayer.hxx> +#include <userdat.hxx> +#include <detfunc.hxx> +#include <editutil.hxx> + +using namespace com::sun::star; + +namespace { + +const tools::Long SC_NOTECAPTION_WIDTH = 2900; /// Default width of note caption textbox. +const tools::Long SC_NOTECAPTION_MAXWIDTH_TEMP = 12000; /// Maximum width of temporary note caption textbox. +const tools::Long SC_NOTECAPTION_HEIGHT = 1800; /// Default height of note caption textbox. +const tools::Long SC_NOTECAPTION_CELLDIST = 600; /// Default distance of note captions to border of anchor cell. +const tools::Long SC_NOTECAPTION_OFFSET_Y = -1500; /// Default Y offset of note captions to top border of anchor cell. +const tools::Long SC_NOTECAPTION_OFFSET_X = 1500; /// Default X offset of note captions to left border of anchor cell. +const tools::Long SC_NOTECAPTION_BORDERDIST_TEMP = 100; /// Distance of temporary note captions to visible sheet area. + +/** Static helper functions for caption objects. */ +class ScCaptionUtil +{ +public: + /** Moves the caption object to the correct layer according to passed visibility. */ + static void SetCaptionLayer( SdrCaptionObj& rCaption, bool bShown ); + /** Sets basic caption settings required for note caption objects. */ + static void SetBasicCaptionSettings( SdrCaptionObj& rCaption, bool bShown ); + /** Stores the cell position of the note in the user data area of the caption. */ + static void SetCaptionUserData( SdrCaptionObj& rCaption, const ScAddress& rPos ); + /** Sets all default formatting attributes to the caption object. */ + static void SetDefaultItems( SdrCaptionObj& rCaption, ScDocument& rDoc, const SfxItemSet* pExtraItemSet ); +}; + +void ScCaptionUtil::SetCaptionLayer( SdrCaptionObj& rCaption, bool bShown ) +{ + SdrLayerID nLayer = bShown ? SC_LAYER_INTERN : SC_LAYER_HIDDEN; + if( nLayer != rCaption.GetLayer() ) + rCaption.SetLayer( nLayer ); +} + +void ScCaptionUtil::SetBasicCaptionSettings( SdrCaptionObj& rCaption, bool bShown ) +{ + SetCaptionLayer( rCaption, bShown ); + rCaption.SetFixedTail(); + rCaption.SetSpecialTextBoxShadow(); +} + +void ScCaptionUtil::SetCaptionUserData( SdrCaptionObj& rCaption, const ScAddress& rPos ) +{ + // pass true to ScDrawLayer::GetObjData() to create the object data entry + ScDrawObjData* pObjData = ScDrawLayer::GetObjData( &rCaption, true ); + OSL_ENSURE( pObjData, "ScCaptionUtil::SetCaptionUserData - missing drawing object user data" ); + pObjData->maStart = rPos; + pObjData->meType = ScDrawObjData::CellNote; +} + +void ScCaptionUtil::SetDefaultItems( SdrCaptionObj& rCaption, ScDocument& rDoc, const SfxItemSet* pExtraItemSet ) +{ + SfxItemSet aItemSet = rCaption.GetMergedItemSet(); + + // caption tail arrow + ::basegfx::B2DPolygon aTriangle; + aTriangle.append( ::basegfx::B2DPoint( 10.0, 0.0 ) ); + aTriangle.append( ::basegfx::B2DPoint( 0.0, 30.0 ) ); + aTriangle.append( ::basegfx::B2DPoint( 20.0, 30.0 ) ); + aTriangle.setClosed( true ); + /* Line ends are now created with an empty name. The + checkForUniqueItem() method then finds a unique name for the item's + value. */ + aItemSet.Put( XLineStartItem( OUString(), ::basegfx::B2DPolyPolygon( aTriangle ) ) ); + aItemSet.Put( XLineStartWidthItem( 200 ) ); + aItemSet.Put( XLineStartCenterItem( false ) ); + aItemSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + aItemSet.Put( XFillColorItem( OUString(), ScDetectiveFunc::GetCommentColor() ) ); + aItemSet.Put( SdrCaptionEscDirItem( SdrCaptionEscDir::BestFit ) ); + + // shadow + /* SdrShadowItem has sal_False, instead the shadow is set for the + rectangle only with SetSpecialTextBoxShadow() when the object is + created (item must be set to adjust objects from older files). */ + aItemSet.Put( makeSdrShadowItem( false ) ); + aItemSet.Put( makeSdrShadowXDistItem( 100 ) ); + aItemSet.Put( makeSdrShadowYDistItem( 100 ) ); + + // text attributes + aItemSet.Put( makeSdrTextLeftDistItem( 100 ) ); + aItemSet.Put( makeSdrTextRightDistItem( 100 ) ); + aItemSet.Put( makeSdrTextUpperDistItem( 100 ) ); + aItemSet.Put( makeSdrTextLowerDistItem( 100 ) ); + aItemSet.Put( makeSdrTextAutoGrowWidthItem( false ) ); + aItemSet.Put( makeSdrTextAutoGrowHeightItem( true ) ); + // use the default cell style to be able to modify the caption font + const ScPatternAttr& rDefPattern = rDoc.GetPool()->GetDefaultItem( ATTR_PATTERN ); + rDefPattern.FillEditItemSet( &aItemSet ); + + if (pExtraItemSet) + { + /* Updates caption item set according to the passed item set while removing shadow items. */ + + aItemSet.Put(*pExtraItemSet); + // reset shadow items + aItemSet.Put( makeSdrShadowItem( false ) ); + aItemSet.Put( makeSdrShadowXDistItem( 100 ) ); + aItemSet.Put( makeSdrShadowYDistItem( 100 ) ); + } + + rCaption.SetMergedItemSet( aItemSet ); + + if (pExtraItemSet) + rCaption.SetSpecialTextBoxShadow(); +} + +/** Helper for creation and manipulation of caption drawing objects independent + from cell annotations. */ +class ScCaptionCreator +{ +public: + /** Create a new caption. The caption will not be inserted into the document. */ + explicit ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, bool bTailFront ); + /** Manipulate an existing caption. */ + explicit ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, const ScCaptionPtr& xCaption ); + + /** Returns the drawing layer page of the sheet contained in maPos. */ + SdrPage* GetDrawPage(); + /** Returns the caption drawing object. */ + ScCaptionPtr & GetCaption() { return mxCaption; } + + /** Moves the caption inside the passed rectangle. Uses page area if 0 is passed. */ + void FitCaptionToRect( const tools::Rectangle* pVisRect = nullptr ); + /** Places the caption inside the passed rectangle, tries to keep the cell rectangle uncovered. Uses page area if 0 is passed. */ + void AutoPlaceCaption( const tools::Rectangle* pVisRect = nullptr ); + /** Updates caption tail and textbox according to current cell position. Uses page area if 0 is passed. */ + void UpdateCaptionPos(); + +protected: + /** Helper constructor for derived classes. */ + explicit ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos ); + + /** Calculates the caption tail position according to current cell position. */ + Point CalcTailPos( bool bTailFront ); + /** Implements creation of the caption object. The caption will not be inserted into the document. */ + void CreateCaption( bool bShown, bool bTailFront ); + +private: + /** Initializes all members. */ + void Initialize(); + /** Returns the passed rectangle if existing, page rectangle otherwise. */ + const tools::Rectangle& GetVisRect( const tools::Rectangle* pVisRect ) const { return pVisRect ? *pVisRect : maPageRect; } + +private: + ScDocument& mrDoc; + ScAddress maPos; + ScCaptionPtr mxCaption; + tools::Rectangle maPageRect; + tools::Rectangle maCellRect; + bool mbNegPage; +}; + +ScCaptionCreator::ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, bool bTailFront ) : + mrDoc( rDoc ), + maPos( rPos ) +{ + Initialize(); + CreateCaption( true/*bShown*/, bTailFront ); +} + +ScCaptionCreator::ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, const ScCaptionPtr& xCaption ) : + mrDoc( rDoc ), + maPos( rPos ), + mxCaption( xCaption ) +{ + Initialize(); +} + +ScCaptionCreator::ScCaptionCreator( ScDocument& rDoc, const ScAddress& rPos ) : + mrDoc( rDoc ), + maPos( rPos ) +{ + Initialize(); +} + +SdrPage* ScCaptionCreator::GetDrawPage() +{ + ScDrawLayer* pDrawLayer = mrDoc.GetDrawLayer(); + return pDrawLayer ? pDrawLayer->GetPage( static_cast< sal_uInt16 >( maPos.Tab() ) ) : nullptr; +} + +void ScCaptionCreator::FitCaptionToRect( const tools::Rectangle* pVisRect ) +{ + const tools::Rectangle& rVisRect = GetVisRect( pVisRect ); + + // tail position + Point aTailPos = mxCaption->GetTailPos(); + aTailPos.setX( ::std::clamp( aTailPos.X(), rVisRect.Left(), rVisRect.Right() ) ); + aTailPos.setY( ::std::clamp( aTailPos.Y(), rVisRect.Top(), rVisRect.Bottom() ) ); + mxCaption->SetTailPos( aTailPos ); + + // caption rectangle + tools::Rectangle aCaptRect = mxCaption->GetLogicRect(); + Point aCaptPos = aCaptRect.TopLeft(); + // move textbox inside right border of visible area + aCaptPos.setX( ::std::min< tools::Long >( aCaptPos.X(), rVisRect.Right() - aCaptRect.GetWidth() ) ); + // move textbox inside left border of visible area (this may move it outside on right side again) + aCaptPos.setX( ::std::max< tools::Long >( aCaptPos.X(), rVisRect.Left() ) ); + // move textbox inside bottom border of visible area + aCaptPos.setY( ::std::min< tools::Long >( aCaptPos.Y(), rVisRect.Bottom() - aCaptRect.GetHeight() ) ); + // move textbox inside top border of visible area (this may move it outside on bottom side again) + aCaptPos.setY( ::std::max< tools::Long >( aCaptPos.Y(), rVisRect.Top() ) ); + // update caption + aCaptRect.SetPos( aCaptPos ); + mxCaption->SetLogicRect( aCaptRect ); +} + +void ScCaptionCreator::AutoPlaceCaption( const tools::Rectangle* pVisRect ) +{ + const tools::Rectangle& rVisRect = GetVisRect( pVisRect ); + + // caption rectangle + tools::Rectangle aCaptRect = mxCaption->GetLogicRect(); + tools::Long nWidth = aCaptRect.GetWidth(); + tools::Long nHeight = aCaptRect.GetHeight(); + + // n***Space contains available space between border of visible area and cell + tools::Long nLeftSpace = maCellRect.Left() - rVisRect.Left() + 1; + tools::Long nRightSpace = rVisRect.Right() - maCellRect.Right() + 1; + tools::Long nTopSpace = maCellRect.Top() - rVisRect.Top() + 1; + tools::Long nBottomSpace = rVisRect.Bottom() - maCellRect.Bottom() + 1; + + // nNeeded*** contains textbox dimensions plus needed distances to cell or border of visible area + tools::Long nNeededSpaceX = nWidth + SC_NOTECAPTION_CELLDIST; + tools::Long nNeededSpaceY = nHeight + SC_NOTECAPTION_CELLDIST; + + // bFitsWidth*** == true means width of textbox fits into horizontal free space of visible area + bool bFitsWidthLeft = nNeededSpaceX <= nLeftSpace; // text box width fits into the width left of cell + bool bFitsWidthRight = nNeededSpaceX <= nRightSpace; // text box width fits into the width right of cell + bool bFitsWidth = nWidth <= rVisRect.GetWidth(); // text box width fits into width of visible area + + // bFitsHeight*** == true means height of textbox fits into vertical free space of visible area + bool bFitsHeightTop = nNeededSpaceY <= nTopSpace; // text box height fits into the height above cell + bool bFitsHeightBottom = nNeededSpaceY <= nBottomSpace; // text box height fits into the height below cell + bool bFitsHeight = nHeight <= rVisRect.GetHeight(); // text box height fits into height of visible area + + // bFits*** == true means the textbox fits completely into free space of visible area + bool bFitsLeft = bFitsWidthLeft && bFitsHeight; + bool bFitsRight = bFitsWidthRight && bFitsHeight; + bool bFitsTop = bFitsWidth && bFitsHeightTop; + bool bFitsBottom = bFitsWidth && bFitsHeightBottom; + + Point aCaptPos; + // use left/right placement if possible, or if top/bottom placement not possible + if( bFitsLeft || bFitsRight || (!bFitsTop && !bFitsBottom) ) + { + // prefer left in RTL sheet and right in LTR sheets + bool bPreferLeft = bFitsLeft && (mbNegPage || !bFitsRight); + bool bPreferRight = bFitsRight && (!mbNegPage || !bFitsLeft); + // move to left, if left is preferred, or if neither left nor right fit and there is more space to the left + if( bPreferLeft || (!bPreferRight && (nLeftSpace > nRightSpace)) ) + aCaptPos.setX( maCellRect.Left() - SC_NOTECAPTION_CELLDIST - nWidth ); + else // to right + aCaptPos.setX( maCellRect.Right() + SC_NOTECAPTION_CELLDIST ); + // Y position according to top cell border + aCaptPos.setY( maCellRect.Top() + SC_NOTECAPTION_OFFSET_Y ); + } + else // top or bottom placement + { + // X position + aCaptPos.setX( maCellRect.Left() + SC_NOTECAPTION_OFFSET_X ); + // top placement, if possible + if( bFitsTop ) + aCaptPos.setY( maCellRect.Top() - SC_NOTECAPTION_CELLDIST - nHeight ); + else // bottom placement + aCaptPos.setY( maCellRect.Bottom() + SC_NOTECAPTION_CELLDIST ); + } + + // update textbox position in note caption object + aCaptRect.SetPos( aCaptPos ); + mxCaption->SetLogicRect( aCaptRect ); + FitCaptionToRect( pVisRect ); +} + +void ScCaptionCreator::UpdateCaptionPos() +{ + ScDrawLayer* pDrawLayer = mrDoc.GetDrawLayer(); + + // update caption position + const Point& rOldTailPos = mxCaption->GetTailPos(); + Point aTailPos = CalcTailPos( false ); + if( rOldTailPos != aTailPos ) + { + // create drawing undo action + if( pDrawLayer && pDrawLayer->IsRecording() ) + pDrawLayer->AddCalcUndo( std::make_unique<SdrUndoGeoObj>( *mxCaption ) ); + // calculate new caption rectangle (#i98141# handle LTR<->RTL switch correctly) + tools::Rectangle aCaptRect = mxCaption->GetLogicRect(); + tools::Long nDiffX = (rOldTailPos.X() >= 0) ? (aCaptRect.Left() - rOldTailPos.X()) : (rOldTailPos.X() - aCaptRect.Right()); + if( mbNegPage ) nDiffX = -nDiffX - aCaptRect.GetWidth(); + tools::Long nDiffY = aCaptRect.Top() - rOldTailPos.Y(); + aCaptRect.SetPos( aTailPos + Point( nDiffX, nDiffY ) ); + // set new tail position and caption rectangle + mxCaption->SetTailPos( aTailPos ); + mxCaption->SetLogicRect( aCaptRect ); + // fit caption into draw page + FitCaptionToRect(); + } + + // update cell position in caption user data + ScDrawObjData* pCaptData = ScDrawLayer::GetNoteCaptionData( mxCaption.get(), maPos.Tab() ); + if( pCaptData && (maPos != pCaptData->maStart) ) + { + // create drawing undo action + if( pDrawLayer && pDrawLayer->IsRecording() ) + pDrawLayer->AddCalcUndo( std::make_unique<ScUndoObjData>( mxCaption.get(), pCaptData->maStart, pCaptData->maEnd, maPos, pCaptData->maEnd ) ); + // set new position + pCaptData->maStart = maPos; + } +} + +Point ScCaptionCreator::CalcTailPos( bool bTailFront ) +{ + // tail position + bool bTailLeft = bTailFront != mbNegPage; + Point aTailPos = bTailLeft ? maCellRect.TopLeft() : maCellRect.TopRight(); + // move caption point 1/10 mm inside cell + if( bTailLeft ) aTailPos.AdjustX(10 ); else aTailPos.AdjustX( -10 ); + aTailPos.AdjustY(10); + return aTailPos; +} + +void ScCaptionCreator::CreateCaption( bool bShown, bool bTailFront ) +{ + // create the caption drawing object + tools::Rectangle aTextRect( Point( 0 , 0 ), Size( SC_NOTECAPTION_WIDTH, SC_NOTECAPTION_HEIGHT ) ); + Point aTailPos = CalcTailPos( bTailFront ); + mxCaption.reset( + new SdrCaptionObj( + *mrDoc.GetDrawLayer(), // TTTT should ret a ref? + aTextRect, + aTailPos)); + // basic caption settings + ScCaptionUtil::SetBasicCaptionSettings( *mxCaption, bShown ); +} + +void ScCaptionCreator::Initialize() +{ + maCellRect = ScDrawLayer::GetCellRect( mrDoc, maPos, true ); + mbNegPage = mrDoc.IsNegativePage( maPos.Tab() ); + if( SdrPage* pDrawPage = GetDrawPage() ) + { + maPageRect = tools::Rectangle( Point( 0, 0 ), pDrawPage->GetSize() ); + /* #i98141# SdrPage::GetSize() returns negative width in RTL mode. + The call to Rectangle::Adjust() orders left/right coordinate + accordingly. */ + maPageRect.Justify(); + } +} + +/** Helper for creation of permanent caption drawing objects for cell notes. */ +class ScNoteCaptionCreator : public ScCaptionCreator +{ +public: + /** Create a new caption object and inserts it into the document. */ + explicit ScNoteCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, ScNoteData& rNoteData ); + /** Manipulate an existing caption. */ + explicit ScNoteCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, ScCaptionPtr& xCaption, bool bShown ); +}; + +ScNoteCaptionCreator::ScNoteCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, ScNoteData& rNoteData ) : + ScCaptionCreator( rDoc, rPos ) // use helper c'tor that does not create the caption yet +{ + SdrPage* pDrawPage = GetDrawPage(); + OSL_ENSURE( pDrawPage, "ScNoteCaptionCreator::ScNoteCaptionCreator - no drawing page" ); + if( !pDrawPage ) + return; + + // create the caption drawing object + CreateCaption( rNoteData.mbShown, false ); + rNoteData.mxCaption = GetCaption(); + OSL_ENSURE( rNoteData.mxCaption, "ScNoteCaptionCreator::ScNoteCaptionCreator - missing caption object" ); + if( rNoteData.mxCaption ) + { + // store note position in user data of caption object + ScCaptionUtil::SetCaptionUserData( *rNoteData.mxCaption, rPos ); + // insert object into draw page + pDrawPage->InsertObject( rNoteData.mxCaption.get() ); + } +} + +ScNoteCaptionCreator::ScNoteCaptionCreator( ScDocument& rDoc, const ScAddress& rPos, ScCaptionPtr& xCaption, bool bShown ) : + ScCaptionCreator( rDoc, rPos, xCaption ) +{ + SdrPage* pDrawPage = GetDrawPage(); + OSL_ENSURE( pDrawPage, "ScNoteCaptionCreator::ScNoteCaptionCreator - no drawing page" ); + OSL_ENSURE( xCaption->getSdrPageFromSdrObject() == pDrawPage, "ScNoteCaptionCreator::ScNoteCaptionCreator - wrong drawing page in caption" ); + if( pDrawPage && (xCaption->getSdrPageFromSdrObject() == pDrawPage) ) + { + // store note position in user data of caption object + ScCaptionUtil::SetCaptionUserData( *xCaption, rPos ); + // basic caption settings + ScCaptionUtil::SetBasicCaptionSettings( *xCaption, bShown ); + // set correct tail position + xCaption->SetTailPos( CalcTailPos( false ) ); + } +} + +} // namespace + +ScCaptionPtr::ScCaptionPtr() : + mpHead(nullptr), mpNext(nullptr), mpCaption(nullptr), mbNotOwner(false) +{ +} + +ScCaptionPtr::ScCaptionPtr( SdrCaptionObj* p ) : + mpHead(nullptr), mpNext(nullptr), mpCaption(p), mbNotOwner(false) +{ + if (p) + { + newHead(); + } +} + +ScCaptionPtr::ScCaptionPtr( const ScCaptionPtr& r ) : + mpHead(r.mpHead), mpCaption(r.mpCaption), mbNotOwner(false) +{ + if (r.mpCaption) + { + assert(r.mpHead); + r.incRef(); + // Insert into list. + mpNext = r.mpNext; + r.mpNext = this; + } + else + { + assert(!r.mpHead); + mpNext = nullptr; + } +} + +ScCaptionPtr::ScCaptionPtr(ScCaptionPtr&& r) noexcept + : mpHead(r.mpHead), mpNext(r.mpNext), mpCaption(r.mpCaption), mbNotOwner(false) +{ + r.replaceInList( this ); + r.mpCaption = nullptr; + r.mbNotOwner = false; +} + +ScCaptionPtr& ScCaptionPtr::operator=(ScCaptionPtr&& r) noexcept +{ + assert(this != &r); + + mpHead = r.mpHead; + mpNext = r.mpNext; + mpCaption = r.mpCaption; + mbNotOwner = r.mbNotOwner; + + r.replaceInList( this ); + r.mpCaption = nullptr; + r.mbNotOwner = false; + + return *this; +} + +ScCaptionPtr& ScCaptionPtr::operator=( const ScCaptionPtr& r ) +{ + if (this == &r) + return *this; + + if (mpCaption == r.mpCaption) + { + // Two lists for the same caption is bad. + assert(!mpCaption || mpHead == r.mpHead); + assert(!mpCaption); // assigning same caption pointer within same list is weird + // Nullptr captions are not inserted to the list, so nothing to do here + // if both are. + return *this; + } + + // Let's find some weird usage. + // Assigning without head doesn't make sense unless it is a nullptr caption. + assert(r.mpHead || !r.mpCaption); + // A nullptr caption must not be in a list and thus not have a head. + assert(!r.mpHead || r.mpCaption); + // Same captions were caught above, so here different heads must be present. + assert(r.mpHead != mpHead); + + r.incRef(); + decRefAndDestroy(); + removeFromList(); + + mpCaption = r.mpCaption; + mbNotOwner = r.mbNotOwner; + // That head is this' master. + mpHead = r.mpHead; + // Insert into list. + mpNext = r.mpNext; + r.mpNext = this; + + return *this; +} + +void ScCaptionPtr::setNotOwner() +{ + mbNotOwner = true; +} + +ScCaptionPtr::Head::Head( ScCaptionPtr* p ) : + mpFirst(p), mnRefs(1) +{ +} + +void ScCaptionPtr::newHead() +{ + assert(!mpHead); + mpHead = new Head(this); +} + +void ScCaptionPtr::replaceInList(ScCaptionPtr* pNew) noexcept +{ + if (!mpHead && !mpNext) + return; + + assert(mpHead); + assert(mpCaption == pNew->mpCaption); + + ScCaptionPtr* pThat = mpHead->mpFirst; + while (pThat && pThat != this && pThat->mpNext != this) + { + pThat = pThat->mpNext; + } + if (pThat && pThat != this) + { + assert(pThat->mpNext == this); + pThat->mpNext = pNew; + } + pNew->mpNext = mpNext; + if (mpHead->mpFirst == this) + mpHead->mpFirst = pNew; + + mpHead = nullptr; + mpNext = nullptr; +} + +void ScCaptionPtr::removeFromList() +{ + if (!mpHead && !mpNext && !mpCaption) + return; + +#if OSL_DEBUG_LEVEL > 0 + oslInterlockedCount nCount = 0; +#endif + ScCaptionPtr* pThat = (mpHead ? mpHead->mpFirst : nullptr); + while (pThat && pThat != this && pThat->mpNext != this) + { + // Use the walk to check consistency on the fly. + assert(pThat->mpHead == mpHead); // all belong to the same + assert(pThat->mpHead || !pThat->mpNext); // next without head is bad + assert(pThat->mpCaption == mpCaption); + pThat = pThat->mpNext; +#if OSL_DEBUG_LEVEL > 0 + ++nCount; +#endif + } + assert(pThat || !mpHead); // not found only if this was standalone + if (pThat) + { + if (pThat != this) + { +#if OSL_DEBUG_LEVEL > 0 + // The while loop above was not executed, and for this + // (pThat->mpNext) the loop below won't either. + ++nCount; +#endif + pThat->mpNext = mpNext; + } +#if OSL_DEBUG_LEVEL > 0 + do + { + assert(pThat->mpHead == mpHead); // all belong to the same + assert(pThat->mpHead || !pThat->mpNext); // next without head is bad + assert(pThat->mpCaption == mpCaption); + ++nCount; + } + while ((pThat = pThat->mpNext) != nullptr); +#endif + } +#if OSL_DEBUG_LEVEL > 0 + // If part of a list then refs were already decremented. + assert(nCount == (mpHead ? mpHead->mnRefs + 1 : 0)); +#endif + if (mpHead && mpHead->mpFirst == this) + { + if (mpNext) + mpHead->mpFirst = mpNext; + else + { + // The only one destroys also head. + assert(mpHead->mnRefs == 0); // cough + delete mpHead; // DEAD now + } + } + mpHead = nullptr; + mpNext = nullptr; +} + +void ScCaptionPtr::reset( SdrCaptionObj* p ) +{ + assert(!p || p != mpCaption); +#if OSL_DEBUG_LEVEL > 0 + if (p) + { + // Check if we end up with a duplicated management in this list. + ScCaptionPtr* pThat = (mpHead ? mpHead->mpFirst : nullptr); + while (pThat) + { + assert(pThat->mpCaption != p); + pThat = pThat->mpNext; + } + } +#endif + decRefAndDestroy(); + removeFromList(); + mpCaption = p; + mbNotOwner = false; + if (p) + { + newHead(); + } +} + +ScCaptionPtr::~ScCaptionPtr() +{ + decRefAndDestroy(); + removeFromList(); +} + +oslInterlockedCount ScCaptionPtr::getRefs() const +{ + return mpHead ? mpHead->mnRefs : 0; +} + +void ScCaptionPtr::incRef() const +{ + if (mpHead) + osl_atomic_increment(&mpHead->mnRefs); +} + +bool ScCaptionPtr::decRef() const +{ + return mpHead && mpHead->mnRefs > 0 && !osl_atomic_decrement(&mpHead->mnRefs); +} + +void ScCaptionPtr::decRefAndDestroy() +{ + if (!decRef()) + return; + + assert(mpHead->mpFirst == this); // this must be one and only one + assert(!mpNext); // this must be one and only one + assert(mpCaption); + +#if 0 + // Quick workaround for when there are still cases where the caption + // pointer is dangling + mpCaption = nullptr; + mbNotOwner = false; +#else + // Destroying Draw Undo and some other delete the SdrObject, don't + // attempt that twice. + if (mbNotOwner) + { + mpCaption = nullptr; + mbNotOwner = false; + } + else + { + removeFromDrawPageAndFree( true ); // ignoring Undo + if (mpCaption) + { + // There's no draw page associated so removeFromDrawPageAndFree() + // didn't do anything, but still we want to delete the caption + // object. release()/dissolve() also resets mpCaption. + SdrObject* pObj = release(); + SdrObject::Free( pObj ); + } + } +#endif + delete mpHead; + mpHead = nullptr; +} + +void ScCaptionPtr::insertToDrawPage( SdrPage& rDrawPage ) +{ + assert(mpHead && mpCaption); + + rDrawPage.InsertObject( mpCaption ); +} + +void ScCaptionPtr::removeFromDrawPage( SdrPage& rDrawPage ) +{ + assert(mpHead && mpCaption); + SdrObject* pObj = rDrawPage.RemoveObject( mpCaption->GetOrdNum() ); + assert(pObj == mpCaption); (void)pObj; +} + +void ScCaptionPtr::removeFromDrawPageAndFree( bool bIgnoreUndo ) +{ + assert(mpHead && mpCaption); + SdrPage* pDrawPage(mpCaption->getSdrPageFromSdrObject()); + SAL_WARN_IF( !pDrawPage, "sc.core", "ScCaptionPtr::removeFromDrawPageAndFree - object without drawing page"); + if (!pDrawPage) + return; + + pDrawPage->RecalcObjOrdNums(); + bool bRecording = false; + if(!bIgnoreUndo) + { + ScDrawLayer* pDrawLayer(dynamic_cast< ScDrawLayer* >(&mpCaption->getSdrModelFromSdrObject())); + SAL_WARN_IF( !pDrawLayer, "sc.core", "ScCaptionPtr::removeFromDrawPageAndFree - object without drawing layer"); + // create drawing undo action (before removing the object to have valid draw page in undo action) + bRecording = (pDrawLayer && pDrawLayer->IsRecording()); + if (bRecording) + pDrawLayer->AddCalcUndo( std::make_unique<SdrUndoDelObj>( *mpCaption )); + } + // remove the object from the drawing page, delete if undo is disabled + removeFromDrawPage( *pDrawPage ); + // If called from outside mnRefs must be 1 to delete. If called from + // decRefAndDestroy() mnRefs is already 0. + if (!bRecording && getRefs() <= 1) + { + SdrObject* pObj = release(); + SdrObject::Free( pObj ); + } +} + +SdrCaptionObj* ScCaptionPtr::release() +{ + SdrCaptionObj* pTmp = mpCaption; + dissolve(); + return pTmp; +} + +void ScCaptionPtr::forget() +{ + decRef(); + removeFromList(); + mpCaption = nullptr; + mbNotOwner = false; +} + +void ScCaptionPtr::dissolve() +{ + ScCaptionPtr::Head* pHead = mpHead; + ScCaptionPtr* pThat = (mpHead ? mpHead->mpFirst : this); + while (pThat) + { + assert(!pThat->mpNext || pThat->mpHead); // next without head is bad + assert(pThat->mpHead == pHead); // same head required within one list + ScCaptionPtr* p = pThat->mpNext; + pThat->clear(); + pThat = p; + } + assert(!mpHead && !mpNext && !mpCaption); // should had been cleared during list walk + delete pHead; +} + +void ScCaptionPtr::clear() +{ + mpHead = nullptr; + mpNext = nullptr; + mpCaption = nullptr; + mbNotOwner = false; +} + +struct ScCaptionInitData +{ + std::optional< SfxItemSet > moItemSet; /// Caption object formatting. + std::optional< OutlinerParaObject > mxOutlinerObj; /// Text object with all text portion formatting. + OUString maSimpleText; /// Simple text without formatting. + Point maCaptionOffset; /// Caption position relative to cell corner. + Size maCaptionSize; /// Size of the caption object. + bool mbDefaultPosSize; /// True = use default position and size for caption. + + explicit ScCaptionInitData(); +}; + +ScCaptionInitData::ScCaptionInitData() : + mbDefaultPosSize( true ) +{ +} + +ScNoteData::ScNoteData( bool bShown ) : + mbShown( bShown ) +{ +} + +sal_uInt32 ScPostIt::mnLastPostItId = 1; + +ScPostIt::ScPostIt( ScDocument& rDoc, const ScAddress& rPos, sal_uInt32 nPostItId ) : + mrDoc( rDoc ), + maNoteData( false ) +{ + mnPostItId = nPostItId == 0 ? mnLastPostItId++ : nPostItId; + AutoStamp(); + CreateCaption( rPos ); +} + +ScPostIt::ScPostIt( ScDocument& rDoc, const ScAddress& rPos, const ScPostIt& rNote, sal_uInt32 nPostItId ) : + mrDoc( rDoc ), + maNoteData( rNote.maNoteData ) +{ + mnPostItId = nPostItId == 0 ? mnLastPostItId++ : nPostItId; + maNoteData.mxCaption.reset(nullptr); + CreateCaption( rPos, rNote.maNoteData.mxCaption.get() ); +} + +ScPostIt::ScPostIt( ScDocument& rDoc, const ScAddress& rPos, const ScNoteData& rNoteData, bool bAlwaysCreateCaption, sal_uInt32 nPostItId ) : + mrDoc( rDoc ), + maNoteData( rNoteData ) +{ + mnPostItId = nPostItId == 0 ? mnLastPostItId++ : nPostItId; + if( bAlwaysCreateCaption || maNoteData.mbShown ) + CreateCaptionFromInitData( rPos ); +} + +ScPostIt::~ScPostIt() +{ + RemoveCaption(); +} + +std::unique_ptr<ScPostIt> ScPostIt::Clone( const ScAddress& rOwnPos, ScDocument& rDestDoc, const ScAddress& rDestPos, bool bCloneCaption ) const +{ + CreateCaptionFromInitData( rOwnPos ); + sal_uInt32 nPostItId = comphelper::LibreOfficeKit::isActive() ? 0 : mnPostItId; + return bCloneCaption ? std::make_unique<ScPostIt>( rDestDoc, rDestPos, *this, nPostItId ) : std::make_unique<ScPostIt>( rDestDoc, rDestPos, maNoteData, false, mnPostItId ); +} + +void ScPostIt::SetDate( const OUString& rDate ) +{ + maNoteData.maDate = rDate; +} + +void ScPostIt::SetAuthor( const OUString& rAuthor ) +{ + maNoteData.maAuthor = rAuthor; +} + +void ScPostIt::AutoStamp() +{ + maNoteData.maDate = ScGlobal::getLocaleData().getDate( Date( Date::SYSTEM ) ); + maNoteData.maAuthor = SvtUserOptions().GetID(); +} + +const OutlinerParaObject* ScPostIt::GetOutlinerObject() const +{ + if( maNoteData.mxCaption ) + return maNoteData.mxCaption->GetOutlinerParaObject(); + if( maNoteData.mxInitData && maNoteData.mxInitData->mxOutlinerObj ) + return &*maNoteData.mxInitData->mxOutlinerObj; + return nullptr; +} + +const EditTextObject* ScPostIt::GetEditTextObject() const +{ + const OutlinerParaObject* pOPO = GetOutlinerObject(); + return pOPO ? &pOPO->GetTextObject() : nullptr; +} + +OUString ScPostIt::GetText() const +{ + if( const EditTextObject* pEditObj = GetEditTextObject() ) + { + OUStringBuffer aBuffer; + ScNoteEditEngine& rEngine = mrDoc.GetNoteEngine(); + rEngine.SetTextCurrentDefaults(*pEditObj); + sal_Int32 nParaCount = rEngine.GetParagraphCount(); + for( sal_Int32 nPara = 0; nPara < nParaCount; ++nPara ) + { + if( nPara > 0 ) + aBuffer.append( '\n' ); + aBuffer.append(rEngine.GetText(nPara)); + } + return aBuffer.makeStringAndClear(); + } + if( maNoteData.mxInitData ) + return maNoteData.mxInitData->maSimpleText; + return OUString(); +} + +bool ScPostIt::HasMultiLineText() const +{ + if( const EditTextObject* pEditObj = GetEditTextObject() ) + return pEditObj->GetParagraphCount() > 1; + if( maNoteData.mxInitData ) + return maNoteData.mxInitData->maSimpleText.indexOf( '\n' ) >= 0; + return false; +} + +void ScPostIt::SetText( const ScAddress& rPos, const OUString& rText ) +{ + CreateCaptionFromInitData( rPos ); + if( maNoteData.mxCaption ) + maNoteData.mxCaption->SetText( rText ); +} + +SdrCaptionObj* ScPostIt::GetOrCreateCaption( const ScAddress& rPos ) const +{ + CreateCaptionFromInitData( rPos ); + return maNoteData.mxCaption.get(); +} + +void ScPostIt::ForgetCaption( bool bPreserveData ) +{ + if (bPreserveData) + { + // Used in clipboard when the originating document is destructed to be + // able to paste into another document. Caption size and relative + // position are not preserved but default created when pasted. Also the + // MergedItemSet can not be carried over or it had to be adapted to + // defaults and pool. At least preserve the text and outline object if + // possible. + ScCaptionInitData* pInitData = new ScCaptionInitData; + const OutlinerParaObject* pOPO = GetOutlinerObject(); + if (pOPO) + pInitData->mxOutlinerObj = *pOPO; + pInitData->maSimpleText = GetText(); + + maNoteData.mxInitData.reset(pInitData); + maNoteData.mxCaption.forget(); + } + else + { + /* This function is used in undo actions to give up the responsibility for + the caption object which is handled by separate drawing undo actions. */ + maNoteData.mxCaption.forget(); + maNoteData.mxInitData.reset(); + } +} + +void ScPostIt::ShowCaption( const ScAddress& rPos, bool bShow ) +{ + CreateCaptionFromInitData( rPos ); + // no separate drawing undo needed, handled completely inside ScUndoShowHideNote + maNoteData.mbShown = bShow; + if( maNoteData.mxCaption ) + ScCaptionUtil::SetCaptionLayer( *maNoteData.mxCaption, bShow ); +} + +void ScPostIt::ShowCaptionTemp( const ScAddress& rPos, bool bShow ) +{ + CreateCaptionFromInitData( rPos ); + if( maNoteData.mxCaption ) + ScCaptionUtil::SetCaptionLayer( *maNoteData.mxCaption, maNoteData.mbShown || bShow ); +} + +void ScPostIt::UpdateCaptionPos( const ScAddress& rPos ) +{ + CreateCaptionFromInitData( rPos ); + if( maNoteData.mxCaption ) + { + ScCaptionCreator aCreator( mrDoc, rPos, maNoteData.mxCaption ); + aCreator.UpdateCaptionPos(); + } +} + +// private -------------------------------------------------------------------- + +void ScPostIt::CreateCaptionFromInitData( const ScAddress& rPos ) const +{ + // Captions are not created in Undo documents and only rarely in Clipboard, + // but otherwise we need caption or initial data. + assert((maNoteData.mxCaption || maNoteData.mxInitData) || mrDoc.IsUndo() || mrDoc.IsClipboard()); + if( !maNoteData.mxInitData ) + return; + + + /* This function is called from ScPostIt::Clone() when copying cells + to the clipboard/undo document, and when copying cells from the + clipboard/undo document. The former should always be called first, + so if called in a clipboard/undo document, the caption should have + been created already. However, for clipboard in case the + originating document was destructed a new caption has to be + created. */ + OSL_ENSURE( !mrDoc.IsUndo() && (!mrDoc.IsClipboard() || !maNoteData.mxCaption), + "ScPostIt::CreateCaptionFromInitData - note caption should not be created in undo/clip documents" ); + + // going to forget the initial caption data struct when this method returns + auto xInitData = std::move(maNoteData.mxInitData); + + /* #i104915# Never try to create notes in Undo document, leads to + crash due to missing document members (e.g. row height array). */ + if( maNoteData.mxCaption || mrDoc.IsUndo() ) + return; + + if (mrDoc.IsClipboard()) + mrDoc.InitDrawLayer(); // ensure there is a drawing layer + + // ScNoteCaptionCreator c'tor creates the caption and inserts it into the document and maNoteData + ScNoteCaptionCreator aCreator( mrDoc, rPos, maNoteData ); + if( !maNoteData.mxCaption ) + return; + + // Prevent triple change broadcasts of the same object. + bool bWasLocked = maNoteData.mxCaption->getSdrModelFromSdrObject().isLocked(); + maNoteData.mxCaption->getSdrModelFromSdrObject().setLock(true); + + // transfer ownership of outliner object to caption, or set simple text + OSL_ENSURE( xInitData->mxOutlinerObj || !xInitData->maSimpleText.isEmpty(), + "ScPostIt::CreateCaptionFromInitData - need either outliner para object or simple text" ); + if (xInitData->mxOutlinerObj) + maNoteData.mxCaption->SetOutlinerParaObject( std::move(xInitData->mxOutlinerObj) ); + else + maNoteData.mxCaption->SetText( xInitData->maSimpleText ); + + // copy all items or set default items; reset shadow items + ScCaptionUtil::SetDefaultItems( *maNoteData.mxCaption, mrDoc, xInitData->moItemSet ? &*xInitData->moItemSet : nullptr ); + + // set position and size of the caption object + if( xInitData->mbDefaultPosSize ) + { + // set other items and fit caption size to text + maNoteData.mxCaption->SetMergedItem( makeSdrTextMinFrameWidthItem( SC_NOTECAPTION_WIDTH ) ); + maNoteData.mxCaption->SetMergedItem( makeSdrTextMaxFrameWidthItem( SC_NOTECAPTION_MAXWIDTH_TEMP ) ); + maNoteData.mxCaption->AdjustTextFrameWidthAndHeight(); + aCreator.AutoPlaceCaption(); + } + else + { + tools::Rectangle aCellRect = ScDrawLayer::GetCellRect( mrDoc, rPos, true ); + bool bNegPage = mrDoc.IsNegativePage( rPos.Tab() ); + tools::Long nPosX = bNegPage ? (aCellRect.Left() - xInitData->maCaptionOffset.X()) : (aCellRect.Right() + xInitData->maCaptionOffset.X()); + tools::Long nPosY = aCellRect.Top() + xInitData->maCaptionOffset.Y(); + tools::Rectangle aCaptRect( Point( nPosX, nPosY ), xInitData->maCaptionSize ); + maNoteData.mxCaption->SetLogicRect( aCaptRect ); + aCreator.FitCaptionToRect(); + } + + // End prevent triple change broadcasts of the same object. + maNoteData.mxCaption->getSdrModelFromSdrObject().setLock(bWasLocked); + maNoteData.mxCaption->BroadcastObjectChange(); +} + +void ScPostIt::CreateCaption( const ScAddress& rPos, const SdrCaptionObj* pCaption ) +{ + OSL_ENSURE( !maNoteData.mxCaption, "ScPostIt::CreateCaption - unexpected caption object found" ); + maNoteData.mxCaption.reset(nullptr); + + /* #i104915# Never try to create notes in Undo document, leads to + crash due to missing document members (e.g. row height array). */ + OSL_ENSURE( !mrDoc.IsUndo(), "ScPostIt::CreateCaption - note caption should not be created in undo documents" ); + if( mrDoc.IsUndo() ) + return; + + // drawing layer may be missing, if a note is copied into a clipboard document + if( mrDoc.IsClipboard() ) + mrDoc.InitDrawLayer(); + + // ScNoteCaptionCreator c'tor creates the caption and inserts it into the document and maNoteData + ScNoteCaptionCreator aCreator( mrDoc, rPos, maNoteData ); + if( !maNoteData.mxCaption ) + return; + + // clone settings of passed caption + if( pCaption ) + { + // copy edit text object (object must be inserted into page already) + if( OutlinerParaObject* pOPO = pCaption->GetOutlinerParaObject() ) + maNoteData.mxCaption->SetOutlinerParaObject( *pOPO ); + // copy formatting items (after text has been copied to apply font formatting) + maNoteData.mxCaption->SetMergedItemSetAndBroadcast( pCaption->GetMergedItemSet() ); + // move textbox position relative to new cell, copy textbox size + tools::Rectangle aCaptRect = pCaption->GetLogicRect(); + Point aDist = maNoteData.mxCaption->GetTailPos() - pCaption->GetTailPos(); + aCaptRect.Move( aDist.X(), aDist.Y() ); + maNoteData.mxCaption->SetLogicRect( aCaptRect ); + aCreator.FitCaptionToRect(); + } + else + { + // set default formatting and default position + ScCaptionUtil::SetDefaultItems( *maNoteData.mxCaption, mrDoc, nullptr ); + aCreator.AutoPlaceCaption(); + } + + // create undo action + if( ScDrawLayer* pDrawLayer = mrDoc.GetDrawLayer() ) + if( pDrawLayer->IsRecording() ) + pDrawLayer->AddCalcUndo( std::make_unique<SdrUndoNewObj>( *maNoteData.mxCaption ) ); +} + +void ScPostIt::RemoveCaption() +{ + if (!maNoteData.mxCaption) + return; + + /* Remove caption object only, if this note is its owner (e.g. notes in + undo documents refer to captions in original document, do not remove + them from drawing layer here). */ + // TTTT maybe no longer needed - can that still happen? + ScDrawLayer* pDrawLayer = mrDoc.GetDrawLayer(); + if (pDrawLayer == &maNoteData.mxCaption->getSdrModelFromSdrObject()) + maNoteData.mxCaption.removeFromDrawPageAndFree(); + + SAL_INFO("sc.core","ScPostIt::RemoveCaption - refs: " << maNoteData.mxCaption.getRefs() << + " IsUndo: " << mrDoc.IsUndo() << " IsClip: " << mrDoc.IsClipboard() << + " Dtor: " << mrDoc.IsInDtorClear()); + + // Forget the caption object if removeFromDrawPageAndFree() did not free it. + if (maNoteData.mxCaption) + { + SAL_INFO("sc.core","ScPostIt::RemoveCaption - forgetting one ref"); + maNoteData.mxCaption.forget(); + } +} + +ScCaptionPtr ScNoteUtil::CreateTempCaption( + ScDocument& rDoc, const ScAddress& rPos, SdrPage& rDrawPage, + std::u16string_view rUserText, const tools::Rectangle& rVisRect, bool bTailFront ) +{ + OUStringBuffer aBuffer( rUserText ); + // add plain text of invisible (!) cell note (no formatting etc.) + SdrCaptionObj* pNoteCaption = nullptr; + const ScPostIt* pNote = rDoc.GetNote( rPos ); + if( pNote && !pNote->IsCaptionShown() ) + { + if( !aBuffer.isEmpty() ) + aBuffer.append( "\n--------\n" + pNote->GetText() ); + pNoteCaption = pNote->GetOrCreateCaption( rPos ); + } + + // create a caption if any text exists + if( !pNoteCaption && aBuffer.isEmpty() ) + return ScCaptionPtr(); + + // prepare visible rectangle (add default distance to all borders) + tools::Rectangle aVisRect( + rVisRect.Left() + SC_NOTECAPTION_BORDERDIST_TEMP, + rVisRect.Top() + SC_NOTECAPTION_BORDERDIST_TEMP, + rVisRect.Right() - SC_NOTECAPTION_BORDERDIST_TEMP, + rVisRect.Bottom() - SC_NOTECAPTION_BORDERDIST_TEMP ); + + // create the caption object + ScCaptionCreator aCreator( rDoc, rPos, bTailFront ); + + // insert caption into page (needed to set caption text) + aCreator.GetCaption().insertToDrawPage( rDrawPage ); + + SdrCaptionObj* pCaption = aCreator.GetCaption().get(); // just for ease of use + + // clone the edit text object, unless user text is present, then set this text + if( pNoteCaption && rUserText.empty() ) + { + if( OutlinerParaObject* pOPO = pNoteCaption->GetOutlinerParaObject() ) + pCaption->SetOutlinerParaObject( *pOPO ); + // set formatting (must be done after setting text) and resize the box to fit the text + pCaption->SetMergedItemSetAndBroadcast( pNoteCaption->GetMergedItemSet() ); + tools::Rectangle aCaptRect( pCaption->GetLogicRect().TopLeft(), pNoteCaption->GetLogicRect().GetSize() ); + pCaption->SetLogicRect( aCaptRect ); + } + else + { + // if pNoteCaption is null, then aBuffer contains some text + pCaption->SetText( aBuffer.makeStringAndClear() ); + ScCaptionUtil::SetDefaultItems( *pCaption, rDoc, nullptr ); + // adjust caption size to text size + tools::Long nMaxWidth = ::std::min< tools::Long >( aVisRect.GetWidth() * 2 / 3, SC_NOTECAPTION_MAXWIDTH_TEMP ); + pCaption->SetMergedItem( makeSdrTextAutoGrowWidthItem( true ) ); + pCaption->SetMergedItem( makeSdrTextMinFrameWidthItem( SC_NOTECAPTION_WIDTH ) ); + pCaption->SetMergedItem( makeSdrTextMaxFrameWidthItem( nMaxWidth ) ); + pCaption->SetMergedItem( makeSdrTextAutoGrowHeightItem( true ) ); + pCaption->AdjustTextFrameWidthAndHeight(); + } + + // move caption into visible area + aCreator.AutoPlaceCaption( &aVisRect ); + + // XXX Note it is already inserted to the draw page. + return aCreator.GetCaption(); +} + +ScPostIt* ScNoteUtil::CreateNoteFromCaption( + ScDocument& rDoc, const ScAddress& rPos, SdrCaptionObj* pCaption ) +{ + ScNoteData aNoteData( true/*bShown*/ ); + aNoteData.mxCaption.reset( pCaption ); + ScPostIt* pNote = new ScPostIt( rDoc, rPos, aNoteData, false ); + pNote->AutoStamp(); + + rDoc.SetNote(rPos, std::unique_ptr<ScPostIt>(pNote)); + + // ScNoteCaptionCreator c'tor updates the caption object to be part of a note + ScNoteCaptionCreator aCreator( rDoc, rPos, aNoteData.mxCaption, true/*bShown*/ ); + + return pNote; +} + +ScPostIt* ScNoteUtil::CreateNoteFromObjectData( + ScDocument& rDoc, const ScAddress& rPos, SfxItemSet&& rItemSet, + const OutlinerParaObject& rOutlinerObj, const tools::Rectangle& rCaptionRect, + bool bShown ) +{ + ScNoteData aNoteData( bShown ); + aNoteData.mxInitData = std::make_shared<ScCaptionInitData>(); + ScCaptionInitData& rInitData = *aNoteData.mxInitData; + rInitData.moItemSet.emplace(std::move(rItemSet)); + rInitData.mxOutlinerObj = rOutlinerObj; + + // convert absolute caption position to relative position + rInitData.mbDefaultPosSize = rCaptionRect.IsEmpty(); + if( !rInitData.mbDefaultPosSize ) + { + tools::Rectangle aCellRect = ScDrawLayer::GetCellRect( rDoc, rPos, true ); + bool bNegPage = rDoc.IsNegativePage( rPos.Tab() ); + rInitData.maCaptionOffset.setX( bNegPage ? (aCellRect.Left() - rCaptionRect.Right()) : (rCaptionRect.Left() - aCellRect.Right()) ); + rInitData.maCaptionOffset.setY( rCaptionRect.Top() - aCellRect.Top() ); + rInitData.maCaptionSize = rCaptionRect.GetSize(); + } + + /* Create the note and insert it into the document. If the note is + visible, the caption object will be created automatically. */ + ScPostIt* pNote = new ScPostIt( rDoc, rPos, aNoteData, /*bAlwaysCreateCaption*/false, 0/*nPostItId*/ ); + pNote->AutoStamp(); + + rDoc.SetNote(rPos, std::unique_ptr<ScPostIt>(pNote)); + + return pNote; +} + +ScPostIt* ScNoteUtil::CreateNoteFromString( + ScDocument& rDoc, const ScAddress& rPos, const OUString& rNoteText, + bool bShown, bool bAlwaysCreateCaption, sal_uInt32 nPostItId ) +{ + ScPostIt* pNote = nullptr; + if( !rNoteText.isEmpty() ) + { + ScNoteData aNoteData( bShown ); + aNoteData.mxInitData = std::make_shared<ScCaptionInitData>(); + ScCaptionInitData& rInitData = *aNoteData.mxInitData; + rInitData.maSimpleText = rNoteText; + rInitData.mbDefaultPosSize = true; + + /* Create the note and insert it into the document. If the note is + visible, the caption object will be created automatically. */ + pNote = new ScPostIt( rDoc, rPos, aNoteData, bAlwaysCreateCaption, nPostItId ); + pNote->AutoStamp(); + //insert takes ownership + rDoc.SetNote(rPos, std::unique_ptr<ScPostIt>(pNote)); + } + return pNote; +} + +namespace sc { + +NoteEntry::NoteEntry( const ScAddress& rPos, const ScPostIt* pNote ) : + maPos(rPos), mpNote(pNote) {} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |