sw/source/core/text/porlin.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: porlin.cxx,v $
  10  * $Revision: 1.27 $
  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_sw.hxx"
  33
  34
  35 #ifndef _OUTDEV_HXX //autogen
  36 #include <vcl/outdev.hxx>
  37 #endif
  38 #include <SwPortionHandler.hxx>
  39
  40 #include "errhdl.hxx"   // ASSERT
  41
  42 #include "txtcfg.hxx"
  43 #include "porlin.hxx"
  44 #include "inftxt.hxx"
  45 #include "portxt.hxx"
  46 #include "pormulti.hxx"
  47 #include "porglue.hxx"
  48 #include "inftxt.hxx"
  49 #include "blink.hxx"
  50 #ifndef PRODUCT
  51
  52 sal_Bool ChkChain( SwLinePortion *pStart )
  53 {
  54     SwLinePortion *pPor = pStart->GetPortion();
  55     MSHORT nCount = 0;
  56     while( pPor )
  57     {
  58         ++nCount;
  59         ASSERT( nCount < 200 && pPor != pStart,
  60                 "ChkChain(): lost in chains" );
  61         if( nCount >= 200 || pPor == pStart )
  62         {
  63             // der Lebensretter
  64             pPor = pStart->GetPortion();
  65             pStart->SetPortion(0);
  66             pPor->Truncate();
  67             pStart->SetPortion( pPor );
  68             return sal_False;
  69         }
  70         pPor = pPor->GetPortion();
  71     }
  72     return sal_True;
  73 }
  74 #endif
  75
  76 #if OSL_DEBUG_LEVEL > 1
  77 const sal_Char *GetPortionName( const MSHORT nType );
  78 #endif
  79
  80 SwLinePortion::~SwLinePortion()
  81 {
  82     if( pBlink )
  83         pBlink->Delete( this );
  84 }
  85
  86 SwLinePortion *SwLinePortion::Compress()
  87 {
  88     return GetLen() || Width() ? this : 0;
  89 }
  90
  91 KSHORT SwLinePortion::GetViewWidth( const SwTxtSizeInfo & ) const
  92 {
  93     return 0;
  94 }
  95
  96 /*************************************************************************
  97  *                               SwLinePortion::SwLinePortion( )
  98  *************************************************************************/
  99
 100 SwLinePortion::SwLinePortion( ) :
 101     pPortion( NULL ),
 102     nLineLength( 0 ),
 103     nAscent( 0 )
 104 {
 105 }
 106
 107 /*************************************************************************
 108  *               SwLinePortion::PrePaint()
 109  *************************************************************************/
 110
 111 void SwLinePortion::PrePaint( const SwTxtPaintInfo& rInf,
 112                               const SwLinePortion* pLast ) const
 113 {
 114     ASSERT( rInf.OnWin(), "SwLinePortion::PrePaint: don't prepaint on a printer");
 115     ASSERT( !Width(), "SwLinePortion::PrePaint: For Width()==0 only!");
 116
 117     const KSHORT nViewWidth = GetViewWidth( rInf );
 118
 119     if( ! nViewWidth )
 120         return;
 121
 122     const KSHORT nHalfView = nViewWidth / 2;
 123     USHORT nLastWidth = pLast->Width();
 124
 125     if ( pLast->InSpaceGrp() && rInf.GetSpaceAdd() )
 126         nLastWidth = nLastWidth + (USHORT)pLast->CalcSpacing( rInf.GetSpaceAdd(), rInf );
 127
 128     KSHORT nPos;
 129     SwTxtPaintInfo aInf( rInf );
 130
 131     const BOOL bBidiPor = ( rInf.GetTxtFrm()->IsRightToLeft() ) !=
 132                           ( 0 != ( TEXT_LAYOUT_BIDI_RTL & rInf.GetOut()->GetLayoutMode() ) );
 133
 134     USHORT nDir = bBidiPor ?
 135                   1800 :
 136                   rInf.GetFont()->GetOrientation( rInf.GetTxtFrm()->IsVertical() );
 137
 138     switch ( nDir )
 139     {
 140     case 0 :
 141         nPos = KSHORT( rInf.X() );
 142         if( nLastWidth > nHalfView )
 143             nPos += nLastWidth - nHalfView;
 144         aInf.X( nPos );
 145         break;
 146     case 900 :
 147         nPos = KSHORT( rInf.Y() );
 148         if( nLastWidth > nHalfView )
 149             nPos -= nLastWidth + nHalfView;
 150         aInf.Y( nPos );
 151         break;
 152     case 1800 :
 153         nPos = KSHORT( rInf.X() );
 154         if( nLastWidth > nHalfView )
 155             nPos -= nLastWidth + nHalfView;
 156         aInf.X( nPos );
 157         break;
 158     case 2700 :
 159         nPos = KSHORT( rInf.Y() );
 160         if( nLastWidth > nHalfView )
 161             nPos += nLastWidth - nHalfView;
 162         aInf.Y( nPos );
 163         break;
 164     }
 165
 166     SwLinePortion *pThis = (SwLinePortion*)this;
 167     pThis->Width( nViewWidth );
 168     Paint( aInf );
 169     pThis->Width(0);
 170 }
 171
 172 /*************************************************************************
 173  *                                      SwLinePortion::CalcTxtSize()
 174  *************************************************************************/
 175
 176 void SwLinePortion::CalcTxtSize( const SwTxtSizeInfo &rInf )
 177 {
 178     if( GetLen() == rInf.GetLen()  )
 179         *((SwPosSize*)this) = GetTxtSize( rInf );
 180     else
 181     {
 182         SwTxtSizeInfo aInf( rInf );
 183         aInf.SetLen( GetLen() );
 184         *((SwPosSize*)this) = GetTxtSize( aInf );
 185     }
 186 }
 187
 188 /*************************************************************************
 189  *                                      SwLinePortion::Truncate()
 190  *
 191  * Es werden alle nachfolgenden Portions geloescht.
 192  *************************************************************************/
 193
 194 void SwLinePortion::_Truncate()
 195 {
 196     SwLinePortion *pPos = pPortion;
 197     do
 198     {   ASSERT( pPos != this, "SwLinePortion::Truncate: loop" );
 199         SwLinePortion *pLast = pPos;
 200         pPos = pPos->GetPortion();
 201         pLast->SetPortion( 0 );
 202         delete pLast;
 203
 204     } while( pPos );
 205
 206     pPortion = 0;
 207 }
 208
 209 /*************************************************************************
 210  *                                virtual SwLinePortion::Insert()
 211  *
 212  * Es wird immer hinter uns eingefuegt.
 213  *************************************************************************/
 214
 215 SwLinePortion *SwLinePortion::Insert( SwLinePortion *pIns )
 216 {
 217     pIns->FindLastPortion()->SetPortion( pPortion );
 218     SetPortion( pIns );
 219 #ifndef PRODUCT
 220     ChkChain( this );
 221 #endif
 222     return pIns;
 223 }
 224
 225 /*************************************************************************
 226  *                                      SwLinePortion::FindLastPortion()
 227  *************************************************************************/
 228
 229 SwLinePortion *SwLinePortion::FindLastPortion()
 230 {
 231     SwLinePortion *pPos = this;
 232     // An das Ende wandern und pLinPortion an den letzten haengen ...
 233     while( pPos->GetPortion() )
 234     {
 235         DBG_LOOP;
 236         pPos = pPos->GetPortion();
 237     }
 238     return pPos;
 239 }
 240
 241 /*************************************************************************
 242  *                                virtual SwLinePortion::Append()
 243  *************************************************************************/
 244
 245 SwLinePortion *SwLinePortion::Append( SwLinePortion *pIns )
 246 {
 247     SwLinePortion *pPos = FindLastPortion();
 248     pPos->SetPortion( pIns );
 249     pIns->SetPortion( 0 );
 250 #ifndef PRODUCT
 251     ChkChain( this );
 252 #endif
 253     return pIns;
 254 }
 255
 256 /*************************************************************************
 257  *                                virtual SwLinePortion::Cut()
 258  *************************************************************************/
 259
 260 SwLinePortion *SwLinePortion::Cut( SwLinePortion *pVictim )
 261 {
 262     SwLinePortion *pPrev = pVictim->FindPrevPortion( this );
 263     ASSERT( pPrev, "SwLinePortion::Cut(): can't cut" );
 264     pPrev->SetPortion( pVictim->GetPortion() );
 265     pVictim->SetPortion(0);
 266     return pVictim;
 267 }
 268
 269 /*************************************************************************
 270  *                                SwLinePortion::FindPrevPortion()
 271  *************************************************************************/
 272
 273 SwLinePortion *SwLinePortion::FindPrevPortion( const SwLinePortion *pRoot )
 274 {
 275     ASSERT( pRoot != this, "SwLinePortion::FindPrevPortion(): invalid root" );
 276     SwLinePortion *pPos = (SwLinePortion*)pRoot;
 277     while( pPos->GetPortion() && pPos->GetPortion() != this )
 278     {
 279         DBG_LOOP;
 280         pPos = pPos->GetPortion();
 281     }
 282     ASSERT( pPos->GetPortion(),
 283             "SwLinePortion::FindPrevPortion: blowing in the wind");
 284     return pPos;
 285 }
 286
 287 /*************************************************************************
 288  *                                virtual SwLinePortion::GetCrsrOfst()
 289  *************************************************************************/
 290
 291 xub_StrLen SwLinePortion::GetCrsrOfst( const KSHORT nOfst ) const
 292 {
 293     if( nOfst > ( PrtWidth() / 2 ) )
 294         return GetLen();
 295     else
 296         return 0;
 297 }
 298
 299 /*************************************************************************
 300  *                                virtual SwLinePortion::GetTxtSize()
 301  *************************************************************************/
 302
 303 SwPosSize SwLinePortion::GetTxtSize( const SwTxtSizeInfo & ) const
 304 {
 305     ASSERT( !this, "SwLinePortion::GetTxtSize: don't ask me about sizes, "
 306                    "I'm only a stupid SwLinePortion" );
 307     return SwPosSize();
 308 }
 309
 310 #ifndef PRODUCT
 311
 312 /*************************************************************************
 313  *                                virtual SwLinePortion::Check()
 314  *************************************************************************/
 315
 316 sal_Bool SwLinePortion::Check( SvStream &, SwTxtSizeInfo & ) //$ ostream
 317 {
 318     return sal_True;
 319 }
 320 #endif
 321
 322 /*************************************************************************
 323  *                                 virtual SwLinePortion::Format()
 324  *************************************************************************/
 325
 326 sal_Bool SwLinePortion::Format( SwTxtFormatInfo &rInf )
 327 {
 328     if( rInf.X() > rInf.Width() )
 329     {
 330         Truncate();
 331         rInf.SetUnderFlow( this );
 332         return sal_True;
 333     }
 334
 335     const SwLinePortion *pLast = rInf.GetLast();
 336     Height( pLast->Height() );
 337     SetAscent( pLast->GetAscent() );
 338     const KSHORT nNewWidth = static_cast<USHORT>(rInf.X() + PrtWidth());
 339     // Nur Portions mit echter Breite koennen ein sal_True zurueckliefern
 340     // Notizen beispielsweise setzen niemals bFull==sal_True
 341     if( rInf.Width() <= nNewWidth && PrtWidth() && ! IsKernPortion() )
 342     {
 343         Truncate();
 344         if( nNewWidth > rInf.Width() )
 345             PrtWidth( nNewWidth - rInf.Width() );
 346         rInf.GetLast()->FormatEOL( rInf );
 347         return sal_True;
 348     }
 349     return sal_False;
 350 }
 351
 352 /*************************************************************************
 353  *                                 virtual SwLinePortion::FormatEOL()
 354  *************************************************************************/
 355
 356 // Format end of line
 357
 358 void SwLinePortion::FormatEOL( SwTxtFormatInfo & )
 359 { }
 360
 361 /*************************************************************************
 362  *                                              SwLinePortion::Move()
 363  *************************************************************************/
 364
 365 void SwLinePortion::Move( SwTxtPaintInfo &rInf )
 366 {
 367     BOOL bB2T = rInf.GetDirection() == DIR_BOTTOM2TOP;
 368     const BOOL bFrmDir = rInf.GetTxtFrm()->IsRightToLeft();
 369     BOOL bCounterDir = ( ! bFrmDir && DIR_RIGHT2LEFT == rInf.GetDirection() ) ||
 370                        (   bFrmDir && DIR_LEFT2RIGHT == rInf.GetDirection() );
 371
 372     if ( InSpaceGrp() && rInf.GetSpaceAdd() )
 373     {
 374         SwTwips nTmp = PrtWidth() +     CalcSpacing( rInf.GetSpaceAdd(), rInf );
 375         if( rInf.IsRotated() )
 376             rInf.Y( rInf.Y() + ( bB2T ? -nTmp : nTmp ) );
 377         else if ( bCounterDir )
 378             rInf.X( rInf.X() - nTmp );
 379         else
 380             rInf.X( rInf.X() + nTmp );
 381     }
 382     else
 383     {
 384         if( InFixMargGrp() && !IsMarginPortion() )
 385         {
 386             rInf.IncSpaceIdx();
 387             rInf.IncKanaIdx();
 388         }
 389         if( rInf.IsRotated() )
 390             rInf.Y( rInf.Y() + ( bB2T ? -PrtWidth() : PrtWidth() ) );
 391         else if ( bCounterDir )
 392             rInf.X( rInf.X() - PrtWidth() );
 393         else
 394             rInf.X( rInf.X() + PrtWidth() );
 395     }
 396     if( IsMultiPortion() && ((SwMultiPortion*)this)->HasTabulator() )
 397         rInf.IncSpaceIdx();
 398
 399     rInf.SetIdx( rInf.GetIdx() + GetLen() );
 400 }
 401
 402 /*************************************************************************
 403  *                              virtual SwLinePortion::CalcSpacing()
 404  *************************************************************************/
 405
 406 long SwLinePortion::CalcSpacing( long , const SwTxtSizeInfo & ) const
 407 {
 408     return 0;
 409 }
 410
 411 /*************************************************************************
 412  *                              virtual SwLinePortion::GetExpTxt()
 413  *************************************************************************/
 414
 415 sal_Bool SwLinePortion::GetExpTxt( const SwTxtSizeInfo &, XubString & ) const
 416 {
 417     return sal_False;
 418 }
 419
 420 /*************************************************************************
 421  *              virtual SwLinePortion::HandlePortion()
 422  *************************************************************************/
 423
 424 void SwLinePortion::HandlePortion( SwPortionHandler& rPH ) const
 425 {
 426     String aString;
 427     rPH.Special( GetLen(), aString, GetWhichPor() );
 428 }
 429