sw/source/core/doc/list.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: list.cxx,v $
  10  * $Revision: 1.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sw.hxx"
  32
  33 #include <list.hxx>
  34
  35 #include <vector>
  36 #include <numrule.hxx>
  37 #include <ndarr.hxx>
  38 #include <node.hxx>
  39 #include <pam.hxx>
  40 #include <SwNodeNum.hxx>
  41
  42 // ----------------------------------------------------------------------------
  43 // SwListImpl
  44 // implementation class for SwList
  45 // ----------------------------------------------------------------------------
  46 class SwListImpl
  47 {
  48     public:
  49         SwListImpl( const String sListId,
  50                     SwNumRule& rDefaultListStyle,
  51                     const SwNodes& rNodes );
  52         ~SwListImpl();
  53
  54         const String GetListId() const;
  55
  56         const String GetDefaultListStyleName() const;
  57
  58         void InsertListItem( SwNodeNum& rNodeNum,
  59                              const int nLevel );
  60         void RemoveListItem( SwNodeNum& rNodeNum );
  61
  62         void InvalidateListTree();
  63         void ValidateListTree();
  64
  65         void MarkListLevel( const int nListLevel,
  66                             const BOOL bValue );
  67
  68         bool IsListLevelMarked( const int nListLevel ) const;
  69
  70     private:
  71         // unique identifier of the list
  72         const String msListId;
  73         // default list style for the list items, identified by the list style name
  74         String msDefaultListStyleName;
  75
  76         // list trees for certain document ranges
  77         typedef std::pair<SwNodeNum*, SwPaM*> tListTreeForRange;
  78         typedef std::vector<tListTreeForRange> tListTrees;
  79         tListTrees maListTrees;
  80
  81         int mnMarkedListLevel;
  82
  83         void NotifyItemsOnListLevel( const int nLevel );
  84 };
  85
  86 SwListImpl::SwListImpl( const String sListId,
  87                         SwNumRule& rDefaultListStyle,
  88                         const SwNodes& rNodes )
  89     : msListId( sListId ),
  90       msDefaultListStyleName( rDefaultListStyle.GetName() ),
  91       maListTrees(),
  92       mnMarkedListLevel( MAXLEVEL )
  93 {
  94     // create empty list trees for the document ranges
  95     const SwNode* pNode = rNodes[0];
  96     do
  97     {
  98         SwPaM aPam( *pNode, *pNode->EndOfSectionNode() );
  99
 100         SwNodeNum* pNumberTreeRootNode = new SwNodeNum( &rDefaultListStyle );
 101         SwPaM* pPam = new SwPaM( *(aPam.Start()), *(aPam.End()) );
 102         tListTreeForRange aListTreeForRange( pNumberTreeRootNode, pPam );
 103         maListTrees.push_back( aListTreeForRange );
 104
 105         pNode = pNode->EndOfSectionNode();
 106         if (pNode != &rNodes.GetEndOfContent())
 107         {
 108             ULONG nIndex = pNode->GetIndex();
 109             nIndex++;
 110             pNode = rNodes[nIndex];
 111         }
 112     }
 113     while ( pNode != &rNodes.GetEndOfContent() );
 114 }
 115
 116 SwListImpl::~SwListImpl()
 117 {
 118     tListTrees::iterator aNumberTreeIter;
 119     for ( aNumberTreeIter = maListTrees.begin();
 120           aNumberTreeIter != maListTrees.end();
 121           ++aNumberTreeIter )
 122     {
 123         SwNodeNum::HandleNumberTreeRootNodeDelete( *((*aNumberTreeIter).first) );
 124         delete (*aNumberTreeIter).first;
 125         delete (*aNumberTreeIter).second;
 126     }
 127 }
 128
 129 const String SwListImpl::GetListId() const
 130 {
 131     return msListId;
 132 }
 133
 134 const String SwListImpl::GetDefaultListStyleName() const
 135 {
 136     return msDefaultListStyleName;
 137 }
 138
 139 void SwListImpl::InsertListItem( SwNodeNum& rNodeNum,
 140                                  const int nLevel )
 141 {
 142     const SwPosition aPosOfNodeNum( rNodeNum.GetPosition() );
 143     const SwNodes* pNodesOfNodeNum = &(aPosOfNodeNum.nNode.GetNode().GetNodes());
 144
 145     tListTrees::const_iterator aNumberTreeIter;
 146     for ( aNumberTreeIter = maListTrees.begin();
 147           aNumberTreeIter != maListTrees.end();
 148           ++aNumberTreeIter )
 149     {
 150         const SwPosition* pStart = (*aNumberTreeIter).second->Start();
 151         const SwPosition* pEnd = (*aNumberTreeIter).second->End();
 152         const SwNodes* pRangeNodes = &(pStart->nNode.GetNode().GetNodes());
 153
 154         if ( pRangeNodes == pNodesOfNodeNum &&
 155              *pStart <= aPosOfNodeNum && aPosOfNodeNum <= *pEnd)
 156         {
 157             (*aNumberTreeIter).first->AddChild( &rNodeNum, nLevel );
 158
 159             break;
 160         }
 161     }
 162 }
 163
 164 void SwListImpl::RemoveListItem( SwNodeNum& rNodeNum )
 165 {
 166     rNodeNum.RemoveMe();
 167 }
 168
 169 void SwListImpl::InvalidateListTree()
 170 {
 171     tListTrees::iterator aNumberTreeIter;
 172     for ( aNumberTreeIter = maListTrees.begin();
 173           aNumberTreeIter != maListTrees.end();
 174           ++aNumberTreeIter )
 175     {
 176         (*aNumberTreeIter).first->InvalidateTree();
 177     }
 178 }
 179
 180 void SwListImpl::ValidateListTree()
 181 {
 182     tListTrees::iterator aNumberTreeIter;
 183     for ( aNumberTreeIter = maListTrees.begin();
 184           aNumberTreeIter != maListTrees.end();
 185           ++aNumberTreeIter )
 186     {
 187         (*aNumberTreeIter).first->NotifyInvalidChildren();
 188     }
 189 }
 190
 191 void SwListImpl::MarkListLevel( const int nListLevel,
 192                                 const BOOL bValue )
 193 {
 194     if ( bValue )
 195     {
 196         if ( nListLevel != mnMarkedListLevel )
 197         {
 198             if ( mnMarkedListLevel != MAXLEVEL )
 199             {
 200                 // notify former marked list nodes
 201                 NotifyItemsOnListLevel( mnMarkedListLevel );
 202             }
 203
 204             mnMarkedListLevel = nListLevel;
 205
 206             // notify new marked list nodes
 207             NotifyItemsOnListLevel( mnMarkedListLevel );
 208         }
 209     }
 210     else
 211     {
 212         if ( mnMarkedListLevel != MAXLEVEL )
 213         {
 214             // notify former marked list nodes
 215             NotifyItemsOnListLevel( mnMarkedListLevel );
 216         }
 217
 218         mnMarkedListLevel = MAXLEVEL;
 219     }
 220 }
 221
 222 bool SwListImpl::IsListLevelMarked( const int nListLevel ) const
 223 {
 224     return nListLevel == mnMarkedListLevel;
 225 }
 226
 227 void SwListImpl::NotifyItemsOnListLevel( const int nLevel )
 228 {
 229     tListTrees::iterator aNumberTreeIter;
 230     for ( aNumberTreeIter = maListTrees.begin();
 231           aNumberTreeIter != maListTrees.end();
 232           ++aNumberTreeIter )
 233     {
 234         (*aNumberTreeIter).first->NotifyNodesOnListLevel( nLevel );
 235     }
 236 }
 237
 238 // ----------------------------------------------------------------------------
 239 // SwList
 240 // ----------------------------------------------------------------------------
 241 SwList::SwList( const String sListId,
 242                 SwNumRule& rDefaultListStyle,
 243                 const SwNodes& rNodes )
 244     : mpListImpl( new SwListImpl( sListId, rDefaultListStyle, rNodes ) )
 245 {
 246 }
 247
 248 SwList::~SwList()
 249 {
 250     delete mpListImpl;
 251 }
 252
 253 const String SwList::GetListId() const
 254 {
 255     return mpListImpl->GetListId();
 256 }
 257
 258 const String SwList::GetDefaultListStyleName() const
 259 {
 260     return mpListImpl->GetDefaultListStyleName();
 261 }
 262
 263 void SwList::InsertListItem( SwNodeNum& rNodeNum,
 264                              const int nLevel )
 265 {
 266     mpListImpl->InsertListItem( rNodeNum, nLevel );
 267 }
 268
 269 void SwList::RemoveListItem( SwNodeNum& rNodeNum )
 270 {
 271     mpListImpl->RemoveListItem( rNodeNum );
 272 }
 273
 274 void SwList::InvalidateListTree()
 275 {
 276     mpListImpl->InvalidateListTree();
 277 }
 278
 279 void SwList::ValidateListTree()
 280 {
 281     mpListImpl->ValidateListTree();
 282 }
 283
 284 void SwList::MarkListLevel( const int nListLevel,
 285                                   const BOOL bValue )
 286 {
 287     mpListImpl->MarkListLevel( nListLevel, bValue );
 288 }
 289
 290 bool SwList::IsListLevelMarked( const int nListLevel ) const
 291 {
 292     return mpListImpl->IsListLevelMarked( nListLevel );
 293 }
 294
 295 //void SwList::ContinueList( SwList& rList )
 296 //{
 297 //    mpListImpl->ContinueList( rList );
 298 //}
 299 //const SwList* SwList::GetContinuedList() const
 300 //{
 301 //    return mpListImpl->GetContinuedList();
 302 //}
 303 //void SwList::ClearContinuation()
 304 //{
 305 //    mpListImpl->ClearContinuation();
 306 //}