svtools/source/contnr/treelistentry.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "svtools/treelistentry.hxx"
  21 #include "svtools/treelist.hxx"
  22
  23 #include <limits>
  24
  25 size_t SvTreeListEntry::ITEM_NOT_FOUND = std::numeric_limits<size_t>::max();
  26
  27 void SvTreeListEntry::ClearChildren()
  28 {
  29     maChildren.clear();
  30 }
  31
  32 void SvTreeListEntry::SetListPositions()
  33 {
  34     SvTreeListEntries::iterator it = maChildren.begin(), itEnd = maChildren.end();
  35     sal_uLong nCur = 0;
  36     for (; it != itEnd; ++it)
  37     {
  38         SvTreeListEntry& rEntry = *it;
  39         rEntry.nListPos &= 0x80000000;
  40         rEntry.nListPos |= nCur;
  41         ++nCur;
  42     }
  43
  44     nListPos &= (~0x80000000); // remove the invalid bit.
  45 }
  46
  47 void SvTreeListEntry::InvalidateChildrensListPositions()
  48 {
  49     nListPos |= 0x80000000;
  50 }
  51
  52 SvTreeListEntry::SvTreeListEntry() :
  53     pParent(NULL),
  54     nAbsPos(0),
  55     nListPos(0),
  56     pUserData(NULL),
  57     nEntryFlags(0)
  58 {
  59 }
  60
  61 SvTreeListEntry::SvTreeListEntry(const SvTreeListEntry& r) :
  62     pParent(NULL),
  63     nAbsPos(r.nAbsPos),
  64     nListPos(r.nListPos & 0x7FFFFFFF)
  65 {
  66     SvTreeListEntries::const_iterator it = r.maChildren.begin(), itEnd = r.maChildren.end();
  67     for (; it != itEnd; ++it)
  68         maChildren.push_back(new SvTreeListEntry(*it));
  69 }
  70
  71 SvTreeListEntry::~SvTreeListEntry()
  72 {
  73 #ifdef DBG_UTIL
  74     pParent     = 0;
  75 #endif
  76
  77     maChildren.clear();
  78     maItems.clear();
  79 }
  80
  81 bool SvTreeListEntry::HasChildren() const
  82 {
  83     return !maChildren.empty();
  84 }
  85
  86 bool SvTreeListEntry::HasChildListPos() const
  87 {
  88     if( pParent && !(pParent->nListPos & 0x80000000) )
  89         return true;
  90     else return false;
  91 }
  92
  93 sal_uLong SvTreeListEntry::GetChildListPos() const
  94 {
  95     if( pParent && (pParent->nListPos & 0x80000000) )
  96         pParent->SetListPositions();
  97     return ( nListPos & 0x7fffffff );
  98 }
  99
 100 SvTreeListEntries& SvTreeListEntry::GetChildEntries()
 101 {
 102     return maChildren;
 103 }
 104
 105 const SvTreeListEntries& SvTreeListEntry::GetChildEntries() const
 106 {
 107     return maChildren;
 108 }
 109
 110 void SvTreeListEntry::Clone(SvTreeListEntry* pSource)
 111 {
 112     nListPos &= 0x80000000;
 113     nListPos |= ( pSource->nListPos & 0x7fffffff);
 114     nAbsPos     = pSource->nAbsPos;
 115
 116     SvLBoxItem* pNewItem;
 117     maItems.clear();
 118     ItemsType::iterator it = pSource->maItems.begin(), itEnd = pSource->maItems.end();
 119     for (; it != itEnd; ++it)
 120     {
 121         SvLBoxItem* pItem = &(*it);
 122         pNewItem = pItem->Create();
 123         pNewItem->Clone(pItem);
 124         maItems.push_back(pNewItem);
 125     }
 126
 127     pUserData = pSource->GetUserData();
 128     nEntryFlags = pSource->nEntryFlags;
 129 }
 130
 131 size_t SvTreeListEntry::ItemCount() const
 132 {
 133     return maItems.size();
 134 }
 135
 136 void SvTreeListEntry::AddItem( SvLBoxItem* pItem )
 137 {
 138     maItems.push_back( pItem );
 139 }
 140
 141 void SvTreeListEntry::EnableChildrenOnDemand( bool bEnable )
 142 {
 143     if ( bEnable )
 144         nEntryFlags |= SV_ENTRYFLAG_CHILDREN_ON_DEMAND;
 145     else
 146         nEntryFlags &= (~SV_ENTRYFLAG_CHILDREN_ON_DEMAND);
 147 }
 148
 149 void SvTreeListEntry::ReplaceItem( SvLBoxItem* pNewItem, size_t nPos )
 150 {
 151     DBG_ASSERT(pNewItem,"ReplaceItem:No Item");
 152     if (nPos >= maItems.size())
 153     {
 154         // Out of bound. Bail out.
 155         delete pNewItem;
 156         return;
 157     }
 158
 159     maItems.erase(maItems.begin()+nPos);
 160     maItems.insert(maItems.begin()+nPos, pNewItem);
 161 }
 162
 163 const SvLBoxItem* SvTreeListEntry::GetItem( size_t nPos ) const
 164 {
 165     return &maItems[nPos];
 166 }
 167
 168 SvLBoxItem* SvTreeListEntry::GetItem( size_t nPos )
 169 {
 170     return &maItems[nPos];
 171 }
 172
 173 namespace {
 174
 175 class FindByType : std::unary_function<SvLBoxItem, void>
 176 {
 177     sal_uInt16 mnId;
 178 public:
 179     FindByType(sal_uInt16 nId) : mnId(nId) {}
 180     bool operator() (const SvLBoxItem& rItem) const
 181     {
 182         return rItem.GetType() == mnId;
 183     }
 184 };
 185
 186 class FindByPointer : std::unary_function<SvLBoxItem, void>
 187 {
 188     const SvLBoxItem* mpItem;
 189 public:
 190     FindByPointer(const SvLBoxItem* p) : mpItem(p) {}
 191     bool operator() (const SvLBoxItem& rItem) const
 192     {
 193         return &rItem == mpItem;
 194     }
 195 };
 196
 197 }
 198
 199 const SvLBoxItem* SvTreeListEntry::GetFirstItem( sal_uInt16 nId ) const
 200 {
 201     ItemsType::const_iterator it = std::find_if(maItems.begin(), maItems.end(), FindByType(nId));
 202     return it == maItems.end() ? NULL : &(*it);
 203 }
 204
 205 SvLBoxItem* SvTreeListEntry::GetFirstItem( sal_uInt16 nId )
 206 {
 207     ItemsType::iterator it = std::find_if(maItems.begin(), maItems.end(), FindByType(nId));
 208     return it == maItems.end() ? NULL : &(*it);
 209 }
 210
 211 size_t SvTreeListEntry::GetPos( const SvLBoxItem* pItem ) const
 212 {
 213     ItemsType::const_iterator it = std::find_if(maItems.begin(), maItems.end(), FindByPointer(pItem));
 214     return it == maItems.end() ? ITEM_NOT_FOUND : std::distance(maItems.begin(), it);
 215 }
 216
 217 void* SvTreeListEntry::GetUserData() const
 218 {
 219     return pUserData;
 220 }
 221
 222 void SvTreeListEntry::SetUserData( void* pPtr )
 223 {
 224     pUserData = pPtr;
 225 }
 226
 227 bool SvTreeListEntry::HasChildrenOnDemand() const
 228 {
 229     return (bool)((nEntryFlags & SV_ENTRYFLAG_CHILDREN_ON_DEMAND)!=0);
 230 }
 231
 232 bool SvTreeListEntry::HasInUseEmphasis() const
 233 {
 234     return (bool)((nEntryFlags & SV_ENTRYFLAG_IN_USE)!=0);
 235 }
 236
 237 sal_uInt16 SvTreeListEntry::GetFlags() const
 238 {
 239     return nEntryFlags;
 240 }
 241
 242 void SvTreeListEntry::SetFlags( sal_uInt16 nFlags )
 243 {
 244     nEntryFlags = nFlags;
 245 }
 246
 247 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */