LCOV - code coverage report
Current view: top level - libreoffice/vcl/source/edit - textdata.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 159 0.0 %
Date: 2012-12-27 Functions: 0 34 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10