editeng/source/outliner/paralist.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 <paralist.hxx>
  22
  23 #include <editeng/outliner.hxx>
  24 #include <editeng/numdef.hxx>
  25
  26 #include <osl/diagnose.h>
  27 #include <tools/debug.hxx>
  28
  29 ParagraphData::ParagraphData()
  30 : nDepth( -1 )
  31 , mnNumberingStartValue( -1 )
  32 , mbParaIsNumberingRestart( false )
  33 {
  34 }
  35
  36 ParagraphData::ParagraphData( const ParagraphData& r )
  37 : nDepth( r.nDepth )
  38 , mnNumberingStartValue( r.mnNumberingStartValue )
  39 , mbParaIsNumberingRestart( r.mbParaIsNumberingRestart )
  40 {
  41 }
  42
  43 ParagraphData& ParagraphData::operator=( const ParagraphData& r)
  44 {
  45     nDepth = r.nDepth;
  46     mnNumberingStartValue = r.mnNumberingStartValue;
  47     mbParaIsNumberingRestart = r.mbParaIsNumberingRestart;
  48     return *this;
  49 }
  50
  51 bool ParagraphData::operator==(const ParagraphData& rCandidate) const
  52 {
  53     return (nDepth == rCandidate.nDepth
  54         && mnNumberingStartValue == rCandidate.mnNumberingStartValue
  55         && mbParaIsNumberingRestart == rCandidate.mbParaIsNumberingRestart);
  56 }
  57
  58 Paragraph::Paragraph( sal_Int16 nDDepth )
  59 : aBulSize( -1, -1)
  60 {
  61
  62     DBG_ASSERT(  ( nDDepth >= -1 ) && ( nDDepth < SVX_MAX_NUM ), "Paragraph-CTOR: nDepth invalid!" );
  63
  64     nDepth = nDDepth;
  65     nFlags = ParaFlag::NONE;
  66     bVisible = true;
  67 }
  68
  69 Paragraph::Paragraph( const ParagraphData& rData )
  70 : nFlags( ParaFlag::NONE )
  71 , aBulSize( -1, -1)
  72 , bVisible( true )
  73 {
  74     nDepth = rData.nDepth;
  75     mnNumberingStartValue = rData.mnNumberingStartValue;
  76     mbParaIsNumberingRestart = rData.mbParaIsNumberingRestart;
  77 }
  78
  79 Paragraph::~Paragraph()
  80 {
  81 }
  82
  83 void Paragraph::SetNumberingStartValue( sal_Int16 nNumberingStartValue )
  84 {
  85     mnNumberingStartValue = nNumberingStartValue;
  86     if( mnNumberingStartValue != -1 )
  87         mbParaIsNumberingRestart = true;
  88 }
  89
  90 void Paragraph::SetParaIsNumberingRestart( bool bParaIsNumberingRestart )
  91 {
  92     mbParaIsNumberingRestart = bParaIsNumberingRestart;
  93     if( !mbParaIsNumberingRestart )
  94         mnNumberingStartValue = -1;
  95 }
  96
  97 void ParagraphList::Clear( bool bDestroyParagraphs )
  98 {
  99     if ( bDestroyParagraphs )
 100     {
 101         std::vector<Paragraph*>::iterator iter;
 102         for (iter = maEntries.begin(); iter != maEntries.end(); ++iter)
 103             delete *iter;
 104     }
 105
 106     maEntries.clear();
 107 }
 108
 109 void ParagraphList::Append( Paragraph* pPara)
 110 {
 111     SAL_WARN_IF( maEntries.size() >= EE_PARA_MAX_COUNT, "editeng", "ParagraphList::Append - overflow");
 112     maEntries.push_back(pPara);
 113 }
 114
 115 void ParagraphList::Insert( Paragraph* pPara, sal_Int32 nAbsPos)
 116 {
 117     SAL_WARN_IF( nAbsPos < 0 || (maEntries.size() < static_cast<size_t>(nAbsPos) && nAbsPos != EE_PARA_APPEND),
 118             "editeng", "ParagraphList::Insert - bad insert position " << nAbsPos);
 119     SAL_WARN_IF( maEntries.size() >= EE_PARA_MAX_COUNT, "editeng", "ParagraphList::Insert - overflow");
 120
 121     if (nAbsPos < 0 || maEntries.size() <= static_cast<size_t>(nAbsPos))
 122         Append( pPara);
 123     else
 124         maEntries.insert(maEntries.begin()+nAbsPos,pPara);
 125 }
 126
 127 void ParagraphList::Remove( sal_Int32 nPara )
 128 {
 129     if (nPara < 0 || maEntries.size() <= static_cast<size_t>(nPara))
 130     {
 131         SAL_WARN( "editeng", "ParagraphList::Remove - out of bounds " << nPara);
 132         return;
 133     }
 134
 135     maEntries.erase(maEntries.begin() + nPara );
 136 }
 137
 138 void ParagraphList::MoveParagraphs( sal_Int32 nStart, sal_Int32 nDest, sal_Int32 _nCount )
 139 {
 140     OSL_ASSERT(static_cast<size_t>(nStart) < maEntries.size() && static_cast<size_t>(nDest) < maEntries.size());
 141
 142     if ( (( nDest < nStart ) || ( nDest >= ( nStart + _nCount ) )) && nStart >= 0 && nDest >= 0 && _nCount >= 0 )
 143     {
 144         std::vector<Paragraph*> aParas;
 145         std::vector<Paragraph*>::iterator iterBeg = maEntries.begin() + nStart;
 146         std::vector<Paragraph*>::iterator iterEnd = iterBeg + _nCount;
 147
 148         std::copy(iterBeg,iterEnd,std::back_inserter(aParas));
 149
 150         maEntries.erase(iterBeg,iterEnd);
 151
 152         if ( nDest > nStart )
 153             nDest -= _nCount;
 154
 155         std::vector<Paragraph*>::iterator iterIns = maEntries.begin() + nDest;
 156
 157         std::copy(aParas.begin(),aParas.end(),std::inserter(maEntries,iterIns));
 158     }
 159     else
 160     {
 161         OSL_FAIL( "MoveParagraphs: Invalid Parameters" );
 162     }
 163 }
 164
 165 bool ParagraphList::HasChildren( Paragraph* pParagraph ) const
 166 {
 167     sal_Int32 n = GetAbsPos( pParagraph );
 168     Paragraph* pNext = GetParagraph( ++n );
 169     return pNext && ( pNext->GetDepth() > pParagraph->GetDepth() );
 170 }
 171
 172 bool ParagraphList::HasHiddenChildren( Paragraph* pParagraph ) const
 173 {
 174     sal_Int32 n = GetAbsPos( pParagraph );
 175     Paragraph* pNext = GetParagraph( ++n );
 176     return pNext && ( pNext->GetDepth() > pParagraph->GetDepth() ) && !pNext->IsVisible();
 177 }
 178
 179 bool ParagraphList::HasVisibleChildren( Paragraph* pParagraph ) const
 180 {
 181     sal_Int32 n = GetAbsPos( pParagraph );
 182     Paragraph* pNext = GetParagraph( ++n );
 183     return pNext && ( pNext->GetDepth() > pParagraph->GetDepth() ) && pNext->IsVisible();
 184 }
 185
 186 sal_Int32 ParagraphList::GetChildCount( Paragraph* pParent ) const
 187 {
 188     sal_Int32 nChildCount = 0;
 189     sal_Int32 n = GetAbsPos( pParent );
 190     Paragraph* pPara = GetParagraph( ++n );
 191     while ( pPara && ( pPara->GetDepth() > pParent->GetDepth() ) )
 192     {
 193         nChildCount++;
 194         pPara = GetParagraph( ++n );
 195     }
 196     return nChildCount;
 197 }
 198
 199 Paragraph* ParagraphList::GetParent( Paragraph* pParagraph /*, sal_uInt16& rRelPos */ ) const
 200 {
 201     /* rRelPos = 0 */;
 202     sal_Int32 n = GetAbsPos( pParagraph );
 203     Paragraph* pPrev = GetParagraph( --n );
 204     while ( pPrev && ( pPrev->GetDepth() >= pParagraph->GetDepth() ) )
 205     {
 206 //      if ( pPrev->GetDepth() == pParagraph->GetDepth() )
 207 //          rRelPos++;
 208         pPrev = GetParagraph( --n );
 209     }
 210
 211     return pPrev;
 212 }
 213
 214 void ParagraphList::Expand( Paragraph* pParent )
 215 {
 216     sal_Int32 nChildCount = GetChildCount( pParent );
 217     sal_Int32 nPos = GetAbsPos( pParent );
 218
 219     for ( sal_Int32 n = 1; n <= nChildCount; n++  )
 220     {
 221         Paragraph* pPara = GetParagraph( nPos+n );
 222         if ( !( pPara->IsVisible() ) )
 223         {
 224             pPara->bVisible = true;
 225             aVisibleStateChangedHdl.Call( pPara );
 226         }
 227     }
 228 }
 229
 230 void ParagraphList::Collapse( Paragraph* pParent )
 231 {
 232     sal_Int32 nChildCount = GetChildCount( pParent );
 233     sal_Int32 nPos = GetAbsPos( pParent );
 234
 235     for ( sal_Int32 n = 1; n <= nChildCount; n++  )
 236     {
 237         Paragraph* pPara = GetParagraph( nPos+n );
 238         if ( pPara->IsVisible() )
 239         {
 240             pPara->bVisible = false;
 241             aVisibleStateChangedHdl.Call( pPara );
 242         }
 243     }
 244 }
 245
 246 sal_Int32 ParagraphList::GetAbsPos( Paragraph* pParent ) const
 247 {
 248     sal_Int32 pos = 0;
 249     std::vector<Paragraph*>::const_iterator iter;
 250     for (iter = maEntries.begin(); iter != maEntries.end(); ++iter, ++pos)
 251     {
 252         if (*iter == pParent)
 253             return pos;
 254     }
 255
 256     return EE_PARA_NOT_FOUND;
 257 }
 258
 259 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */