sw/source/core/inc/drawfont.hxx

   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: drawfont.hxx,v $
  10  * $Revision: 1.40 $
  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 #ifndef _DRAWFONT_HXX
  31 #define _DRAWFONT_HXX
  32
  33 #include <tools/solar.h>
  34 #include <tools/string.hxx>
  35 #include <errhdl.hxx>
  36
  37 class SwTxtFrm;
  38 class OutputDevice;
  39 class ViewShell;
  40 class SwScriptInfo;
  41 class Point;
  42 class SwWrongList;
  43 class Size;
  44 class SwFont;
  45 class Font;
  46 class SwUnderlineFont;
  47
  48 /*************************************************************************
  49  *                      class SwDrawTextInfo
  50  *
  51  * encapsulates information for drawing text
  52  *************************************************************************/
  53
  54 class SwDrawTextInfo
  55 {
  56     const SwTxtFrm* pFrm;
  57     OutputDevice* pOut;
  58     ViewShell* pSh;
  59     const SwScriptInfo* pScriptInfo;
  60     const Point* pPos;
  61     const XubString* pText;
  62     const SwWrongList* pWrong;
  63     const SwWrongList* pGrammarCheck;
  64     const SwWrongList* pSmartTags; // SMARTTAGS
  65     const Size* pSize;
  66     SwFont *pFnt;
  67     SwUnderlineFont* pUnderFnt;
  68     xub_StrLen* pHyphPos;
  69     long nLeft;
  70     long nRight;
  71     long nKanaDiff;
  72     xub_StrLen nIdx;
  73     xub_StrLen nLen;
  74     xub_StrLen nOfst;
  75     USHORT nWidth;
  76     USHORT nAscent;
  77     USHORT nCompress;
  78     long nSperren;
  79     long nSpace;
  80     long nKern;
  81     xub_StrLen nNumberOfBlanks;
  82     BYTE nCursorBidiLevel;
  83     BOOL bBullet : 1;
  84     BOOL bUpper : 1;            // Fuer Kapitaelchen: Grossbuchstaben-Flag
  85     BOOL bDrawSpace : 1;        // Fuer Kapitaelchen: Unter/Durchstreichung
  86     BOOL bGreyWave      : 1;    // Graue Wellenlinie beim extended TextInput
  87     BOOL bSpaceStop : 1;    // For underlining we need to know, if a portion
  88                             // is right in front of a hole portion or a
  89                             // fix margin portion.
  90     BOOL bSnapToGrid : 1;   // Does paragraph snap to grid?
  91     BOOL bIgnoreFrmRTL : 1; // Paint text as if text has LTR direction, used for
  92                             // line numbering
  93     BOOL bPosMatchesBounds :1;  // GetCrsrOfst should not return the next
  94                                 // position if screen position is inside second
  95                                 // half of bound rect, used for Accessibility
  96
  97     SwDrawTextInfo();       // nicht zulaessig
  98 public:
  99
 100 #ifndef PRODUCT
 101     BOOL bPos   : 1;            // These flags should control, that the appropriate
 102     BOOL bWrong : 1;            // Set-function has been called before calling
 103     BOOL bGrammarCheck : 1;     //  the Get-function of a member
 104     BOOL bSize  : 1;
 105     BOOL bFnt   : 1;
 106     BOOL bHyph  : 1;
 107     BOOL bLeft  : 1;
 108     BOOL bRight : 1;
 109     BOOL bKana  : 1;
 110     BOOL bOfst  : 1;
 111     BOOL bAscent: 1;
 112     BOOL bSperr : 1;
 113     BOOL bSpace : 1;
 114     BOOL bNumberOfBlanks : 1;
 115     BOOL bUppr  : 1;
 116     BOOL bDrawSp: 1;
 117 #endif
 118
 119     SwDrawTextInfo( ViewShell *pS, OutputDevice &rO, const SwScriptInfo* pSI,
 120                     const XubString &rSt, xub_StrLen nI, xub_StrLen nL,
 121                     USHORT nW = 0, BOOL bB = FALSE )
 122     {
 123         pFrm = NULL;
 124         pSh = pS;
 125         pOut = &rO;
 126         pScriptInfo = pSI;
 127         pText = &rSt;
 128         nIdx = nI;
 129         nLen = nL;
 130         nKern = 0;
 131         nCompress = 0;
 132         nWidth = nW;
 133         nNumberOfBlanks = 0;
 134         nCursorBidiLevel = 0;
 135         bBullet = bB;
 136         pUnderFnt = 0;
 137         bGreyWave = FALSE;
 138         bSpaceStop = FALSE;
 139         bSnapToGrid = FALSE;
 140         bIgnoreFrmRTL = FALSE;
 141         bPosMatchesBounds = FALSE;
 142
 143         // These values are initialized but, they have to be
 144         // set explicitly via their Set-function before they may
 145         // be accessed by their Get-function:
 146         pPos = 0;
 147         pWrong = 0;
 148         pGrammarCheck = 0;
 149         pSmartTags = 0;
 150         pSize = 0;
 151         pFnt = 0;
 152         pHyphPos = 0;
 153         nLeft = 0;
 154         nRight = 0;
 155         nKanaDiff = 0;
 156         nOfst = 0;
 157         nAscent = 0;
 158         nSperren = 0;
 159         nSpace = 0;
 160         bUpper = FALSE;
 161         bDrawSpace = FALSE;
 162
 163 #ifndef PRODUCT
 164         // these flags control, whether the matching member variables have
 165         // been set by using the Set-function before they may be accessed
 166         // by their Get-function:
 167         bPos = bWrong = bGrammarCheck = bSize = bFnt = bAscent = bSpace = bNumberOfBlanks = bUppr =
 168         bDrawSp = bLeft = bRight = bKana = bOfst = bHyph = bSperr = FALSE;
 169 #endif
 170     }
 171
 172     const SwTxtFrm* GetFrm() const
 173     {
 174         return pFrm;
 175     }
 176
 177     void SetFrm( const SwTxtFrm* pNewFrm )
 178     {
 179         pFrm = pNewFrm;
 180     }
 181
 182     ViewShell *GetShell() const
 183     {
 184         return pSh;
 185     }
 186
 187     OutputDevice& GetOut() const
 188     {
 189         return *pOut;
 190     }
 191
 192     OutputDevice *GetpOut() const
 193     {
 194         return pOut;
 195     }
 196
 197     const SwScriptInfo* GetScriptInfo() const
 198     {
 199         return pScriptInfo;
 200     }
 201
 202     const Point &GetPos() const
 203     {
 204         ASSERT( bPos, "DrawTextInfo: Undefined Position" );
 205         return *pPos;
 206     }
 207
 208     xub_StrLen *GetHyphPos() const
 209     {
 210         ASSERT( bHyph, "DrawTextInfo: Undefined Hyph Position" );
 211         return pHyphPos;
 212     }
 213
 214     const XubString &GetText() const
 215     {
 216         return *pText;
 217     }
 218
 219     const SwWrongList* GetWrong() const
 220     {
 221         ASSERT( bWrong, "DrawTextInfo: Undefined WrongList" );
 222         return pWrong;
 223     }
 224
 225     const SwWrongList* GetGrammarCheck() const
 226     {
 227         ASSERT( bGrammarCheck, "DrawTextInfo: Undefined GrammarCheck List" );
 228         return pGrammarCheck;
 229     }
 230
 231     const SwWrongList* GetSmartTags() const
 232     {
 233         return pSmartTags;
 234     }
 235
 236     const Size &GetSize() const
 237     {
 238         ASSERT( bSize, "DrawTextInfo: Undefined Size" );
 239         return *pSize;
 240     }
 241
 242     SwFont* GetFont() const
 243     {
 244         ASSERT( bFnt, "DrawTextInfo: Undefined Font" );
 245         return pFnt;
 246     }
 247
 248     SwUnderlineFont* GetUnderFnt() const
 249     {
 250         return pUnderFnt;
 251     }
 252
 253     xub_StrLen GetIdx() const
 254     {
 255         return nIdx;
 256     }
 257
 258     xub_StrLen GetLen() const
 259     {
 260         return nLen;
 261     }
 262
 263     xub_StrLen GetOfst() const
 264     {
 265         ASSERT( bOfst, "DrawTextInfo: Undefined Offset" );
 266         return nOfst;
 267     }
 268
 269     xub_StrLen GetEnd() const
 270     {
 271         return nIdx + nLen;
 272     }
 273
 274     long GetLeft() const
 275     {
 276         ASSERT( bLeft, "DrawTextInfo: Undefined left range" );
 277         return nLeft;
 278     }
 279
 280     long GetRight() const
 281     {
 282         ASSERT( bRight, "DrawTextInfo: Undefined right range" );
 283         return nRight;
 284     }
 285
 286     long GetKanaDiff() const
 287     {
 288         ASSERT( bKana, "DrawTextInfo: Undefined kana difference" );
 289         return nKanaDiff;
 290     }
 291
 292     USHORT GetWidth() const
 293     {
 294         return nWidth;
 295     }
 296
 297     USHORT GetAscent() const
 298     {
 299         ASSERT( bAscent, "DrawTextInfo: Undefined Ascent" );
 300         return nAscent;
 301     }
 302
 303     USHORT GetKanaComp() const
 304     {
 305         return nCompress;
 306     }
 307
 308     long GetSperren() const
 309     {
 310         ASSERT( bSperr, "DrawTextInfo: Undefined >Sperren<" );
 311         return nSperren;
 312     }
 313
 314     long GetKern() const
 315     {
 316         return nKern;
 317     }
 318
 319     long GetSpace() const
 320     {
 321         ASSERT( bSpace, "DrawTextInfo: Undefined Spacing" );
 322         return nSpace;
 323     }
 324
 325     xub_StrLen GetNumberOfBlanks() const
 326     {
 327         ASSERT( bNumberOfBlanks, "DrawTextInfo::Undefined NumberOfBlanks" );
 328         return nNumberOfBlanks;
 329     }
 330
 331     BYTE GetCursorBidiLevel() const
 332     {
 333         return nCursorBidiLevel;
 334     }
 335
 336     BOOL GetBullet() const
 337     {
 338         return bBullet;
 339     }
 340
 341     BOOL GetUpper() const
 342     {
 343         ASSERT( bUppr, "DrawTextInfo: Undefined Upperflag" );
 344         return bUpper;
 345     }
 346
 347     BOOL GetDrawSpace() const
 348     {
 349         ASSERT( bDrawSp, "DrawTextInfo: Undefined DrawSpaceflag" );
 350         return bDrawSpace;
 351     }
 352
 353     BOOL GetGreyWave() const
 354     {
 355         return bGreyWave;
 356     }
 357
 358     BOOL IsSpaceStop() const
 359     {
 360         return bSpaceStop;
 361     }
 362
 363     BOOL SnapToGrid() const
 364     {
 365         return bSnapToGrid;
 366     }
 367
 368     BOOL IsIgnoreFrmRTL() const
 369     {
 370         return bIgnoreFrmRTL;
 371     }
 372
 373     BOOL IsPosMatchesBounds() const
 374     {
 375         return bPosMatchesBounds;
 376     }
 377
 378     void SetOut( OutputDevice &rNew )
 379     {
 380         pOut = &rNew;
 381     }
 382
 383     void SetPos( const Point &rNew )
 384     {
 385         pPos = &rNew;
 386 #ifndef PRODUCT
 387         bPos = TRUE;
 388 #endif
 389     }
 390
 391     void SetHyphPos( xub_StrLen *pNew )
 392     {
 393         pHyphPos = pNew;
 394 #ifndef PRODUCT
 395         bHyph = TRUE;
 396 #endif
 397     }
 398
 399     void SetText( const XubString &rNew )
 400     {
 401         pText = &rNew;
 402     }
 403
 404     void SetWrong( const SwWrongList* pNew )
 405     {
 406         pWrong = pNew;
 407 #ifndef PRODUCT
 408         bWrong = TRUE;
 409 #endif
 410     }
 411
 412     void SetGrammarCheck( const SwWrongList* pNew )
 413     {
 414         pGrammarCheck = pNew;
 415 #ifndef PRODUCT
 416         bGrammarCheck = TRUE;
 417 #endif
 418     }
 419
 420     void SetSmartTags( const SwWrongList* pNew )
 421     {
 422         pSmartTags = pNew;
 423     }
 424
 425     void SetSize( const Size &rNew )
 426     {
 427         pSize = &rNew;
 428 #ifndef PRODUCT
 429         bSize = TRUE;
 430 #endif
 431     }
 432
 433     void SetFont( SwFont* pNew )
 434     {
 435         pFnt = pNew;
 436 #ifndef PRODUCT
 437         bFnt = TRUE;
 438 #endif
 439     }
 440
 441     void SetIdx( xub_StrLen nNew )
 442     {
 443         nIdx = nNew;
 444     }
 445
 446     void SetLen( xub_StrLen nNew )
 447     {
 448         nLen = nNew;
 449     }
 450
 451     void SetOfst( xub_StrLen nNew )
 452     {
 453         nOfst = nNew;
 454 #ifndef PRODUCT
 455         bOfst = TRUE;
 456 #endif
 457     }
 458
 459     void SetLeft( long nNew )
 460     {
 461         nLeft = nNew;
 462 #ifndef PRODUCT
 463         bLeft = TRUE;
 464 #endif
 465     }
 466
 467     void SetRight( long nNew )
 468     {
 469         nRight = nNew;
 470 #ifndef PRODUCT
 471         bRight = TRUE;
 472 #endif
 473     }
 474
 475     void SetKanaDiff( long nNew )
 476     {
 477         nKanaDiff = nNew;
 478 #ifndef PRODUCT
 479         bKana = TRUE;
 480 #endif
 481     }
 482
 483     void SetWidth( USHORT nNew )
 484     {
 485         nWidth = nNew;
 486     }
 487
 488     void SetAscent( USHORT nNew )
 489     {
 490         nAscent = nNew;
 491 #ifndef PRODUCT
 492         bAscent = TRUE;
 493 #endif
 494     }
 495
 496     void SetKern( long nNew )
 497     {
 498         nKern = nNew;
 499     }
 500
 501     void SetSpace( long nNew )
 502     {
 503         if( nNew < 0 )
 504         {
 505             nSperren = -nNew;
 506             nSpace = 0;
 507         }
 508         else
 509         {
 510             nSpace = nNew;
 511             nSperren = 0;
 512         }
 513 #ifndef PRODUCT
 514         bSpace = TRUE;
 515         bSperr = TRUE;
 516 #endif
 517     }
 518
 519     void SetNumberOfBlanks( xub_StrLen nNew )
 520     {
 521 #ifndef PRODUCT
 522         bNumberOfBlanks = TRUE;
 523 #endif
 524         nNumberOfBlanks = nNew;
 525     }
 526
 527     void SetCursorBidiLevel( BYTE nNew )
 528     {
 529         nCursorBidiLevel = nNew;
 530     }
 531
 532     void SetKanaComp( short nNew )
 533     {
 534         nCompress = nNew;
 535     }
 536
 537     void SetBullet( BOOL bNew )
 538     {
 539         bBullet = bNew;
 540     }
 541
 542     void SetUnderFnt( SwUnderlineFont* pULFnt )
 543     {
 544         pUnderFnt = pULFnt;
 545     }
 546
 547     void SetUpper( BOOL bNew )
 548     {
 549         bUpper = bNew;
 550 #ifndef PRODUCT
 551         bUppr = TRUE;
 552 #endif
 553     }
 554
 555     void SetDrawSpace( BOOL bNew )
 556     {
 557         bDrawSpace = bNew;
 558 #ifndef PRODUCT
 559         bDrawSp = TRUE;
 560 #endif
 561     }
 562
 563     void SetGreyWave( BOOL bNew )
 564     {
 565         bGreyWave = bNew;
 566     }
 567
 568     void SetSpaceStop( BOOL bNew )
 569     {
 570         bSpaceStop = bNew;
 571     }
 572
 573     void SetSnapToGrid( BOOL bNew )
 574     {
 575         bSnapToGrid = bNew;
 576     }
 577
 578     void SetIgnoreFrmRTL( BOOL bNew )
 579     {
 580         bIgnoreFrmRTL = bNew;
 581     }
 582
 583     void SetPosMatchesBounds( BOOL bNew )
 584     {
 585         bPosMatchesBounds = bNew;
 586     }
 587
 588     void Shift( USHORT nDir );
 589
 590     // sets a new color at the output device if necessary
 591     // if a font is passed as argument, the change if made to the font
 592     // otherwise the font at the output device is changed
 593     // returns if the font has been changed
 594     sal_Bool ApplyAutoColor( Font* pFnt = 0 );
 595 };
 596
 597 #endif