summaryrefslogtreecommitdiffstats
path: root/sc/inc/postit.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /sc/inc/postit.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sc/inc/postit.hxx')
-rw-r--r--sc/inc/postit.hxx374
1 files changed, 374 insertions, 0 deletions
diff --git a/sc/inc/postit.hxx b/sc/inc/postit.hxx
new file mode 100644
index 000000000..dd3475ebb
--- /dev/null
+++ b/sc/inc/postit.hxx
@@ -0,0 +1,374 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <rtl/ustring.hxx>
+#include <svl/itemset.hxx>
+#include "address.hxx"
+#include "scdllapi.h"
+
+#include <memory>
+#include <string_view>
+
+class EditTextObject;
+class OutlinerParaObject;
+class SdrCaptionObj;
+class SdrPage;
+
+class ScDocument;
+namespace tools { class Rectangle; }
+struct ScCaptionInitData;
+
+/** Some desperate attempt to fight against the caption object ownership mess,
+ to which none of shared/weak/plain pointer is a cure.
+ */
+class ScCaptionPtr
+{
+public:
+ ScCaptionPtr();
+ explicit ScCaptionPtr( SdrCaptionObj* p );
+ ScCaptionPtr( const ScCaptionPtr& r );
+ ScCaptionPtr(ScCaptionPtr&& r) noexcept;
+ ~ScCaptionPtr();
+
+ ScCaptionPtr& operator=( const ScCaptionPtr& r );
+ ScCaptionPtr& operator=(ScCaptionPtr&& r) noexcept;
+ explicit operator bool() const { return mpCaption != nullptr; }
+ const SdrCaptionObj* get() const { return mpCaption; }
+ SdrCaptionObj* get() { return mpCaption; }
+ const SdrCaptionObj* operator->() const { return mpCaption; }
+ SdrCaptionObj* operator->() { return mpCaption; }
+ const SdrCaptionObj& operator*() const { return *mpCaption; }
+ SdrCaptionObj& operator*() { return *mpCaption; }
+
+ // Does not default to nullptr to make it visually obvious where such is used.
+ void reset( SdrCaptionObj* p );
+
+ /** Insert to draw page. The caption object is owned by the draw page then.
+ */
+ void insertToDrawPage( SdrPage& rDrawPage );
+
+ /** Remove from draw page. The caption object is not owned anymore by the
+ draw page then.
+ */
+ void removeFromDrawPage( SdrPage& rDrawPage );
+
+ /** Remove from draw page and free caption object if no Undo recording.
+ */
+ void removeFromDrawPageAndFree( bool bIgnoreUndo = false );
+
+ /** Release all management of the SdrCaptionObj* in all instances of this
+ list and dissolve. The SdrCaptionObj pointer returned is ready to be
+ managed elsewhere.
+ */
+ SdrCaptionObj* release();
+
+ /** Forget the SdrCaptionObj pointer in this one instance.
+ Decrements a use count but does not destroy the object, it's up to the
+ caller to manage this mess...
+ */
+ void forget();
+
+ /** Flag that this instance is in Undo, so drawing layer owns it. */
+ void setNotOwner();
+
+ oslInterlockedCount getRefs() const;
+
+private:
+
+ struct Head
+ {
+ ScCaptionPtr* mpFirst; ///< first in list
+ oslInterlockedCount mnRefs; ///< use count
+
+ Head() = delete;
+ explicit Head( ScCaptionPtr* );
+ };
+
+ Head* mpHead; ///< points to the "master" entry
+ mutable ScCaptionPtr* mpNext; ///< next in list
+ SdrCaptionObj* mpCaption; ///< the caption object, managed by head master
+ bool mbNotOwner; ///< whether this caption object is owned by something else, e.g. held in Undo
+ /* TODO: can that be moved to Head?
+ * It's unclear when to reset, so
+ * each instance has its own flag.
+ * The last reference count
+ * decrement automatically has the
+ * then current state available.
+ * */
+
+ void newHead(); //< Allocate a new Head and init.
+ void incRef() const;
+ bool decRef() const; //< @returns <TRUE/> if the last reference was decremented.
+ void decRefAndDestroy(); //< Destroys caption object if the last reference was decremented.
+
+ /** Remove from current list and close gap.
+
+ Usually there are only very few instances, so maintaining a doubly
+ linked list isn't worth memory/performance wise and a simple walk does
+ it.
+ */
+ void removeFromList();
+
+ /** Replace this instance with pNew in a list, if any.
+
+ Used by move-ctor and move assignment operator.
+ */
+ void replaceInList(ScCaptionPtr* pNew) noexcept;
+
+ /** Dissolve list when the caption object is released or gone. */
+ void dissolve();
+
+ /** Just clear everything, while dissolving the list. */
+ void clear();
+};
+
+/** Internal data for a cell annotation. */
+struct ScNoteData
+{
+ typedef std::shared_ptr< ScCaptionInitData > ScCaptionInitDataRef;
+
+ OUString maDate; /// Creation date of the note.
+ OUString maAuthor; /// Author of the note.
+ ScCaptionInitDataRef mxInitData; /// Initial data for invisible notes without SdrObject.
+ ScCaptionPtr mxCaption; /// Drawing object representing the cell note.
+ bool mbShown; /// True = note is visible.
+
+ explicit ScNoteData( bool bShown = false );
+};
+
+/**
+ * Additional class containing cell annotation data.
+ */
+class SC_DLLPUBLIC ScPostIt
+{
+public:
+ static sal_uInt32 mnLastPostItId;
+
+ /** Creates an empty note and its caption object and places it according to
+ the passed cell position. */
+ explicit ScPostIt( ScDocument& rDoc, const ScAddress& rPos, sal_uInt32 nPostItId = 0 );
+
+ /** Copy constructor. Clones the note and its caption to a new document. */
+ explicit ScPostIt( ScDocument& rDoc, const ScAddress& rPos, const ScPostIt& rNote, sal_uInt32 nPostItId = 0 );
+
+ /** Creates a note from the passed note data with existing caption object.
+
+ @param bAlwaysCreateCaption Instead of a pointer to an existing
+ caption object, the passed note data structure may contain a
+ reference to an ScCaptionInitData structure containing information
+ about how to construct a missing caption object. If sal_True is passed,
+ the caption drawing object will be created immediately from that
+ data. If sal_False is passed and the note is not visible, it will
+ continue to cache that data until the caption object is requested.
+ */
+ explicit ScPostIt(
+ ScDocument& rDoc, const ScAddress& rPos,
+ const ScNoteData& rNoteData, bool bAlwaysCreateCaption, sal_uInt32 nPostItId = 0 );
+
+ /** Removes the caption object from drawing layer, if this note is its owner. */
+ ~ScPostIt();
+
+ /** Clones this note and its caption object, if specified.
+
+ @param bCloneCaption If sal_True is passed, clones the caption object and
+ inserts it into the drawing layer of the destination document. If
+ sal_False is passed, the cloned note will refer to the old caption
+ object (used e.g. in Undo documents to restore the pointer to the
+ existing caption object).
+ */
+ std::unique_ptr<ScPostIt> Clone(
+ const ScAddress& rOwnPos,
+ ScDocument& rDestDoc, const ScAddress& rDestPos,
+ bool bCloneCaption ) const;
+
+ /** Returns the note id. */
+ sal_uInt32 GetId() const { return mnPostItId; }
+
+ /** Returns the data struct containing all note settings. */
+ const ScNoteData& GetNoteData() const { return maNoteData;}
+
+ /** Returns the creation date of this note. */
+ const OUString& GetDate() const { return maNoteData.maDate;}
+ /** Sets a new creation date for this note. */
+ void SetDate( const OUString& rDate );
+
+ /** Returns the author date of this note. */
+ const OUString& GetAuthor() const { return maNoteData.maAuthor;}
+ /** Sets a new author date for this note. */
+ void SetAuthor( const OUString& rAuthor );
+
+ /** Sets date and author from system settings. */
+ void AutoStamp();
+
+ /** Returns the pointer to the current outliner object, or null. */
+ const OutlinerParaObject* GetOutlinerObject() const;
+ /** Returns the pointer to the current edit text object, or null. */
+ const EditTextObject* GetEditTextObject() const;
+
+ /** Returns the caption text of this note. */
+ OUString GetText() const;
+ /** Returns true, if the caption text of this note contains line breaks. */
+ bool HasMultiLineText() const;
+ /** Changes the caption text of this note. All text formatting will be lost. */
+ void SetText( const ScAddress& rPos, const OUString& rText );
+
+ /** Returns an existing note caption object. returns null, if the note
+ contains initial caption data needed to construct a caption object.
+ The SdrCaptionObj* returned is still managed by the underlying
+ ScNoteData::ScCaptionPtr and must not be stored elsewhere. */
+ SdrCaptionObj* GetCaption() const { return maNoteData.mxCaption.get();}
+ /** Returns the caption object of this note. Creates the caption object, if
+ the note contains initial caption data instead of the caption.
+ The SdrCaptionObj* returned is still managed by the underlying
+ ScNoteData::ScCaptionPtr and must not be stored elsewhere. */
+ SdrCaptionObj* GetOrCreateCaption( const ScAddress& rPos ) const;
+
+ /** Forgets the pointer to the note caption object.
+
+ @param bPreserveData
+ If true then the note text is remembered in maNoteData to be able
+ to later reconstruct a caption from it.
+ */
+ void ForgetCaption( bool bPreserveData = false );
+
+ /** Shows or hides the note caption object. */
+ void ShowCaption( const ScAddress& rPos, bool bShow );
+ /** Returns true, if the caption object is visible. */
+ bool IsCaptionShown() const { return maNoteData.mbShown;}
+
+ /** Shows or hides the caption temporarily (does not change internal visibility state). */
+ void ShowCaptionTemp( const ScAddress& rPos, bool bShow = true );
+
+ /** Updates caption position according to position of the passed cell. */
+ void UpdateCaptionPos( const ScAddress& rPos );
+
+private:
+ ScPostIt( const ScPostIt& ) = delete;
+ ScPostIt& operator=( const ScPostIt& ) = delete;
+
+ /** Creates the caption object from initial caption data if existing. */
+ void CreateCaptionFromInitData( const ScAddress& rPos ) const;
+ /** Creates a new caption object at the passed cell position, clones passed existing caption. */
+ void CreateCaption( const ScAddress& rPos, const SdrCaptionObj* pCaption = nullptr );
+ /** Removes the caption object from the drawing layer, if this note is its owner. */
+ void RemoveCaption();
+
+private:
+ ScDocument& mrDoc; /// Parent document containing the note.
+ mutable ScNoteData maNoteData; /// Note data with pointer to caption object.
+ sal_uInt32 mnPostItId;
+};
+
+class SC_DLLPUBLIC ScNoteUtil
+{
+public:
+
+ /** Creates and returns a caption object for a temporary caption. */
+ static ScCaptionPtr CreateTempCaption( ScDocument& rDoc, const ScAddress& rPos,
+ SdrPage& rDrawPage, std::u16string_view rUserText,
+ const tools::Rectangle& rVisRect, bool bTailFront );
+
+ /** Creates a cell note using the passed caption drawing object.
+
+ This function is used in import filters to reuse the imported drawing
+ object as note caption object.
+
+ @param pCaption The drawing object for the cell note. This object MUST
+ be inserted into the document at the correct drawing page already.
+ The underlying ScPostIt::ScNoteData::ScCaptionPtr takes managing
+ ownership of the pointer.
+
+ @return Pointer to the new cell note object if insertion was
+ successful (i.e. the passed cell position was valid), null
+ otherwise. The Calc document is the owner of the note object. The
+ passed item set and outliner object are deleted automatically if
+ creation of the note was not successful.
+ */
+ static ScPostIt* CreateNoteFromCaption(
+ ScDocument& rDoc, const ScAddress& rPos,
+ SdrCaptionObj* pCaption );
+
+ /** Creates a cell note based on the passed caption object data.
+
+ This function is used in import filters to use an existing imported
+ item set and outliner object to create a note caption object. For
+ performance reasons, it is possible to specify that the caption drawing
+ object for the cell note is not created yet but the note caches the
+ passed data needed to create the caption object on demand (see
+ parameter bAlwaysCreateCaption).
+
+ @param pItemSet Pointer to an item set on heap memory containing all
+ formatting attributes of the caption object. This function takes
+ ownership of the passed item set.
+
+ @param rOutlinerObj An outliner object containing (formatted) text
+ for the caption object.
+
+ @param rCaptionRect The absolute position and size of the caption
+ object. The rectangle may be empty, in this case the default
+ position and size is used.
+
+ @return Pointer to the new cell note object if insertion was
+ successful (i.e. the passed cell position was valid), null
+ otherwise. The Calc document is the owner of the note object.
+ */
+ static ScPostIt* CreateNoteFromObjectData(
+ ScDocument& rDoc, const ScAddress& rPos,
+ SfxItemSet&& oItemSet,
+ const OutlinerParaObject& rOutlinerObj,
+ const tools::Rectangle& rCaptionRect, bool bShown );
+
+ /** Creates a cell note based on the passed string and inserts it into the
+ document.
+
+ @param rNoteText The text used to create the note caption object. Must
+ not be empty.
+
+ @param bAlwaysCreateCaption If sal_True is passed, the caption drawing
+ object will be created immediately. If sal_False is passed, the caption
+ drawing object will not be created if the note is not visible
+ (bShown = sal_False), but the cell note will cache the passed data.
+ MUST be set to sal_False outside of import filter implementations!
+
+ @return Pointer to the new cell note object if insertion was
+ successful (i.e. the passed cell position was valid), null
+ otherwise. The Calc document is the owner of the note object.
+ */
+ static ScPostIt* CreateNoteFromString(
+ ScDocument& rDoc, const ScAddress& rPos,
+ const OUString& rNoteText, bool bShown,
+ bool bAlwaysCreateCaption, sal_uInt32 nPostItId = 0 );
+
+};
+
+namespace sc {
+
+struct NoteEntry
+{
+ ScAddress maPos;
+ const ScPostIt* mpNote;
+
+ NoteEntry( const ScAddress& rPos, const ScPostIt* pNote );
+};
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */