svtools/source/edit/textdata.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: textdata.cxx,v $
  10  * $Revision: 1.15 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include <svtools/textdata.hxx>
  35 #include <textdat2.hxx>
  36
  37 #include <tools/debug.hxx>
  38
  39 SV_IMPL_PTRARR( TextLines, TextLinePtr );
  40 SV_IMPL_VARARR( TEWritingDirectionInfos, TEWritingDirectionInfo );
  41
  42
  43 \f// -------------------------------------------------------------------------
  44 // (+) class TextSelection
  45 // -------------------------------------------------------------------------
  46
  47 TextSelection::TextSelection()
  48 {
  49 }
  50
  51 TextSelection::TextSelection( const TextPaM& rPaM ) :
  52     maStartPaM( rPaM ), maEndPaM( rPaM )
  53 {
  54 }
  55
  56 TextSelection::TextSelection( const TextPaM& rStart, const TextPaM& rEnd ) :
  57     maStartPaM( rStart ), maEndPaM( rEnd )
  58 {
  59 }
  60
  61 void TextSelection::Justify()
  62 {
  63     if ( maEndPaM < maStartPaM )
  64     {
  65         TextPaM aTemp( maStartPaM );
  66         maStartPaM = maEndPaM;
  67         maEndPaM = aTemp;
  68     }
  69 }
  70
  71
  72 \f// -------------------------------------------------------------------------
  73 // (+) class TETextPortionList
  74 // -------------------------------------------------------------------------
  75 TETextPortionList::TETextPortionList()
  76 {
  77 }
  78
  79 TETextPortionList::~TETextPortionList()
  80 {
  81     Reset();
  82 }
  83
  84 void TETextPortionList::Reset()
  85 {
  86     for ( USHORT nPortion = 0; nPortion < Count(); nPortion++ )
  87         delete GetObject( nPortion );
  88     Remove( 0, Count() );
  89 }
  90
  91 void TETextPortionList::DeleteFromPortion( USHORT nDelFrom )
  92 {
  93     DBG_ASSERT( ( nDelFrom < Count() ) || ( (nDelFrom == 0) && (Count() == 0) ), "DeleteFromPortion: Out of range" );
  94     for ( USHORT nP = nDelFrom; nP < Count(); nP++ )
  95         delete GetObject( nP );
  96     Remove( nDelFrom, Count()-nDelFrom );
  97 }
  98
  99 USHORT TETextPortionList::FindPortion( USHORT nCharPos, USHORT& nPortionStart, BOOL bPreferStartingPortion )
 100 {
 101     // Bei nCharPos an Portion-Grenze wird die linke Portion gefunden
 102     USHORT nTmpPos = 0;
 103     for ( USHORT nPortion = 0; nPortion < Count(); nPortion++ )
 104     {
 105         TETextPortion* pPortion = GetObject( nPortion );
 106         nTmpPos = nTmpPos + pPortion->GetLen();
 107         if ( nTmpPos >= nCharPos )
 108         {
 109             // take this one if we don't prefer the starting portion, or if it's the last one
 110             if ( ( nTmpPos != nCharPos ) || !bPreferStartingPortion || ( nPortion == Count() - 1 ) )
 111             {
 112                 nPortionStart = nTmpPos - pPortion->GetLen();
 113                 return nPortion;
 114             }
 115         }
 116     }
 117     DBG_ERROR( "FindPortion: Nicht gefunden!" );
 118     return ( Count() - 1 );
 119 }
 120
 121 /*
 122 USHORT TETextPortionList::GetPortionStartIndex( USHORT nPortion )
 123 {
 124     USHORT nPos = 0;
 125     for ( USHORT nP = 0; nP < nPortion; nP++ )
 126     {
 127         TETextPortion* pPortion = GetObject( nP );
 128         nPos += pPortion->GetLen();
 129     }
 130     return nPos;
 131 }
 132 */
 133
 134
 135 \f// -------------------------------------------------------------------------
 136 // (+) class TEParaPortion
 137 // -------------------------------------------------------------------------
 138 TEParaPortion::TEParaPortion( TextNode* pN )
 139 {
 140     mpNode = pN;
 141     mnInvalidPosStart = mnInvalidDiff = 0;
 142     mbInvalid = TRUE;
 143     mbSimple = FALSE;
 144 }
 145
 146 TEParaPortion::~TEParaPortion()
 147 {
 148 }
 149
 150 void TEParaPortion::MarkInvalid( USHORT nStart, short nDiff )
 151 {
 152     if ( mbInvalid == FALSE )
 153     {
 154         mnInvalidPosStart = ( nDiff >= 0 ) ? nStart : ( nStart + nDiff );
 155         mnInvalidDiff = nDiff;
 156     }
 157     else
 158     {
 159         // Einfaches hintereinander tippen
 160         if ( ( nDiff > 0 ) && ( mnInvalidDiff > 0 ) &&
 161              ( ( mnInvalidPosStart+mnInvalidDiff ) == nStart ) )
 162         {
 163             mnInvalidDiff = mnInvalidDiff + nDiff;
 164         }
 165         // Einfaches hintereinander loeschen
 166         else if ( ( nDiff < 0 ) && ( mnInvalidDiff < 0 ) && ( mnInvalidPosStart == nStart ) )
 167         {
 168             mnInvalidPosStart = mnInvalidPosStart + nDiff;
 169             mnInvalidDiff = mnInvalidDiff + nDiff;
 170         }
 171         else
 172         {
 173             DBG_ASSERT( ( nDiff >= 0 ) || ( (nStart+nDiff) >= 0 ), "MarkInvalid: Diff out of Range" );
 174             mnInvalidPosStart = Min( mnInvalidPosStart, (USHORT) ( (nDiff < 0) ? nStart+nDiff : nDiff ) );
 175             mnInvalidDiff = 0;
 176             mbSimple = FALSE;
 177         }
 178     }
 179
 180     maWritingDirectionInfos.Remove( 0, maWritingDirectionInfos.Count() );
 181
 182     mbInvalid = TRUE;
 183 }
 184
 185 void TEParaPortion::MarkSelectionInvalid( USHORT nStart, USHORT /*nEnd*/ )
 186 {
 187     if ( mbInvalid == FALSE )
 188     {
 189         mnInvalidPosStart = nStart;
 190 //              nInvalidPosEnd = nEnd;
 191     }
 192     else
 193     {
 194         mnInvalidPosStart = Min( mnInvalidPosStart, nStart );
 195 //              nInvalidPosEnd = pNode->Len();
 196     }
 197
 198     maWritingDirectionInfos.Remove( 0, maWritingDirectionInfos.Count() );
 199
 200     mnInvalidDiff = 0;
 201     mbInvalid = TRUE;
 202     mbSimple = FALSE;
 203 }
 204
 205 USHORT TEParaPortion::GetLineNumber( USHORT nChar, BOOL bInclEnd )
 206 {
 207     for ( USHORT nLine = 0; nLine < maLines.Count(); nLine++ )
 208     {
 209         TextLine* pLine = maLines.GetObject( nLine );
 210         if ( ( bInclEnd && ( pLine->GetEnd() >= nChar ) ) ||
 211              ( pLine->GetEnd() > nChar ) )
 212         {
 213             return nLine;
 214         }
 215     }
 216
 217     // Dann sollte es am Ende der letzten Zeile sein!
 218     DBG_ASSERT( nChar == maLines[ maLines.Count() - 1 ]->GetEnd(), "Index voll daneben!" );
 219     DBG_ASSERT( !bInclEnd, "Zeile nicht gefunden: FindLine" );
 220     return ( maLines.Count() - 1 );
 221 }
 222
 223
 224 void TEParaPortion::CorrectValuesBehindLastFormattedLine( USHORT nLastFormattedLine )
 225 {
 226     USHORT nLines = maLines.Count();
 227     DBG_ASSERT( nLines, "CorrectPortionNumbersFromLine: Leere Portion?" );
 228     if ( nLastFormattedLine < ( nLines - 1 ) )
 229     {
 230         const TextLine* pLastFormatted = maLines[ nLastFormattedLine ];
 231         const TextLine* pUnformatted = maLines[ nLastFormattedLine+1 ];
 232         short nPortionDiff = pUnformatted->GetStartPortion() - pLastFormatted->GetEndPortion();
 233         short nTextDiff = pUnformatted->GetStart() - pLastFormatted->GetEnd();
 234         nTextDiff++;    // LastFormatted->GetEnd() war incl. => 1 zuviel abgezogen!
 235
 236         // Die erste unformatierte muss genau eine Portion hinter der letzten der
 237         // formatierten beginnen:
 238         // Wenn in der geaenderten Zeile eine Portion gesplittet wurde,
 239         // kann nLastEnd > nNextStart sein!
 240         short nPDiff = sal::static_int_cast< short >(-( nPortionDiff-1 ));
 241         short nTDiff = sal::static_int_cast< short >(-( nTextDiff-1 ));
 242         if ( nPDiff || nTDiff )
 243         {
 244             for ( USHORT nL = nLastFormattedLine+1; nL < nLines; nL++ )
 245             {
 246                 TextLine* pLine = maLines[ nL ];
 247
 248                 pLine->GetStartPortion() = pLine->GetStartPortion() + nPDiff;
 249                 pLine->GetEndPortion() = pLine->GetEndPortion() + nPDiff;
 250
 251                 pLine->GetStart() = pLine->GetStart() + nTDiff;
 252                 pLine->GetEnd() = pLine->GetEnd() + nTDiff;
 253
 254                 pLine->SetValid();
 255             }
 256         }
 257     }
 258 }
 259
 260 \f// -------------------------------------------------------------------------
 261 // (+) class TEParaPortions
 262 // -------------------------------------------------------------------------
 263 TEParaPortions::TEParaPortions()
 264 {
 265 }
 266
 267 TEParaPortions::~TEParaPortions()
 268 {
 269     Reset();
 270 }
 271
 272 void TEParaPortions::Reset()
 273 {
 274     TEParaPortions::iterator aIter( begin() );
 275     while ( aIter != end() )
 276         delete *aIter++;
 277     clear();
 278 }
 279
 280 \f// -------------------------------------------------------------------------
 281 // (+) class IdleFormatter
 282 // -------------------------------------------------------------------------
 283 IdleFormatter::IdleFormatter()
 284 {
 285     mpView = 0;
 286     mnRestarts = 0;
 287 }
 288
 289 IdleFormatter::~IdleFormatter()
 290 {
 291     mpView = 0;
 292 }
 293
 294 void IdleFormatter::DoIdleFormat( TextView* pV, USHORT nMaxRestarts )
 295 {
 296     mpView = pV;
 297
 298     if ( IsActive() )
 299         mnRestarts++;
 300
 301     if ( mnRestarts > nMaxRestarts )
 302     {
 303         mnRestarts = 0;
 304         ((Link&)GetTimeoutHdl()).Call( this );
 305     }
 306     else
 307     {
 308         Start();
 309     }
 310 }
 311
 312 void IdleFormatter::ForceTimeout()
 313 {
 314     if ( IsActive() )
 315     {
 316         Stop();
 317         mnRestarts = 0;
 318         ((Link&)GetTimeoutHdl()).Call( this );
 319     }
 320 }
 321
 322 TYPEINIT1( TextHint, SfxSimpleHint );
 323
 324 TextHint::TextHint( ULONG Id ) : SfxSimpleHint( Id )
 325 {
 326     mnValue = 0;
 327 }
 328
 329 TextHint::TextHint( ULONG Id, ULONG nValue ) : SfxSimpleHint( Id )
 330 {
 331     mnValue = nValue;
 332 }
 333
 334 TEIMEInfos::TEIMEInfos( const TextPaM& rPos, const String& rOldTextAfterStartPos )
 335 : aOldTextAfterStartPos( rOldTextAfterStartPos )
 336 {
 337     aPos = rPos;
 338     nLen = 0;
 339     bCursor = TRUE;
 340     pAttribs = NULL;
 341     bWasCursorOverwrite = FALSE;
 342 }
 343
 344 TEIMEInfos::~TEIMEInfos()
 345 {
 346     delete[] pAttribs;
 347 }
 348
 349 void TEIMEInfos::CopyAttribs( const USHORT* pA, USHORT nL )
 350 {
 351     nLen = nL;
 352     delete pAttribs;
 353     pAttribs = new USHORT[ nL ];
 354     memcpy( pAttribs, pA, nL*sizeof(USHORT) );
 355 }
 356
 357 void TEIMEInfos::DestroyAttribs()
 358 {
 359     delete pAttribs;
 360     pAttribs = NULL;
 361     nLen = 0;
 362 }
 363
 364