sw/source/core/doc/list.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
  21 #include <list.hxx>
  22
  23 #include <vector>
  24 #include <numrule.hxx>
  25 #include <ndarr.hxx>
  26 #include <node.hxx>
  27 #include <pam.hxx>
  28 #include <SwNodeNum.hxx>
  29
  30 // implementation class for SwList
  31 class SwListImpl
  32 {
  33     public:
  34         SwListImpl( const String sListId,
  35                     SwNumRule& rDefaultListStyle,
  36                     const SwNodes& rNodes );
  37         ~SwListImpl();
  38
  39         const String GetListId() const;
  40
  41         const String GetDefaultListStyleName() const;
  42
  43         void InsertListItem( SwNodeNum& rNodeNum,
  44                              const int nLevel );
  45         void RemoveListItem( SwNodeNum& rNodeNum );
  46
  47         void InvalidateListTree();
  48         void ValidateListTree();
  49
  50         void MarkListLevel( const int nListLevel,
  51                             const bool bValue );
  52
  53         bool IsListLevelMarked( const int nListLevel ) const;
  54
  55     private:
  56         // unique identifier of the list
  57         const String msListId;
  58         // default list style for the list items, identified by the list style name
  59         String msDefaultListStyleName;
  60
  61         // list trees for certain document ranges
  62         typedef std::pair<SwNodeNum*, SwPaM*> tListTreeForRange;
  63         typedef std::vector<tListTreeForRange> tListTrees;
  64         tListTrees maListTrees;
  65
  66         int mnMarkedListLevel;
  67
  68         void NotifyItemsOnListLevel( const int nLevel );
  69 };
  70
  71 SwListImpl::SwListImpl( const String sListId,
  72                         SwNumRule& rDefaultListStyle,
  73                         const SwNodes& rNodes )
  74     : msListId( sListId ),
  75       msDefaultListStyleName( rDefaultListStyle.GetName() ),
  76       maListTrees(),
  77       mnMarkedListLevel( MAXLEVEL )
  78 {
  79     // create empty list trees for the document ranges
  80     const SwNode* pNode = rNodes[0];
  81     do
  82     {
  83         SwPaM aPam( *pNode, *pNode->EndOfSectionNode() );
  84
  85         SwNodeNum* pNumberTreeRootNode = new SwNodeNum( &rDefaultListStyle );
  86         SwPaM* pPam = new SwPaM( *(aPam.Start()), *(aPam.End()) );
  87         tListTreeForRange aListTreeForRange( pNumberTreeRootNode, pPam );
  88         maListTrees.push_back( aListTreeForRange );
  89
  90         pNode = pNode->EndOfSectionNode();
  91         if (pNode != &rNodes.GetEndOfContent())
  92         {
  93             sal_uLong nIndex = pNode->GetIndex();
  94             nIndex++;
  95             pNode = rNodes[nIndex];
  96         }
  97     }
  98     while ( pNode != &rNodes.GetEndOfContent() );
  99 }
 100
 101 SwListImpl::~SwListImpl()
 102 {
 103     tListTrees::iterator aNumberTreeIter;
 104     for ( aNumberTreeIter = maListTrees.begin();
 105           aNumberTreeIter != maListTrees.end();
 106           ++aNumberTreeIter )
 107     {
 108         SwNodeNum::HandleNumberTreeRootNodeDelete( *((*aNumberTreeIter).first) );
 109         delete (*aNumberTreeIter).first;
 110         delete (*aNumberTreeIter).second;
 111     }
 112 }
 113
 114 const String SwListImpl::GetListId() const
 115 {
 116     return msListId;
 117 }
 118
 119 const String SwListImpl::GetDefaultListStyleName() const
 120 {
 121     return msDefaultListStyleName;
 122 }
 123
 124 void SwListImpl::InsertListItem( SwNodeNum& rNodeNum,
 125                                  const int nLevel )
 126 {
 127     const SwPosition aPosOfNodeNum( rNodeNum.GetPosition() );
 128     const SwNodes* pNodesOfNodeNum = &(aPosOfNodeNum.nNode.GetNode().GetNodes());
 129
 130     tListTrees::const_iterator aNumberTreeIter;
 131     for ( aNumberTreeIter = maListTrees.begin();
 132           aNumberTreeIter != maListTrees.end();
 133           ++aNumberTreeIter )
 134     {
 135         const SwPosition* pStart = (*aNumberTreeIter).second->Start();
 136         const SwPosition* pEnd = (*aNumberTreeIter).second->End();
 137         const SwNodes* pRangeNodes = &(pStart->nNode.GetNode().GetNodes());
 138
 139         if ( pRangeNodes == pNodesOfNodeNum &&
 140              *pStart <= aPosOfNodeNum && aPosOfNodeNum <= *pEnd)
 141         {
 142             (*aNumberTreeIter).first->AddChild( &rNodeNum, nLevel );
 143
 144             break;
 145         }
 146     }
 147 }
 148
 149 void SwListImpl::RemoveListItem( SwNodeNum& rNodeNum )
 150 {
 151     rNodeNum.RemoveMe();
 152 }
 153
 154 void SwListImpl::InvalidateListTree()
 155 {
 156     tListTrees::iterator aNumberTreeIter;
 157     for ( aNumberTreeIter = maListTrees.begin();
 158           aNumberTreeIter != maListTrees.end();
 159           ++aNumberTreeIter )
 160     {
 161         (*aNumberTreeIter).first->InvalidateTree();
 162     }
 163 }
 164
 165 void SwListImpl::ValidateListTree()
 166 {
 167     tListTrees::iterator aNumberTreeIter;
 168     for ( aNumberTreeIter = maListTrees.begin();
 169           aNumberTreeIter != maListTrees.end();
 170           ++aNumberTreeIter )
 171     {
 172         (*aNumberTreeIter).first->NotifyInvalidChildren();
 173     }
 174 }
 175
 176 void SwListImpl::MarkListLevel( const int nListLevel,
 177                                 const bool bValue )
 178 {
 179     if ( bValue )
 180     {
 181         if ( nListLevel != mnMarkedListLevel )
 182         {
 183             if ( mnMarkedListLevel != MAXLEVEL )
 184             {
 185                 // notify former marked list nodes
 186                 NotifyItemsOnListLevel( mnMarkedListLevel );
 187             }
 188
 189             mnMarkedListLevel = nListLevel;
 190
 191             // notify new marked list nodes
 192             NotifyItemsOnListLevel( mnMarkedListLevel );
 193         }
 194     }
 195     else
 196     {
 197         if ( mnMarkedListLevel != MAXLEVEL )
 198         {
 199             // notify former marked list nodes
 200             NotifyItemsOnListLevel( mnMarkedListLevel );
 201         }
 202
 203         mnMarkedListLevel = MAXLEVEL;
 204     }
 205 }
 206
 207 bool SwListImpl::IsListLevelMarked( const int nListLevel ) const
 208 {
 209     return nListLevel == mnMarkedListLevel;
 210 }
 211
 212 void SwListImpl::NotifyItemsOnListLevel( const int nLevel )
 213 {
 214     tListTrees::iterator aNumberTreeIter;
 215     for ( aNumberTreeIter = maListTrees.begin();
 216           aNumberTreeIter != maListTrees.end();
 217           ++aNumberTreeIter )
 218     {
 219         (*aNumberTreeIter).first->NotifyNodesOnListLevel( nLevel );
 220     }
 221 }
 222
 223 // SwList ---------------------------------------------------------------------
 224 SwList::SwList( const String sListId,
 225                 SwNumRule& rDefaultListStyle,
 226                 const SwNodes& rNodes )
 227     : mpListImpl( new SwListImpl( sListId, rDefaultListStyle, rNodes ) )
 228 {
 229 }
 230
 231 SwList::~SwList()
 232 {
 233     delete mpListImpl;
 234 }
 235
 236 const String SwList::GetListId() const
 237 {
 238     return mpListImpl->GetListId();
 239 }
 240
 241 const String SwList::GetDefaultListStyleName() const
 242 {
 243     return mpListImpl->GetDefaultListStyleName();
 244 }
 245
 246 void SwList::InsertListItem( SwNodeNum& rNodeNum,
 247                              const int nLevel )
 248 {
 249     mpListImpl->InsertListItem( rNodeNum, nLevel );
 250 }
 251
 252 void SwList::RemoveListItem( SwNodeNum& rNodeNum )
 253 {
 254     mpListImpl->RemoveListItem( rNodeNum );
 255 }
 256
 257 void SwList::InvalidateListTree()
 258 {
 259     mpListImpl->InvalidateListTree();
 260 }
 261
 262 void SwList::ValidateListTree()
 263 {
 264     mpListImpl->ValidateListTree();
 265 }
 266
 267 void SwList::MarkListLevel( const int nListLevel,
 268                                   const bool bValue )
 269 {
 270     mpListImpl->MarkListLevel( nListLevel, bValue );
 271 }
 272
 273 bool SwList::IsListLevelMarked( const int nListLevel ) const
 274 {
 275     return mpListImpl->IsListLevelMarked( nListLevel );
 276 }
 277
 278 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */