[Libreoffice-commits] core.git: Branch 'feature/item_refactor2' - include/item item/Library_item.mk item/source item/test svl/source
Armin Le Grand (via logerrit)
logerrit at kemper.freedesktop.org
Mon May 13 20:39:12 UTC 2019
include/item/base/ItemBase.hxx | 46 +++++
include/item/base/ItemBuffered.hxx | 4
include/item/base/ModelSpecificItemValues.hxx | 74 ++++++++
include/item/simple/CntInt16.hxx | 21 +-
include/item/simple/CntOUString.hxx | 29 ++-
item/Library_item.mk | 11 -
item/source/base/ItemBase.cxx | 90 ++++++++++
item/source/base/ItemBuffered.cxx | 9 -
item/source/base/ModelSpecificItemValues.cxx | 93 ++++++++++-
item/source/simple/CntInt16.cxx | 46 +++--
item/source/simple/CntOUString.cxx | 45 +++--
item/test/ItemTest.cxx | 218 +++++++++++++++++++-------
svl/source/items/itempool.cxx | 15 +
13 files changed, 575 insertions(+), 126 deletions(-)
New commits:
commit 144ae8582176d87f05850db19a35b920f2ea3a0a
Author: Armin Le Grand <Armin.Le.Grand at me.com>
AuthorDate: Mon May 13 22:31:49 2019 +0200
Commit: Armin Le Grand <Armin.Le.Grand at me.com>
CommitDate: Mon May 13 22:31:49 2019 +0200
WIP: Continued Item stuff changes
Checked what else is needed at the ItemBase stuff,
checked and added getPresentation, scaleMetrics,
query/putValue stuff and dunmAsXml, made quite some
notes about it. Added basiic functionality to basic
sal_Int16 and OUString-Items, also made these tooling
base classes as preparation for type-safe simple
derivations.
Deep check of defaults at currentItemPool, two (static
and default) are used, adapted ModelSpecificItemValues
and added quite some comments about findings. This is
highly copmplex calling stuff, esp. MapMode usages due
to the apps using different basic MapModes what is not
represented in the items - these have no unit.
Adapted tests accordingly - test implementations/derivations
of basic Item implementations used now
Change-Id: Ieac1ef2c62b0bfae97753b15bd8bd61803c8906c
diff --git a/include/item/base/ItemBase.hxx b/include/item/base/ItemBase.hxx
index f0f746b5a036..d099bb4a93ea 100644
--- a/include/item/base/ItemBase.hxx
+++ b/include/item/base/ItemBase.hxx
@@ -23,13 +23,31 @@
#include <sal/types.h>
#include <item/itemdllapi.h>
#include <com/sun/star/uno/Any.hxx>
+#include <tools/mapunit.hxx>
#include <memory>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
+// predefines
+
+class IntlWrapper;
+typedef struct _xmlTextWriter* xmlTextWriterPtr;
+
+///////////////////////////////////////////////////////////////////////////////
namespace Item
{
+ /*
+ * The values of this enum describe the degree of textual
+ * representation of an item after calling the virtual
+ * method <SfxPoolItem::GetPresentation()const>.
+ */
+ enum class SfxItemPresentation
+ {
+ Nameless,
+ Complete
+ };
+
class ItemControlBlock;
// Baseclass for implementation of (refactored) Items. It is
@@ -57,7 +75,7 @@ namespace Item
// is reached. That again will - due to the Item-incarnation
// referencing the ItemData - also have small footprint and simple
// copyability, but be a bit harder to implement.
- // Note: All Items can be implemented either way, the diecision should
+ // Note: All Items can be implemented either way, the decision should
// be made upon size of one incarnation and copyability (some are better
// refCnted). (2) has all the tooling to do that in a unified way.
// For examples how to implement your Item, check
@@ -75,7 +93,7 @@ namespace Item
// PutValue/Any interface for automated instance creation from SfxType
// mechanism (UNO API and sfx2 stuff)
- void putAnyValues(const AnyIDArgs& rArgs);
+ bool putAnyValues(const AnyIDArgs& rArgs);
private:
// local reference to instance of ItemControlBlock for this
@@ -88,7 +106,7 @@ namespace Item
protected:
// PutValue/Any interface for automated instance creation from SfxType
// mechanism (UNO API and sfx2 stuff)
- virtual void putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
+ virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
// constructor for derived classes, thus protected. Derived
// classes hand in their specific ItemControlBlock to be used
@@ -112,6 +130,28 @@ namespace Item
// clone-op, secured by returning a std::unique_ptr to make
// explicit the ownership you get when calling this
std::unique_ptr<ItemBase> clone() const;
+
+ // ca. 220 impls
+ // /** @return true if it has a valid string representation */
+ virtual bool getPresentation(
+ SfxItemPresentation ePresentation,
+ MapUnit eCoreMetric,
+ MapUnit ePresentationMetric,
+ OUString &rText,
+ const IntlWrapper& rIntlWrapper) const;
+
+ // ::ScaleMetrics 18 implementations
+ // used by sdr::properties::ScaleItemSet / itemSetTools only
+ // used by DefaultProperties::DefaultProperties only -> probably copying SdrObjects between Writer/Draw/Impress
+ virtual void scaleMetrics(long lMult, long lDiv);
+
+ // around 250 impls for each
+ virtual bool queryValue(css::uno::Any& rVal, sal_uInt8 nMemberId = 0) const;
+ // virtual bool PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId );
+ // -> 'virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);'
+
+ // ca. 150 impls
+ virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
};
// static versions of default interface
diff --git a/include/item/base/ItemBuffered.hxx b/include/item/base/ItemBuffered.hxx
index 92401a028307..de35a1d01e3e 100755
--- a/include/item/base/ItemBuffered.hxx
+++ b/include/item/base/ItemBuffered.hxx
@@ -56,7 +56,7 @@ namespace Item
// PutValue/Any interface for automated instance creation from SfxType
// mechanism (UNO API and sfx2 stuff). Default does nothing, but asserts
// for missing implementation
- virtual void putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
+ virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
public:
ItemData();
@@ -88,7 +88,7 @@ namespace Item
protected:
// PutValue/Any interface for automated instance creation from SfxType
// mechanism (UNO API and sfx2 stuff)
- virtual void putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
+ virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId);
protected:
// Method to internally (thus protected) set a new ItemData
diff --git a/include/item/base/ModelSpecificItemValues.hxx b/include/item/base/ModelSpecificItemValues.hxx
index 5fce6e40bc69..013ee4433a69 100644
--- a/include/item/base/ModelSpecificItemValues.hxx
+++ b/include/item/base/ModelSpecificItemValues.hxx
@@ -25,6 +25,7 @@
#include <unordered_map>
#include <item/base/ItemBase.hxx>
#include <sal/types.h>
+#include <tools/mapunit.hxx>
///////////////////////////////////////////////////////////////////////////////
@@ -37,6 +38,41 @@ namespace Item
// - maybe: ItemNames - currently in ::TakeItemName and others
// - maybe: hold MapMode info to allow correct GetPresentation
// executions
+ //
+ // Defaults:
+ // Ckecked current stuff, there are two sets of items at a pool:
+ // (1) mpStaticDefaults -> size of start_end fully set ptrs, static defaults, not to be changed, may be owned or not, may be cloned or not
+ // (2) maPoolDefaults -> size of start_end inited by nullptr, set/reset by SetPoolDefaultItem/ResetPoolDefaultItem
+ // This means that we need also two sets here, one for (1) static defaults
+ // which have to be set when different from Item::getDefault and one
+ // for just overridden defaults (1). The 2nd one also has to allow resetting
+ // single entries.
+ // What does SfxItemPool::GetDefaultItem -> first checks maPoolDefaults, then uses mpStaticDefaults
+ //
+ // MapUnit:
+ // in current SfxItemPool there is a 'MapUnit eDefMetric', but also
+ // ::GetMetric(sal_uInt16 nWhich) - grep for that. Dependent of the ItemID
+ // the eDefMetric may be used (that is the default ignoring nWhich), but there
+ // are exceptions - hard to understand.
+ // What is and stays clear:
+ // - one SfxItemPool incarnation including all its 2ndary pools has one MapUnit
+ // - Writer: DrawingLayer runs in MapUnit::MapTwip (which is the default for
+ // SfxItemPool constructor, will be changed using ::SetDefaultMetric, grep).
+ // All Items in Writer run in MapUnit::MapTwip
+ // - Draw/Impress/Chart: All Items run in MapUnit::Map100thMM
+ // - Calc: here it gets complicated - looks as if between
+ // ATTR_STARTINDEX and ATTR_ENDINDEX MapUnit::MapTwip is used. It is
+ // OTOH known that DrawingLayer in Calc runs in MapUnit::Map100thMM.
+ // Strange is ScMessagePool/ScDocumentPool which use for the given range
+ // MapUnit::MapTwip, but MapUnit::Map100thMM for all else - thus the Items in
+ // ScMessagePool are in Map100thMM while the doc items in Calc use MapTwip ?!?
+ // Usually the eDefMetric at SfxItemPool is correct, it may be necessary
+ // to define 'Item-Groups' e.g. for ScMessagePool which have an exceptional
+ // MapUnit.
+ // Alternatively each Item could have an entry for MapUnit, but that would
+ // make them expensive - this has to be taken into account in compare, search,
+ // grep, sort, ecerywhere. No more simple Items, so not really an alternative - sigh.
+
class ITEM_DLLPUBLIC ModelSpecificItemValues : public std::enable_shared_from_this<ModelSpecificItemValues>
{
public:
@@ -44,13 +80,21 @@ namespace Item
typedef std::shared_ptr<ModelSpecificItemValues> SharedPtr;
private:
- // the alternative default items
+ // the static and alternative default items
+ std::unordered_map<size_t, const ItemBase*> m_aStaticItems;
std::unordered_map<size_t, const ItemBase*> m_aAlternativeItems;
+ // the MapUnit used
+ MapUnit m_aMapUnit;
+
protected:
// constructor - protected BY DEFAULT - do NOT CHANGE (!)
// Use ::Create(...) method instead
- ModelSpecificItemValues();
+ ModelSpecificItemValues(
+ MapUnit aMapUnit);
+
+ void implclearStaticDefaultItem(size_t hash_code);
+ void implclearAlternativeDefaultItem(size_t hash_code);
public:
virtual ~ModelSpecificItemValues();
@@ -60,10 +104,34 @@ namespace Item
ModelSpecificItemValues& operator=(const ModelSpecificItemValues&) = delete;
// create instance
- static SharedPtr create();
+ static SharedPtr create(
+ MapUnit aMapUnit = MapUnit::MapTwip
+ );
+
+ // MapUnit interface
+ MapUnit getMapUnit() const
+ {
+ return m_aMapUnit;
+ }
+
+ // StaticDefault interface
+ void setStaticDefaultItem(const ItemBase& rItem);
+ template<class T> void clearStaticDefaultItem()
+ {
+ implclearStaticDefaultItem(typeid(T).hash_code());
+ }
+ void clearStaticDefaultItems();
// AlternativeDefault interface
void setAlternativeDefaultItem(const ItemBase& rItem);
+ template<class T> void clearAlternativeDefaultItem()
+ {
+ implclearAlternativeDefaultItem(typeid(T).hash_code());
+ }
+ void clearAlternativeDefaultItems();
+
+ // default interface using the state of
+ // AlternativeDefault/StaticDefault itzems
bool isDefault(const ItemBase& rItem) const;
const ItemBase& getDefault(const ItemBase& rItem) const;
};
diff --git a/include/item/simple/CntInt16.hxx b/include/item/simple/CntInt16.hxx
index 7a2da5efbe51..a1bd7b51c91a 100644
--- a/include/item/simple/CntInt16.hxx
+++ b/include/item/simple/CntInt16.hxx
@@ -17,14 +17,12 @@
namespace Item
{
// example for SfxInt16Item
- // It uses IAdministrator_set to provide an Administrator using
- // a sorted list for fast accesses. This requires ::operator< to be
- // implemented.
+ // this is a helper base class, so it has *no* method
+ // static ItemControlBlock& GetStaticItemControlBlock();
+ // and also no public constructor (!), but implements all the
+ // tooling methods for Items using a sal_Int16 internally
class ITEM_DLLPUBLIC CntInt16 : public ItemBase
{
- public:
- static ItemControlBlock& GetStaticItemControlBlock();
-
private:
sal_Int16 m_nValue;
@@ -34,11 +32,20 @@ namespace Item
CntInt16(ItemControlBlock& rItemControlBlock, sal_Int16 nVal = 0);
public:
- CntInt16(sal_Int16 nVal = 0);
+ CntInt16() = delete;
virtual bool operator==(const ItemBase&) const;
sal_Int16 getValue() const { return m_nValue; }
void putValue(sal_Int16 nNew) { m_nValue = nNew; }
+
+ virtual bool getPresentation(
+ SfxItemPresentation,
+ MapUnit,
+ MapUnit,
+ rtl::OUString&,
+ const IntlWrapper&) const override;
+ virtual bool queryValue(css::uno::Any& rVal, sal_uInt8 nMemberId = 0) const override;
+ virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId) override;
};
} // end of namespace Item
diff --git a/include/item/simple/CntOUString.hxx b/include/item/simple/CntOUString.hxx
index 0b33c66578c0..9f72ee5e25f6 100644
--- a/include/item/simple/CntOUString.hxx
+++ b/include/item/simple/CntOUString.hxx
@@ -10,7 +10,6 @@
#ifndef INCLUDED_ITEM_SIMPLE_CNTOUSTRING_HXX
#define INCLUDED_ITEM_SIMPLE_CNTOUSTRING_HXX
-//#include <item/base/ItemBaseStaticHelper.hxx>
#include <item/base/ItemBase.hxx>
#include <rtl/ustring.hxx>
@@ -18,24 +17,36 @@
namespace Item
{
- // example for OUStringItem
- // It uses IAdministrator_unordered_set to provide an Administrator using
- // a hashed list for fast accesses. This requires ::operator== and
- // ::GetUniqueKey() to be implemented.
+ // example for CntUnencodedStringItem
+ // this is a helper base class, so it has *no* method
+ // static ItemControlBlock& GetStaticItemControlBlock();
+ // and also no public constructor (!), but implements all the
+ // tooling methods for Items using a sal_Int16 internally
class ITEM_DLLPUBLIC CntOUString : public ItemBase
{
- public:
- static ItemControlBlock& GetStaticItemControlBlock();
-
private:
rtl::OUString m_aValue;
+ protected:
+ // constructor for derived classes that *have* to hand
+ // in the to-be-used ItemControlBlock
+ CntOUString(ItemControlBlock& rItemControlBlock, const rtl::OUString& rValue = rtl::OUString());
+
public:
- CntOUString(const rtl::OUString& rValue = rtl::OUString());
+ CntOUString() = delete;
virtual bool operator==(const ItemBase&) const;
const rtl::OUString& getValue() const { return m_aValue; }
void putValue(const rtl::OUString& rValue) { m_aValue = rValue; }
+
+ virtual bool getPresentation(
+ SfxItemPresentation,
+ MapUnit,
+ MapUnit,
+ rtl::OUString&,
+ const IntlWrapper&) const override;
+ virtual bool queryValue(css::uno::Any& rVal, sal_uInt8 nMemberId = 0) const override;
+ virtual bool putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId) override;
};
} // end of namespace Item
diff --git a/item/Library_item.mk b/item/Library_item.mk
index f63914f79c9e..f89945a29c89 100644
--- a/item/Library_item.mk
+++ b/item/Library_item.mk
@@ -9,7 +9,10 @@
$(eval $(call gb_Library_Library,item))
-$(eval $(call gb_Library_use_external,item,boost_headers))
+$(eval $(call gb_Library_use_externals,item,\
+ boost_headers \
+ libxml2 \
+))
$(eval $(call gb_Library_set_precompiled_header,item,$(SRCDIR)/item/inc/pch/precompiled_item))
@@ -19,13 +22,9 @@ $(eval $(call gb_Library_use_libraries,item,\
cppu \
cppuhelper \
sal \
+ utl \
))
-#$(eval $(call gb_Library_set_include,item,\
-# -I$(SRCDIR)/item/source/inc \
-# $$(INCLUDE) \
-#))
-
$(eval $(call gb_Library_add_defs,item,\
-DITEM_DLLIMPLEMENTATION \
))
diff --git a/item/source/base/ItemBase.cxx b/item/source/base/ItemBase.cxx
index b4ca752fc08e..1b6175c7f44e 100644
--- a/item/source/base/ItemBase.cxx
+++ b/item/source/base/ItemBase.cxx
@@ -10,6 +10,10 @@
#include <item/base/ItemBase.hxx>
#include <item/base/ItemControlBlock.hxx>
#include <cassert>
+#include <osl/diagnose.h>
+#include <libxml/xmlwriter.h>
+#include <unotools/syslocale.hxx>
+#include <unotools/intlwrapper.hxx>
///////////////////////////////////////////////////////////////////////////////
// derived items from : public SfxPoolItem -> 123
@@ -85,18 +89,25 @@ Nonetheless these SlotItems STILL depend on the SfxItem-RANGES defined in the Sf
namespace Item
{
- void ItemBase::putAnyValues(const AnyIDArgs& rArgs)
+ bool ItemBase::putAnyValues(const AnyIDArgs& rArgs)
{
// default implementation does spread given arguments to putAnyValue-call
for(const auto& arg : rArgs)
{
- putAnyValue(arg.first, arg.second);
+ if(!putAnyValue(arg.first, arg.second))
+ {
+ return false;
+ }
}
+
+ return true;
}
- void ItemBase::putAnyValue(const css::uno::Any& /*rVal*/, sal_uInt8 /*nMemberId*/)
+ bool ItemBase::putAnyValue(const css::uno::Any& /*rVal*/, sal_uInt8 /*nMemberId*/)
{
// default has nothing to to
+ OSL_FAIL("There is no implementation for putAnyValue for this item!");
+ return false;
}
ItemBase::ItemBase(ItemControlBlock& rItemControlBlock)
@@ -156,6 +167,79 @@ namespace Item
// callback to ItemControlBlock
return rCandidate.m_rItemControlBlock.isDefault(rCandidate);
}
+
+ /**
+ * This virtual method allows to get a textual representation of the value
+ * for the SfxPoolItem subclasses. It should be overridden by all UI-relevant
+ * SfxPoolItem subclasses.
+ *
+ * Because the unit of measure of the value in the SfxItemPool is only
+ * queryable via @see SfxItemPool::GetMetric(sal_uInt16) const (and not
+ * via the SfxPoolItem instance or subclass, the own unit of measure is
+ * passed to 'eCoreMetric'.
+ *
+ * The corresponding unit of measure is passed as 'ePresentationMetric'.
+ *
+ *
+ * @return SfxItemPresentation SfxItemPresentation::Nameless
+ * A textual representation (if applicable
+ * with a unit of measure) could be created,
+ * but it doesn't contain any semantic meaning
+ *
+ * SfxItemPresentation::Complete
+ * A complete textual representation could be
+ * created with semantic meaning (if applicable
+ * with unit of measure)
+ *
+ * Example:
+ *
+ * pSvxFontItem->GetPresentation( SFX_PRESENTATION_NAMELESS, ... )
+ * "12pt" with return SfxItemPresentation::Nameless
+ *
+ * pSvxColorItem->GetPresentation( SFX_PRESENTATION_COMPLETE, ... )
+ * "red" with return SfxItemPresentation::Nameless
+ * Because the SvxColorItem does not know which color it represents
+ * it cannot provide a name, which is communicated by the return value
+ *
+ * pSvxBorderItem->GetPresentation( SFX_PRESENTATION_COMPLETE, ... )
+ * "1cm top border, 2cm left border, 0.2cm bottom border, ..."
+ */
+ bool ItemBase::getPresentation
+ (
+ SfxItemPresentation /*ePresentation*/, // IN: how we should format
+ MapUnit /*eCoreMetric*/, // IN: current metric of the SfxPoolItems
+ MapUnit /*ePresentationMetric*/, // IN: target metric of the presentation
+ OUString& /*rText*/, // OUT: textual representation
+ const IntlWrapper&
+ ) const
+ {
+ return false;
+ }
+
+ void ItemBase::scaleMetrics( long /*lMult*/, long /*lDiv*/ )
+ {
+ }
+
+ bool ItemBase::queryValue( css::uno::Any&, sal_uInt8 ) const
+ {
+ OSL_FAIL("There is no implementation for queryValue for this item!");
+ return false;
+ }
+
+ void ItemBase::dumpAsXml(xmlTextWriterPtr pWriter) const
+ {
+ xmlTextWriterStartElement(pWriter, BAD_CAST("ItemBase"));
+ // no whichId anymore, type-safe
+ // xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("typeName"), BAD_CAST(typeid(*this).name()));
+ OUString rText;
+ IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
+ if(getPresentation(SfxItemPresentation::Complete, MapUnit::Map100thMM, MapUnit::Map100thMM, rText, aIntlWrapper))
+ {
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(rText.getStr()));
+ }
+ xmlTextWriterEndElement(pWriter);
+ }
} // end of namespace Item
///////////////////////////////////////////////////////////////////////////////
diff --git a/item/source/base/ItemBuffered.cxx b/item/source/base/ItemBuffered.cxx
index 1c974f0fa589..e94f18a4fd9f 100755
--- a/item/source/base/ItemBuffered.cxx
+++ b/item/source/base/ItemBuffered.cxx
@@ -15,10 +15,11 @@
namespace Item
{
- void ItemBuffered::ItemData::putAnyValue(const css::uno::Any& /*rVal*/, sal_uInt8 /*nMemberId*/)
+ bool ItemBuffered::ItemData::putAnyValue(const css::uno::Any& /*rVal*/, sal_uInt8 /*nMemberId*/)
{
// not intended to be used, error
assert(false && "Error: Some instance tries to set an Any at an ::ItemData instance - implement ItemData::putValue method there (!)");
+ return false;
}
ItemBuffered::ItemData::ItemData()
@@ -134,9 +135,9 @@ namespace Item
}
}
- void ItemBuffered::putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId)
+ bool ItemBuffered::putAnyValue(const css::uno::Any& rVal, sal_uInt8 nMemberId)
{
- assert(nullptr != m_pItemData && "ItemBuffered::putAnyValues called but m_pItemData not set (!)");
+ assert(nullptr != m_pItemData && "ItemBuffered::putAnyValue called but m_pItemData not set (!)");
// make sure we are unique - would be nice to first test for change,
// but main usage of putAnyValues() is anyways uno api and thus will
@@ -144,7 +145,7 @@ namespace Item
make_unique();
// forward call to ItemData incarnation
- m_pItemData->putAnyValue(rVal, nMemberId);
+ return m_pItemData->putAnyValue(rVal, nMemberId);
}
ItemBuffered::ItemBuffered(ItemControlBlock& rItemControlBlock)
diff --git a/item/source/base/ModelSpecificItemValues.cxx b/item/source/base/ModelSpecificItemValues.cxx
index 1f56d03709e9..e3ffd9de4998 100644
--- a/item/source/base/ModelSpecificItemValues.cxx
+++ b/item/source/base/ModelSpecificItemValues.cxx
@@ -14,9 +14,12 @@
namespace Item
{
- ModelSpecificItemValues::ModelSpecificItemValues()
+ ModelSpecificItemValues::ModelSpecificItemValues(
+ MapUnit aMapUnit)
: std::enable_shared_from_this<ModelSpecificItemValues>(),
- m_aAlternativeItems()
+ m_aStaticItems(),
+ m_aAlternativeItems(),
+ m_aMapUnit(aMapUnit)
{
}
@@ -24,9 +27,52 @@ namespace Item
{
}
- ModelSpecificItemValues::SharedPtr ModelSpecificItemValues::create()
+ ModelSpecificItemValues::SharedPtr ModelSpecificItemValues::create(
+ MapUnit aMapUnit)
{
- return ModelSpecificItemValues::SharedPtr(new ModelSpecificItemValues());
+ return ModelSpecificItemValues::SharedPtr(
+ new ModelSpecificItemValues(
+ aMapUnit
+ ));
+ }
+
+ void ModelSpecificItemValues::setStaticDefaultItem(const ItemBase& rItem)
+ {
+ const size_t hash_code(typeid(rItem).hash_code());
+ const auto aRetval(m_aStaticItems.find(hash_code));
+
+ if(aRetval == m_aStaticItems.end())
+ {
+ // new entry
+ m_aStaticItems[hash_code] = rItem.clone().release();
+ }
+ else
+ {
+ // replace existing entry
+ delete aRetval->second;
+ aRetval->second = rItem.clone().release();
+ }
+ }
+
+ void ModelSpecificItemValues::implclearStaticDefaultItem(size_t hash_code)
+ {
+ const auto aRetval(m_aStaticItems.find(hash_code));
+
+ if(aRetval != m_aStaticItems.end())
+ {
+ delete aRetval->second;
+ m_aStaticItems.erase(aRetval);
+ }
+ }
+
+ void ModelSpecificItemValues::clearStaticDefaultItems()
+ {
+ for(const auto& candidate : m_aStaticItems)
+ {
+ delete candidate.second;
+ }
+
+ m_aStaticItems.clear();
}
void ModelSpecificItemValues::setAlternativeDefaultItem(const ItemBase& rItem)
@@ -36,15 +82,38 @@ namespace Item
if(aRetval == m_aAlternativeItems.end())
{
+ // new entry
m_aAlternativeItems[hash_code] = rItem.clone().release();
}
else
{
+ // replace existing entry
delete aRetval->second;
aRetval->second = rItem.clone().release();
}
}
+ void ModelSpecificItemValues::implclearAlternativeDefaultItem(size_t hash_code)
+ {
+ const auto aRetval(m_aAlternativeItems.find(hash_code));
+
+ if(aRetval != m_aAlternativeItems.end())
+ {
+ delete aRetval->second;
+ m_aAlternativeItems.erase(aRetval);
+ }
+ }
+
+ void ModelSpecificItemValues::clearAlternativeDefaultItems()
+ {
+ for(const auto& candidate : m_aAlternativeItems)
+ {
+ delete candidate.second;
+ }
+
+ m_aAlternativeItems.clear();
+ }
+
bool ModelSpecificItemValues::isDefault(const ItemBase& rItem) const
{
if(!m_aAlternativeItems.empty())
@@ -64,6 +133,7 @@ namespace Item
const ItemBase& ModelSpecificItemValues::getDefault(const ItemBase& rItem) const
{
+ // check AlternativeItems 1st
if(!m_aAlternativeItems.empty())
{
const size_t hash_code(typeid(rItem).hash_code());
@@ -75,7 +145,20 @@ namespace Item
}
}
- return rItem;
+ // check StaticItems 2nd
+ if(!m_aStaticItems.empty())
+ {
+ const size_t hash_code(typeid(rItem).hash_code());
+ const auto aRetval(m_aStaticItems.find(hash_code));
+
+ if(aRetval != m_aStaticItems.end())
+ {
+ return *aRetval->second;
+ }
+ }
+
+ // no limitations/replacements -> use given Item's default
+ return rItem.getDefault();
}
} // end of namespace Item
diff --git a/item/source/simple/CntInt16.cxx b/item/source/simple/CntInt16.cxx
index e7549c50419a..bd4357c83858 100644
--- a/item/source/simple/CntInt16.cxx
+++ b/item/source/simple/CntInt16.cxx
@@ -15,32 +15,48 @@
namespace Item
{
- ItemControlBlock& CntInt16::GetStaticItemControlBlock()
+ CntInt16::CntInt16(ItemControlBlock& rItemControlBlock, sal_Int16 nVal)
+ : ItemBase(rItemControlBlock),
+ m_nValue(nVal)
{
- static ItemControlBlock aItemControlBlock(
- [](){ return new CntInt16(); },
- [](const ItemBase& rRef){ return new CntInt16(static_cast<const CntInt16&>(rRef)); },
- "CntInt16");
+ }
- return aItemControlBlock;
+ bool CntInt16::operator==(const ItemBase& rRef) const
+ {
+ return ItemBase::operator==(rRef) || // ptr-compare
+ getValue() == static_cast<const CntInt16&>(rRef).getValue();
}
- CntInt16::CntInt16(ItemControlBlock& rItemControlBlock, sal_Int16 nVal)
- : ItemBase(rItemControlBlock),
- m_nValue(nVal)
+ bool CntInt16::getPresentation(
+ SfxItemPresentation,
+ MapUnit,
+ MapUnit,
+ rtl::OUString& rText,
+ const IntlWrapper&) const
{
+ rText = rtl::OUString::number(m_nValue);
+ return true;
}
- CntInt16::CntInt16(sal_Int16 nVal)
- : ItemBase(CntInt16::GetStaticItemControlBlock()),
- m_nValue(nVal)
+ bool CntInt16::queryValue(css::uno::Any& rVal, sal_uInt8) const
{
+ sal_Int16 nValue = m_nValue;
+ rVal <<= nValue;
+ return true;
}
- bool CntInt16::operator==(const ItemBase& rRef) const
+ bool CntInt16::putAnyValue(const css::uno::Any& rVal, sal_uInt8)
{
- return ItemBase::operator==(rRef) || // ptr-compare
- getValue() == static_cast<const CntInt16&>(rRef).getValue();
+ sal_Int16 nValue(0);
+
+ if(rVal >>= nValue)
+ {
+ m_nValue = nValue;
+ return true;
+ }
+
+ assert(false && "CntInt16::putAnyValue - Wrong type!");
+ return false;
}
} // end of namespace Item
diff --git a/item/source/simple/CntOUString.cxx b/item/source/simple/CntOUString.cxx
index 5975fee68c43..08d91e618326 100644
--- a/item/source/simple/CntOUString.cxx
+++ b/item/source/simple/CntOUString.cxx
@@ -15,18 +15,8 @@
namespace Item
{
- ItemControlBlock& CntOUString::GetStaticItemControlBlock()
- {
- static ItemControlBlock aItemControlBlock(
- [](){ return new CntOUString(); },
- [](const ItemBase& rRef){ return new CntOUString(static_cast<const CntOUString&>(rRef)); },
- "CntOUString");
-
- return aItemControlBlock;
- }
-
- CntOUString::CntOUString(const rtl::OUString& rValue)
- : ItemBase(CntOUString::GetStaticItemControlBlock()),
+ CntOUString::CntOUString(ItemControlBlock& rItemControlBlock, const rtl::OUString& rValue)
+ : ItemBase(rItemControlBlock),
m_aValue(rValue)
{
}
@@ -36,6 +26,37 @@ namespace Item
return ItemBase::operator==(rRef) || // ptr-compare
getValue() == static_cast<const CntOUString&>(rRef).getValue();
}
+
+ bool CntOUString::getPresentation(
+ SfxItemPresentation,
+ MapUnit,
+ MapUnit,
+ rtl::OUString& rText,
+ const IntlWrapper&) const
+ {
+ rText = m_aValue;
+ return true;
+ }
+
+ bool CntOUString::queryValue(css::uno::Any& rVal, sal_uInt8) const
+ {
+ rVal <<= m_aValue;
+ return true;
+ }
+
+ bool CntOUString::putAnyValue(const css::uno::Any& rVal, sal_uInt8)
+ {
+ rtl::OUString aTheValue;
+
+ if(rVal >>= aTheValue)
+ {
+ m_aValue = aTheValue;
+ return true;
+ }
+
+ assert(false && "CntOUString::putAnyValue - Wrong type!");
+ return false;
+ }
} // end of namespace Item
///////////////////////////////////////////////////////////////////////////////
diff --git a/item/test/ItemTest.cxx b/item/test/ItemTest.cxx
index 35483a160306..705867a81d04 100644
--- a/item/test/ItemTest.cxx
+++ b/item/test/ItemTest.cxx
@@ -496,6 +496,57 @@ namespace Item
} // end of namespace Item
///////////////////////////////////////////////////////////////////////////////
+
+namespace Item
+{
+ // example for class derived from CntInt16
+ class CntInt16_derived : public CntInt16
+ {
+ public:
+ static ItemControlBlock& GetStaticItemControlBlock()
+ {
+ static ItemControlBlock aItemControlBlock(
+ [](){ return new CntInt16_derived(); },
+ [](const ItemBase& rRef){ return new CntInt16_derived(static_cast<const CntInt16_derived&>(rRef)); },
+ "CntInt16_derived");
+
+ return aItemControlBlock;
+ }
+
+ public:
+ CntInt16_derived(sal_Int16 nValue = 0)
+ : CntInt16(CntInt16_derived::GetStaticItemControlBlock(), nValue)
+ {
+ }
+ };
+} // end of namespace Item
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace Item
+{
+ // example for class derived from CntOUString
+ class CntOUString_derived : public CntOUString
+ {
+ public:
+ static ItemControlBlock& GetStaticItemControlBlock()
+ {
+ static ItemControlBlock aItemControlBlock(
+ [](){ return new CntOUString_derived(); },
+ [](const ItemBase& rRef){ return new CntOUString_derived(static_cast<const CntOUString_derived&>(rRef)); },
+ "CntOUString_derived");
+
+ return aItemControlBlock;
+ }
+
+ public:
+ CntOUString_derived(const rtl::OUString& rValue = rtl::OUString())
+ : CntOUString(CntOUString_derived::GetStaticItemControlBlock(), rValue)
+ {
+ }
+ };
+} // end of namespace Item
+
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
@@ -1225,7 +1276,7 @@ namespace Item
bLoop = true;
}
- int nIncrement(0);
+ int nIncrement(0);
// make use of local MultiValueAB item in conjuction with ItemSet
ModelSpecificItemValues::SharedPtr aModelSpecificIValues(ModelSpecificItemValues::create());
@@ -1384,38 +1435,38 @@ namespace Item
void checkSimpleItems()
{
static bool bInit(false);
- static CntInt16 a_sp, b_sp, c_sp;
- static CntInt16 theDefault;
- static CntOUString sa_sp, sb_sp, sc_sp;
- static CntOUString stheDefault;
+ static CntInt16_derived a_sp, b_sp, c_sp;
+ static CntInt16_derived theDefault;
+ static CntOUString_derived sa_sp, sb_sp, sc_sp;
+ static CntOUString_derived stheDefault;
const sal_uInt32 nLoopNumber(50);
int nIncrement(0);
if(!bInit)
{
bInit = true;
- a_sp = CntInt16(3);
- b_sp = CntInt16(5);
- c_sp = CntInt16(7);
- theDefault = Item::getDefault<CntInt16>();
+ a_sp = CntInt16_derived(3);
+ b_sp = CntInt16_derived(5);
+ c_sp = CntInt16_derived(7);
+ theDefault = Item::getDefault<CntInt16_derived>();
- sa_sp = CntOUString("Hello");
- sb_sp = CntOUString("World");
- sc_sp = CntOUString("..of Doom!");
- stheDefault = Item::getDefault<CntOUString>();
+ sa_sp = CntOUString_derived("Hello");
+ sb_sp = CntOUString_derived("World");
+ sc_sp = CntOUString_derived("..of Doom!");
+ stheDefault = Item::getDefault<CntOUString_derived>();
}
///////////////////////////////////////////////////////////////////////////////
- CntInt16 has3(CntInt16(3));
- CntInt16 has4(CntInt16(4));
+ CntInt16_derived has3(CntInt16_derived(3));
+ CntInt16_derived has4(CntInt16_derived(4));
- if(CntInt16(11).isDefault())
+ if(CntInt16_derived(11).isDefault())
{
nIncrement++;
}
- if(CntInt16(0).isDefault())
+ if(CntInt16_derived(0).isDefault())
{
nIncrement++;
}
@@ -1425,26 +1476,26 @@ namespace Item
nIncrement++;
}
- std::vector<CntInt16> test16;
+ std::vector<CntInt16_derived> test16;
for(sal_uInt32 a(0); a < nLoopNumber; a++)
{
- test16.push_back(CntInt16(a));
+ test16.push_back(CntInt16_derived(a));
}
test16.clear();
///////////////////////////////////////////////////////////////////////////////
- CntOUString shas3(CntOUString("Hello"));
- CntOUString shas4(CntOUString("WhateverComesAlong"));
+ CntOUString_derived shas3(CntOUString_derived("Hello"));
+ CntOUString_derived shas4(CntOUString_derived("WhateverComesAlong"));
- if(CntOUString("NotDefault").isDefault())
+ if(CntOUString_derived("NotDefault").isDefault())
{
nIncrement++;
}
- if(CntOUString(OUString()).isDefault())
+ if(CntOUString_derived(OUString()).isDefault())
{
nIncrement++;
}
@@ -1454,11 +1505,11 @@ namespace Item
nIncrement++;
}
- std::vector<CntOUString> testStr;
+ std::vector<CntOUString_derived> testStr;
for(sal_uInt32 a(0); a < nLoopNumber; a++)
{
- testStr.push_back(CntOUString(OUString::number(static_cast<int>(a))));
+ testStr.push_back(CntOUString_derived(OUString::number(static_cast<int>(a))));
}
testStr.clear();
@@ -1471,30 +1522,83 @@ namespace Item
void checkSimpleItemsAtISet()
{
- int nIncrement(0);
+ // for debug, change bLoop to true, start, attach and set to false again to debug (one possibility...)
+ static bool bLoop(false);
+ while(bLoop)
+ {
+ bLoop = true;
+ }
- ModelSpecificItemValues::SharedPtr aModelSpecificIValues(ModelSpecificItemValues::create());
- aModelSpecificIValues->setAlternativeDefaultItem(CntInt16(3));
- aModelSpecificIValues->setAlternativeDefaultItem(CntInt16(4));
+ int nIncrement(0);
+ ModelSpecificItemValues::SharedPtr aModelSpecificIValues(
+ ModelSpecificItemValues::create(
+ MapUnit::Map100thMM
+ ));
+
+ // check StaticDefaultItem
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(6));
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(7));
+ aModelSpecificIValues->clearStaticDefaultItem<CntInt16_derived>();
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(8));
+ aModelSpecificIValues->clearStaticDefaultItems();
+
+ // check AlternativeDefaultItem
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(3));
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(4));
+ aModelSpecificIValues->clearAlternativeDefaultItem<CntInt16_derived>();
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(5));
+ aModelSpecificIValues->clearAlternativeDefaultItems();
+
+ // both mixed...
+ const CntInt16_derived aInstance(CntInt16_derived(44));
+ const auto& rStateA(aModelSpecificIValues->getDefault(aInstance));
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(9));
+ const auto& rStateB(aModelSpecificIValues->getDefault(aInstance));
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(10));
+ const auto& rStateC(aModelSpecificIValues->getDefault(aInstance));
+ aModelSpecificIValues->clearStaticDefaultItem<CntInt16_derived>();
+ const auto& rStateD(aModelSpecificIValues->getDefault(aInstance));
+
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(11));
+ const auto& rStateE(aModelSpecificIValues->getDefault(aInstance));
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(12));
+ const auto& rStateF(aModelSpecificIValues->getDefault(aInstance));
+ aModelSpecificIValues->clearAlternativeDefaultItem<CntInt16_derived>();
+ const auto& rStateG(aModelSpecificIValues->getDefault(aInstance));
+
+ aModelSpecificIValues->setStaticDefaultItem(CntInt16_derived(13));
+ aModelSpecificIValues->setAlternativeDefaultItem(CntInt16_derived(14));
+ const auto& rStateH(aModelSpecificIValues->getDefault(aInstance));
+
+ if(44 == static_cast<const CntInt16_derived&>(rStateA).getValue()) nIncrement++;
+ if( 9 == static_cast<const CntInt16_derived&>(rStateB).getValue()) nIncrement++;
+ if(10 == static_cast<const CntInt16_derived&>(rStateC).getValue()) nIncrement++;
+ if(10 == static_cast<const CntInt16_derived&>(rStateD).getValue()) nIncrement++;
+ if(11 == static_cast<const CntInt16_derived&>(rStateE).getValue()) nIncrement++;
+ if(12 == static_cast<const CntInt16_derived&>(rStateF).getValue()) nIncrement++;
+ if(13 == static_cast<const CntInt16_derived&>(rStateG).getValue()) nIncrement++;
+ if(14 == static_cast<const CntInt16_derived&>(rStateH).getValue()) nIncrement++;
+
+ // create and play with TtemSet
ItemSet::SharedPtr aSet(ItemSet::create(aModelSpecificIValues));
- const auto aActEmpty(aSet->getStateAndItem<CntInt16>());
+ const auto aActEmpty(aSet->getStateAndItem<CntInt16_derived>());
- aSet->setItem(CntInt16(4));
- const auto aActA(aSet->getStateAndItem<CntInt16>());
+ aSet->setItem(CntInt16_derived(4));
+ const auto aActA(aSet->getStateAndItem<CntInt16_derived>());
- aSet->setItem(Item::getDefault<CntInt16>());
- const auto aActB(aSet->getStateAndItem<CntInt16>());
+ aSet->setItem(Item::getDefault<CntInt16_derived>());
+ const auto aActB(aSet->getStateAndItem<CntInt16_derived>());
- aSet->setItem(CntInt16(12));
- const auto aActC(aSet->getStateAndItem<CntInt16>());
+ aSet->setItem(CntInt16_derived(12));
+ const auto aActC(aSet->getStateAndItem<CntInt16_derived>());
- aSet->setItem(CntOUString("Teststring - not really useful :-)"));
- const auto aActStr(aSet->getStateAndItem<CntOUString>());
+ aSet->setItem(CntOUString_derived("Teststring - not really useful :-)"));
+ const auto aActStr(aSet->getStateAndItem<CntOUString_derived>());
- const auto ItemDADA(aSet->getStateAndItem<CntInt16>());
+ const auto ItemDADA(aSet->getStateAndItem<CntInt16_derived>());
- if(const auto Item(aSet->getStateAndItem<CntOUString>()); Item.isSet())
+ if(const auto Item(aSet->getStateAndItem<CntOUString_derived>()); Item.isSet())
{
nIncrement += (ItemSet::IState::SET == Item.getIState()) ? 1 : 0;
nIncrement += Item.isDisabled();
@@ -1513,14 +1617,14 @@ namespace Item
}
// check getting default at Set, this will include ModelSpecificItemValues
- // compared with the static ItemBase::GetDefault<CntInt16>() call
- const CntInt16 aDefSet(aSet->getDefault<CntInt16>());
- const CntInt16 aDefGlobal(Item::getDefault<CntInt16>());
+ // compared with the static ItemBase::GetDefault<CntInt16_derived>() call
+ const CntInt16_derived aDefSet(aSet->getDefault<CntInt16_derived>());
+ const CntInt16_derived aDefGlobal(Item::getDefault<CntInt16_derived>());
- const bool bClA(aSet->clearItem<const CntInt16>());
+ const bool bClA(aSet->clearItem<const CntInt16_derived>());
nIncrement += bClA;
// let one exist to check destruction when Set gets destructed
- // const bool bClB(aSet->ClearItem<const CntOUString>());
+ // const bool bClB(aSet->ClearItem<const CntOUString_derived>());
nIncrement ++;
}
@@ -1533,31 +1637,31 @@ namespace Item
}
static bool bInit(false);
- static CntInt16 a_sp, b_sp, c_sp;
- static CntInt16 theDefault;
+ static CntInt16_derived a_sp, b_sp, c_sp;
+ static CntInt16_derived theDefault;
const sal_uInt32 nLoopNumber(50);
int nIncrement(0);
if(!bInit)
{
bInit = true;
- a_sp = CntInt16(3);
- b_sp = CntInt16(5);
- c_sp = CntInt16(7);
- theDefault = Item::getDefault<CntInt16>();
+ a_sp = CntInt16_derived(3);
+ b_sp = CntInt16_derived(5);
+ c_sp = CntInt16_derived(7);
+ theDefault = Item::getDefault<CntInt16_derived>();
}
///////////////////////////////////////////////////////////////////////////////
- CntInt16 has3(CntInt16(3));
- CntInt16 has4(CntInt16(4));
+ CntInt16_derived has3(CntInt16_derived(3));
+ CntInt16_derived has4(CntInt16_derived(4));
- if(CntInt16(11).isDefault())
+ if(CntInt16_derived(11).isDefault())
{
nIncrement++;
}
- if(CntInt16(0).isDefault())
+ if(CntInt16_derived(0).isDefault())
{
nIncrement++;
}
@@ -1567,11 +1671,11 @@ namespace Item
nIncrement++;
}
- std::vector<CntInt16> test16;
+ std::vector<CntInt16_derived> test16;
for(sal_uInt32 a(0); a < nLoopNumber; a++)
{
- test16.push_back(CntInt16(a));
+ test16.push_back(CntInt16_derived(a));
}
test16.clear();
diff --git a/svl/source/items/itempool.cxx b/svl/source/items/itempool.cxx
index 40a513bc0d72..6c3e43daef80 100644
--- a/svl/source/items/itempool.cxx
+++ b/svl/source/items/itempool.cxx
@@ -85,6 +85,21 @@ do { \
#define CHECK_SLOTS() do {} while (false)
#endif
+//////////////////////////////////////////////////////////////////////////////
+// list of classes derived from SfxItemPool
+//////////////////////////////////////////////////////////////////////////////
+// ChartItemPool : public SfxItemPool
+// EditEngineItemPool : public SfxItemPool
+// XOutdevItemPool : public SfxItemPool
+// SdrItemPool : public XOutdevItemPool
+// ScDocumentPool: public SfxItemPool
+// ScMessagePool: public SfxItemPool
+// CntItemPool: public SfxItemPool
+// SwAttrPool : public SfxItemPool
+//
+// mpStaticDefaults -> size of start_end fully set ptrs, static defaults, not to be changed, may be owned or not, may be cloned or not
+// maPoolDefaults -> size of start_end inited by nullptr, set/reset by SetPoolDefaultItem/ResetPoolDefaultItem
+// GetDefaultItem -> first checks maPoolDefaults, then uses mpStaticDefaults
void SfxItemPool::AddSfxItemPoolUser(SfxItemPoolUser& rNewUser)
{
More information about the Libreoffice-commits
mailing list