[Libreoffice-commits] core.git: Branch 'feature/item_refactor2' - include/item include/svl item/source item/test svl/source
Armin Le Grand (via logerrit)
logerrit at kemper.freedesktop.org
Tue May 14 15:56:11 UTC 2019
include/item/base/ItemBase.hxx | 9 ++
include/item/base/ItemSet.hxx | 17 ++-
include/item/simple/CntInt16.hxx | 17 +++
include/item/simple/CntOUString.hxx | 30 ++++++
include/svl/itemiter.hxx | 9 ++
include/svl/itemset.hxx | 7 -
item/source/base/ItemBase.cxx | 10 ++
item/source/base/ItemSet.cxx | 156 +++++++++++++++++++++++++++---------
item/source/simple/CntOUString.cxx | 8 +
item/test/ItemTest.cxx | 102 +++++++++++++++++++++++
svl/source/items/itemset.cxx | 40 ++++++++-
11 files changed, 352 insertions(+), 53 deletions(-)
New commits:
commit 8471a84bcd79557b5543d8fbaade014edb64f591
Author: Armin Le Grand <Armin.Le.Grand at me.com>
AuthorDate: Tue May 14 17:47:23 2019 +0200
Commit: Armin Le Grand <Armin.Le.Grand at me.com>
CommitDate: Tue May 14 17:47:23 2019 +0200
WIP: Deeper adaptions to SfxItemSet/Item::ItemSet
To get forward I added more functionality to the used
combination of SfxItemSet and Item::ItemSet.
Changed internal state holding of Invalidate and Disable
states. No longer using a single static instance of
specialized Item:: derivations (exclusively and ilsolated
in cxx impl parts of ::ItemSet), but incarnating these.
Advantage is to have the ItemDefault stored with these
and thus to have something to return when these Items
are in that state.
To do so, added small boolean virtual functions to iidentify,
added descriptions how/why they are there.
Added methods to ItemSet to get all Items or all in a special
state, see header. Due to change above this can now come
with ItemDefaults added as fallbacks.
Added dumpAsXml plunged to where it is called from SfxItemSet
currently to have that functional.
Checked current SfxItemIter and commented there due to hard
problems there, see comments.
Added support for SetParent, forwarding to Item::ItemSet now
to get that functional, too.
Extended test for new functions.
Change-Id: Ifb043a893bcef9e176a317801acbd848d5443122
diff --git a/include/item/base/ItemBase.hxx b/include/item/base/ItemBase.hxx
index d099bb4a93ea..34901af80d72 100644
--- a/include/item/base/ItemBase.hxx
+++ b/include/item/base/ItemBase.hxx
@@ -95,6 +95,15 @@ namespace Item
// mechanism (UNO API and sfx2 stuff)
bool putAnyValues(const AnyIDArgs& rArgs);
+ // fast identifyer for invalidate/disable state extra-Items,
+ // only to be used internally for ItemSet stuff. This could be
+ // done using dynamic_cast, but is faster this way. This could
+ // be private or protected, but would require ItemSet to be
+ // declared as friend then. May be changed, but for now, use as
+ // simple public virtual bool methods
+ virtual bool isInvalidateItem() const;
+ virtual bool isDisableItem() const;
+
private:
// local reference to instance of ItemControlBlock for this
// incarnation - same as type::GetStaticItemControlBlock(), but
diff --git a/include/item/base/ItemSet.hxx b/include/item/base/ItemSet.hxx
index 0d66a4da7c56..785b78099779 100644
--- a/include/item/base/ItemSet.hxx
+++ b/include/item/base/ItemSet.hxx
@@ -221,8 +221,8 @@ namespace Item
// helpers for reduction of template member implementations,
// all based on typeid(<type>).hash_code()
const ItemBase* implGetStateAndItem(size_t hash_code, IState& rIState, bool bSearchParent) const;
- void implInvalidateItem(size_t hash_code);
- void implDisableItem(size_t hash_code);
+ void implInvalidateItem(size_t hash_code, const ItemBase& rItemDefault);
+ void implDisableItem(size_t hash_code, const ItemBase& rItemDefault);
bool implClearItem(size_t hash_code);
protected:
@@ -251,6 +251,10 @@ namespace Item
void setItem(const ItemBase& rItem);
void setItems(const ItemSet& rSource, bool bDontCareToDefault = true);
+ // get methods for a whole selection of Items
+ std::vector<std::pair<const ItemBase*, IState>> getAllItemsAndStates() const;
+ std::vector<const ItemBase*> getItemsOfState(IState eIState = IState::SET) const;
+
// from here are all the type-specific template methods,
// as reduced as possible due to these being unfolded from
// the compiler for each class.
@@ -258,12 +262,12 @@ namespace Item
// on the fetched TypeID
template< typename TItem > void invalidateItem()
{
- implInvalidateItem(typeid(TItem).hash_code());
+ implInvalidateItem(typeid(TItem).hash_code(), Item::getDefault<TItem>());
}
template< typename TItem > void disableItem()
{
- implDisableItem(typeid(TItem).hash_code());
+ implDisableItem(typeid(TItem).hash_code(), Item::getDefault<TItem>());
}
template< typename TItem > const TItem& getDefault() const
@@ -286,7 +290,10 @@ namespace Item
IState aIState(IState::DEFAULT);
const ItemBase* pItem(implGetStateAndItem(typeid(TItem).hash_code(), aIState, bSearchParent));
- // SfxItemState::DEFAULT || SfxItemState::DONTCARE || SfxItemState::DISABLED
+ // SfxItemState::DEFAULT
+ // SfxItemState::DONTCARE || SfxItemState::DISABLED -> should already be
+ // solved from ImplInvalidateItem/ImplDisableItem, but to have the
+ // fallback here additionally is never wrong
// in short: no specific ItemBase -> use default
if(nullptr == pItem)
{
diff --git a/include/item/simple/CntInt16.hxx b/include/item/simple/CntInt16.hxx
index 164e2afe85d9..fafd819b0c0c 100644
--- a/include/item/simple/CntInt16.hxx
+++ b/include/item/simple/CntInt16.hxx
@@ -21,6 +21,23 @@ namespace Item
// static ItemControlBlock& GetStaticItemControlBlock();
// and also no public constructor (!), but implements all the
// tooling methods for Items using a sal_Int16 internally
+ //
+ // class SfxInt16Item: public SfxPoolItem
+ // class SvxKerningItem : public SfxInt16Item
+ // class SfxImageItem : public SfxInt16Item
+ // class SdrSignedPercentItem : public SfxInt16Item
+ // class SdrGrafRedItem : public SdrSignedPercentItem
+ // class SdrGrafGreenItem : public SdrSignedPercentItem
+ // class SdrGrafBlueItem : public SdrSignedPercentItem
+ // class SdrGrafLuminanceItem : public SdrSignedPercentItem
+ // class SdrGrafContrastItem : public SdrSignedPercentItem
+ // class SdrTextAniAmountItem: public SfxInt16Item
+ // class SdrMeasureDecimalPlacesItem: public SfxInt16Item
+ // class ScMergeFlagAttr: public SfxInt16Item
+ // class SwLuminanceGrf : public SfxInt16Item
+ // class SwContrastGrf : public SfxInt16Item
+ // class SwChannelGrf : public SfxInt16Item
+ //
class ITEM_DLLPUBLIC CntInt16 : public ItemBase
{
private:
diff --git a/include/item/simple/CntOUString.hxx b/include/item/simple/CntOUString.hxx
index 87cea1749d34..9a56fc260998 100644
--- a/include/item/simple/CntOUString.hxx
+++ b/include/item/simple/CntOUString.hxx
@@ -30,6 +30,33 @@ namespace Item
// here now to always only have one instance for CntOUString-based
// derivations. This will use ItemAdministrator_set, see *.cxx
// for details
+ //
+ //class CntUnencodedStringItem: public SfxPoolItem
+ // class SfxStringItem: public CntUnencodedStringItem
+ // class SvxPageModelItem : public SfxStringItem
+ // class SfxDocumentInfoItem : public SfxStringItem
+ // class SvxPostItAuthorItem: public SfxStringItem
+ // class SvxPostItDateItem: public SfxStringItem
+ // class SvxPostItTextItem: public SfxStringItem
+ // class SvxPostItIdItem: public SfxStringItem
+ // class SdrMeasureFormatStringItem: public SfxStringItem
+ // class NameOrIndex : public SfxStringItem
+ // class XFillBitmapItem : public NameOrIndex
+ // class XColorItem : public NameOrIndex
+ // class XFillColorItem : public XColorItem
+ // class XFormTextShadowColorItem : public XColorItem
+ // class XLineColorItem : public XColorItem
+ // class XSecondaryFillColorItem : public XColorItem
+ // class XFillGradientItem : public NameOrIndex
+ // class XFillFloatTransparenceItem : public XFillGradientItem
+ // class XFillHatchItem : public NameOrIndex
+ // class XLineDashItem : public NameOrIndex
+ // class XLineEndItem : public NameOrIndex
+ // class XLineStartItem : public NameOrIndex
+ // class SfxScriptOrganizerItem : public SfxStringItem
+ // class SdrLayerNameItem: public SfxStringItem
+ // class SwNumRuleItem : public SfxStringItem
+ //
class ITEM_DLLPUBLIC CntOUString : public ItemBuffered
{
protected:
@@ -69,6 +96,9 @@ namespace Item
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;
+
+ // from SfxStringItem, was not implemented in CntUnencodedStringItem
+ void dumpAsXml(xmlTextWriterPtr pWriter) const override;
};
} // end of namespace Item
diff --git a/include/svl/itemiter.hxx b/include/svl/itemiter.hxx
index 913ca9cba0eb..437aa4896ee5 100644
--- a/include/svl/itemiter.hxx
+++ b/include/svl/itemiter.hxx
@@ -24,6 +24,15 @@
class SfxPoolItem;
+// I2TM notes:
+// SfxItemIter will check to not return nullptr, but it will *not* check
+// for other states of SfxPoolItem (see ::SfxItemIter and ::NextItem()),
+// thus it may
+// - return -1 -> invalid item -> SfxItemState::DONTCARE
+// - return SfxVoidItem* -> SfxItemState::DISABLED
+// - return a set item -> SfxItemState::SET
+// I see quite some usages that *do not care* for the returned ptr-value,
+// so these may stumble hard over de-referencing (-1) ptr's (!)
class SVL_DLLPUBLIC SfxItemIter
{
const SfxItemSet& m_rSet;
diff --git a/include/svl/itemset.hxx b/include/svl/itemset.hxx
index 453b571e0d41..6d48df063e1a 100644
--- a/include/svl/itemset.hxx
+++ b/include/svl/itemset.hxx
@@ -190,7 +190,7 @@ public:
void ClearInvalidItems();
void InvalidateAllItems(); // HACK(via nWhich = 0) ???
- inline void SetParent( const SfxItemSet* pNew );
+ void SetParent( const SfxItemSet* pNew );
// add, delete items, work on items
public:
@@ -242,11 +242,6 @@ public:
// ~I2TM
};
-inline void SfxItemSet::SetParent( const SfxItemSet* pNew )
-{
- m_pParent = pNew;
-}
-
class SVL_DLLPUBLIC SfxAllItemSet: public SfxItemSet
// Handles all Ranges. Ranges are automatically modified by putting items.
diff --git a/item/source/base/ItemBase.cxx b/item/source/base/ItemBase.cxx
index 1b6175c7f44e..7ef54fc11c50 100644
--- a/item/source/base/ItemBase.cxx
+++ b/item/source/base/ItemBase.cxx
@@ -103,6 +103,16 @@ namespace Item
return true;
}
+ bool ItemBase::isInvalidateItem() const
+ {
+ return false;
+ }
+
+ bool ItemBase::isDisableItem() const
+ {
+ return false;
+ }
+
bool ItemBase::putAnyValue(const css::uno::Any& /*rVal*/, sal_uInt8 /*nMemberId*/)
{
// default has nothing to to
diff --git a/item/source/base/ItemSet.cxx b/item/source/base/ItemSet.cxx
index bdf72a52d6cc..554a46cfec07 100644
--- a/item/source/base/ItemSet.cxx
+++ b/item/source/base/ItemSet.cxx
@@ -21,37 +21,53 @@ namespace Item
return aItemControlBlock;
}
- // single global static instance for helper class ImplInvalidateItem
- static const ItemBase& getInvalidateItem()
+ // helper class for an ImplInvalidateItem - placeholder for InvaidateState
+ // SfxItemState::DONTCARE -> IsInvalidItem -> pItem == INVALID_POOL_ITEM -> reinterpret_cast<SfxPoolItem*>(-1)
+ // instances of this class are *never* returned in any way or helper data struture,
+ // but are *strictly* local. Thus also need no 'static ItemControlBlock& GetStaticItemControlBlock()' (for now)
+ class ImplInvalidateItem : public ItemBase
{
- // helper class for an ImplInvalidateItem - placeholder for InvaidateState
- // SfxItemState::DONTCARE -> IsInvalidItem -> pItem == INVALID_POOL_ITEM -> reinterpret_cast<SfxPoolItem*>(-1)
- class ImplInvalidateItem : public ItemBase
+ private:
+ const ItemBase& m_rItemDefault;
+
+ public:
+ ImplInvalidateItem(const ItemBase& rItemDefault)
+ : ItemBase(getEmptyStaticItemControlBlock()),
+ m_rItemDefault(rItemDefault)
{
- public:
- ImplInvalidateItem() : ItemBase(getEmptyStaticItemControlBlock()) {}
- virtual std::unique_ptr<ItemBase> clone() const { return std::make_unique<ImplInvalidateItem>(); }
- };
+ }
- static const ImplInvalidateItem aImplInvalidateItem;
- return aImplInvalidateItem;
- }
+ virtual bool isInvalidateItem() const override
+ {
+ return true;
+ }
- // single global static instance for helper class ImplDisableItem
- static const ItemBase& getDisableItem()
+ const ItemBase& getItemDefault() const { return m_rItemDefault; }
+ };
+
+ // helper class for a ImplDisableItem - placeholder for InvaidateState
+ // SfxItemState::DISABLED -> IsVoidItem() -> instance of SfxVoidItem, virtual bool IsVoidItem()
+ // instances of this class are *never* returned in any way or helper data struture,
+ // but are *strictly* local. Thus also need no 'static ItemControlBlock& GetStaticItemControlBlock()' (for now)
+ class ImplDisableItem : public ItemBase
{
- // helper class for a ImplDisableItem - placeholder for InvaidateState
- // SfxItemState::DISABLED -> IsVoidItem() -> instance of SfxVoidItem, virtual bool IsVoidItem()
- class ImplDisableItem : public ItemBase
+ private:
+ const ItemBase& m_rItemDefault;
+
+ public:
+ ImplDisableItem(const ItemBase& rItemDefault)
+ : ItemBase(getEmptyStaticItemControlBlock()),
+ m_rItemDefault(rItemDefault)
{
- public:
- ImplDisableItem() : ItemBase(getEmptyStaticItemControlBlock()) {}
- virtual std::unique_ptr<ItemBase> clone() const { return std::make_unique<ImplDisableItem>(); }
- };
+ }
- static const ImplDisableItem aImplDisableItem;
- return aImplDisableItem;
- }
+ virtual bool isDisableItem() const override
+ {
+ return true;
+ }
+
+ const ItemBase& getItemDefault() const { return m_rItemDefault; }
+ };
const ItemBase* ItemSet::implGetStateAndItem(size_t hash_code, IState& rIState, bool bSearchParent) const
{
@@ -61,18 +77,18 @@ namespace Item
{
assert(nullptr != aRetval->second && "empty const ItemBase* in ItemSet (!)");
- if(aRetval->second == &getInvalidateItem())
+ if(aRetval->second->isInvalidateItem())
{
// SfxItemState::DONTCARE
rIState = IState::DONTCARE;
- return nullptr;
+ return &static_cast<const ImplInvalidateItem*>(aRetval->second)->getItemDefault();
}
- if(aRetval->second == &getDisableItem())
+ if(aRetval->second->isDisableItem())
{
// SfxItemState::DISABLED
rIState = IState::DISABLED;
- return nullptr;
+ return &static_cast<const ImplDisableItem*>(aRetval->second)->getItemDefault();
}
// SfxItemState::SET
@@ -92,33 +108,33 @@ namespace Item
return nullptr;
}
- void ItemSet::implInvalidateItem(size_t hash_code)
+ void ItemSet::implInvalidateItem(size_t hash_code, const ItemBase& rItemDefault)
{
const auto aRetval(m_aItems.find(hash_code));
if(aRetval == m_aItems.end())
{
- m_aItems[hash_code] = &getInvalidateItem();
+ m_aItems[hash_code] = new ImplInvalidateItem(rItemDefault);
}
else
{
delete aRetval->second;
- aRetval->second = &getInvalidateItem();
+ aRetval->second = new ImplInvalidateItem(rItemDefault);
}
}
- void ItemSet::implDisableItem(size_t hash_code)
+ void ItemSet::implDisableItem(size_t hash_code, const ItemBase& rItemDefault)
{
const auto aRetval(m_aItems.find(hash_code));
if(aRetval == m_aItems.end())
{
- m_aItems[hash_code] = &getDisableItem();
+ m_aItems[hash_code] = new ImplDisableItem(rItemDefault);
}
else
{
delete aRetval->second;
- aRetval->second = &getDisableItem();
+ aRetval->second = new ImplDisableItem(rItemDefault);
}
}
@@ -207,7 +223,7 @@ namespace Item
assert(nullptr != candidate.second && "empty const ItemBase* not allowed (!)");
const ItemBase* pNew(nullptr);
- if(candidate.second == &getInvalidateItem())
+ if(candidate.second->isInvalidateItem())
{
if(bDontCareToDefault)
{
@@ -217,13 +233,13 @@ namespace Item
else
{
// prepare SfxItemState::DONTCARE
- pNew = &getInvalidateItem();
+ pNew = new ImplInvalidateItem(static_cast<const ImplInvalidateItem*>(candidate.second)->getItemDefault());
}
}
- else if(candidate.second == &getDisableItem())
+ else if(candidate.second->isDisableItem())
{
// prepare SfxItemState::DISABLED
- pNew = &getDisableItem();
+ pNew = new ImplDisableItem(static_cast<const ImplDisableItem*>(candidate.second)->getItemDefault());
}
else
{
@@ -251,6 +267,70 @@ namespace Item
}
}
}
+
+ std::vector<std::pair<const ItemBase*, ItemSet::IState>> ItemSet::getAllItemsAndStates() const
+ {
+ std::vector<std::pair<const ItemBase*, ItemSet::IState>> aRetval;
+
+ if(!m_aItems.empty())
+ {
+ aRetval.reserve(m_aItems.size());
+
+ for(const auto& candidate : m_aItems)
+ {
+ if(candidate.second->isInvalidateItem())
+ {
+ aRetval.push_back(std::pair<const ItemBase*, ItemSet::IState>(
+ &static_cast<const ImplInvalidateItem*>(candidate.second)->getItemDefault(),
+ IState::DONTCARE));
+ }
+ else if(candidate.second->isDisableItem())
+ {
+ aRetval.push_back(std::pair<const ItemBase*, ItemSet::IState>(
+ &static_cast<const ImplDisableItem*>(candidate.second)->getItemDefault(),
+ IState::DISABLED));
+ }
+ else
+ {
+ aRetval.push_back(std::pair<const ItemBase*, ItemSet::IState>(
+ candidate.second,
+ IState::SET));
+ }
+ }
+ }
+
+ return aRetval;
+ }
+
+ std::vector<const ItemBase*> ItemSet::getItemsOfState(IState eIState) const
+ {
+ assert((IState::SET == eIState || IState::DISABLED == eIState || IState::DONTCARE == eIState)
+ && "only IStates SET/DISBALE/DONTCALE allowed (!)");
+ std::vector<const ItemBase*> aRetval;
+
+ if(!m_aItems.empty())
+ {
+ aRetval.reserve(m_aItems.size());
+
+ for(const auto& candidate : m_aItems)
+ {
+ if(IState::DONTCARE == eIState && candidate.second->isInvalidateItem())
+ {
+ aRetval.push_back(&static_cast<const ImplInvalidateItem*>(candidate.second)->getItemDefault());
+ }
+ else if(IState::DISABLED == eIState && candidate.second->isDisableItem())
+ {
+ aRetval.push_back(&static_cast<const ImplDisableItem*>(candidate.second)->getItemDefault());
+ }
+ else if(IState::SET == eIState)
+ {
+ aRetval.push_back(candidate.second);
+ }
+ }
+ }
+
+ return aRetval;
+ }
} // end of namespace Item
///////////////////////////////////////////////////////////////////////////////
diff --git a/item/source/simple/CntOUString.cxx b/item/source/simple/CntOUString.cxx
index ba397337dc11..c77b31369ef3 100644
--- a/item/source/simple/CntOUString.cxx
+++ b/item/source/simple/CntOUString.cxx
@@ -10,6 +10,7 @@
#include <item/simple/CntOUString.hxx>
#include <item/base/ItemControlBlock.hxx>
#include <item/base/ItemAdministrator.hxx>
+#include <libxml/xmlwriter.h>
#include <cassert>
///////////////////////////////////////////////////////////////////////////////
@@ -103,6 +104,13 @@ namespace Item
assert(false && "CntOUString::putAnyValue - Wrong type!");
return false;
}
+
+ void CntOUString::dumpAsXml(xmlTextWriterPtr pWriter) const
+ {
+ xmlTextWriterStartElement(pWriter, BAD_CAST("CntOUString"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(getValue().toUtf8().getStr()));
+ xmlTextWriterEndElement(pWriter);
+ }
} // end of namespace Item
///////////////////////////////////////////////////////////////////////////////
diff --git a/item/test/ItemTest.cxx b/item/test/ItemTest.cxx
index 1347bd775ddb..44de5be83cbc 100644
--- a/item/test/ItemTest.cxx
+++ b/item/test/ItemTest.cxx
@@ -1698,6 +1698,107 @@ namespace Item
}
}
+ void checkInvalidateAndDisableItem()
+ {
+ static bool bLoop(false);
+ while(bLoop)
+ {
+ bLoop = true;
+ }
+
+ int nIncrement(0);
+ ModelSpecificItemValues::SharedPtr aModelSpecificIValues(
+ ModelSpecificItemValues::create(
+ MapUnit::Map100thMM
+ ));
+
+ // create and play with ItemSet
+ ItemSet::SharedPtr aSetA(ItemSet::create(aModelSpecificIValues));
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->setItem(CntOUString_derived("StringStuff"));
+ aSetA->setItem(CntInt16_derived(22));
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->invalidateItem<CntInt16_derived>();
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->invalidateItem<CntOUString_derived>();
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->setItem(CntOUString_derived("NewText"));
+ aSetA->setItem(CntInt16_derived(4422));
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->disableItem<CntInt16_derived>();
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->disableItem<CntOUString_derived>();
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->setItem(CntOUString_derived("NewText"));
+ aSetA->setItem(CntInt16_derived(4422));
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+
+ aSetA->invalidateItem<CntOUString_derived>();
+ aSetA->disableItem<CntInt16_derived>();
+
+ { auto aActA = aSetA->getStateAndItem<CntInt16_derived>(); if(aActA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aStrA = aSetA->getStateAndItem<CntOUString_derived>(); if(aStrA.getIState() == ItemSet::IState::SET) nIncrement++;
+ auto aVecA = aSetA->getAllItemsAndStates(); if(aVecA.size() > 0) nIncrement++;
+ auto aItemsSETA = aSetA->getItemsOfState(ItemSet::IState::SET); if(aItemsSETA.size() > 0) nIncrement++;
+ auto aItemsDISA = aSetA->getItemsOfState(ItemSet::IState::DISABLED); if(aItemsDISA.size() > 0) nIncrement++;
+ auto aItemsDNTA = aSetA->getItemsOfState(ItemSet::IState::DONTCARE); if(aItemsDNTA.size() > 0) nIncrement++; }
+ }
+
// Change the following lines only, if you add, remove or rename
// member functions of the current class,
// because these macros are need by auto register mechanism.
@@ -1716,6 +1817,7 @@ namespace Item
CPPUNIT_TEST(checkSimpleItems);
CPPUNIT_TEST(checkSimpleItemsAtISet);
CPPUNIT_TEST(checkItem2);
+ CPPUNIT_TEST(checkInvalidateAndDisableItem);
CPPUNIT_TEST_SUITE_END();
};
} // end of namespace Item
diff --git a/svl/source/items/itemset.cxx b/svl/source/items/itemset.cxx
index f301cf374ad7..8d6323ef7af7 100644
--- a/svl/source/items/itemset.cxx
+++ b/svl/source/items/itemset.cxx
@@ -183,9 +183,9 @@ SfxItemSet::SfxItemSet( const SfxItemSet& rASet )
: m_pPool( rASet.m_pPool )
, m_pParent( rASet.m_pParent )
, m_nCount( rASet.m_nCount )
-// I2TM copy shared ptrs - no clone
+ // I2TM copy shared ptrs - no clone
, m_aItemSetSharedPtr(rASet.m_aItemSetSharedPtr)
-// ~I2TM
+ // ~I2TM
{
// Calculate the attribute count
sal_uInt16 nCnt = 0;
@@ -374,6 +374,25 @@ void SfxItemSet::InvalidateAllItems()
memset(static_cast<void*>(m_pItems.get()), -1, m_nCount * sizeof(SfxPoolItem*));
}
+void SfxItemSet::SetParent( const SfxItemSet* pNew )
+{
+ m_pParent = pNew;
+ // I2TM Transfer phase:
+ if(m_aItemSetSharedPtr)
+ {
+ if(nullptr == pNew)
+ {
+ m_aItemSetSharedPtr->setParent(Item::ItemSet::SharedPtr());
+ }
+ else
+ {
+ pNew->itemSet(); // access to evtl. create
+ m_aItemSetSharedPtr->setParent(pNew->m_aItemSetSharedPtr);
+ }
+ }
+ // ~I2TM
+}
+
SfxItemState SfxItemSet::GetItemState( sal_uInt16 nWhich,
bool bSrchInParent,
const SfxPoolItem **ppItem ) const
@@ -541,9 +560,9 @@ bool SfxItemSet::Put( const SfxItemSet& rSet, bool bInvalidAsDefault )
}
}
-// I2TM
+ // I2TM
itemSet().setItems(rSet.itemSet(), bInvalidAsDefault);
-// ~I2TM
+ // ~I2TM
return bRet;
}
@@ -1481,6 +1500,19 @@ void SfxItemSet::dumpAsXml(xmlTextWriterPtr pWriter) const
SfxItemIter aIter(*this);
for (const SfxPoolItem* pItem = aIter.FirstItem(); pItem; pItem = aIter.NextItem())
pItem->dumpAsXml(pWriter);
+
+ // I2TM Transfer phase:
+ if(m_aItemSetSharedPtr)
+ {
+ // dumpAsXml adaption: Use all IState::SET, see comments at include\svl\itemiter.hxx for I2TM
+ const std::vector<const Item::ItemBase*> aAllSetItems(m_aItemSetSharedPtr->getItemsOfState(Item::ItemSet::IState::SET));
+ for(const auto& candidate : aAllSetItems)
+ {
+ candidate->dumpAsXml(pWriter);
+ }
+ }
+ // ~I2TM
+
xmlTextWriterEndElement(pWriter);
}
More information about the Libreoffice-commits
mailing list