svx/source/cui/chardlg.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: chardlg.cxx,v $
  10  * $Revision: 1.102.148.1 $
  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_svx.hxx"
  33
  34 #ifdef SVX_DLLIMPLEMENTATION
  35 #undef SVX_DLLIMPLEMENTATION
  36 #endif
  37
  38 // include ---------------------------------------------------------------
  39 #include <unolingu.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <svtools/pathoptions.hxx>
  42 #include <svtools/ctrltool.hxx>
  43 #include <svtools/sfontitm.hxx>
  44 #include <sfx2/printer.hxx>
  45 #include <sfx2/objsh.hxx>
  46 #include <sfx2/viewsh.hxx>
  47 #include <sfx2/bindings.hxx>
  48 #include <sfx2/viewfrm.hxx>
  49 #include <vcl/msgbox.hxx>
  50
  51 #define _SVX_CHARDLG_CXX
  52 #include <svtools/languageoptions.hxx>
  53
  54 #include <svx/dialogs.hrc>
  55 #include <svx/svxitems.hrc>
  56 #include "chardlg.hrc"
  57
  58 //Erstmal definieren, damit die Klassendeklarionen angezogen werden.
  59
  60 #include <svx/xtable.hxx>               // XColorTable
  61 #include "chardlg.hxx"
  62 #include "fontitem.hxx"
  63 #include <svx/postitem.hxx>
  64 #include <svx/udlnitem.hxx>
  65 #include <svx/crsditem.hxx>
  66 #include <svx/cntritem.hxx>
  67 #include <svx/langitem.hxx>
  68 #include <svx/wghtitem.hxx>
  69 #include <svx/fhgtitem.hxx>
  70 #include <svx/shdditem.hxx>
  71 #include <svx/escpitem.hxx>
  72 #include <svx/prszitem.hxx>
  73 #include <svx/wrlmitem.hxx>
  74 #include <svx/cmapitem.hxx>
  75 #include <svx/kernitem.hxx>
  76 #include <svx/blnkitem.hxx>
  77 #include "flstitem.hxx"
  78 #include <svx/akrnitem.hxx>
  79 #include <svx/brshitem.hxx>
  80 #include <svx/colritem.hxx>
  81 #include "drawitem.hxx"
  82 #include "dlgutil.hxx"
  83 #include <svx/dialmgr.hxx>
  84 #include "htmlmode.hxx"
  85 #include "cuicharmap.hxx"
  86 #include "chardlg.h"
  87 #include <svx/emphitem.hxx>
  88 #include <svx/charreliefitem.hxx>
  89 #include <svx/twolinesitem.hxx>
  90 #include <charhiddenitem.hxx>
  91 #include <svtools/stritem.hxx>
  92 #include <svx/charscaleitem.hxx>
  93 #include <svx/charrotateitem.hxx>
  94 #include <svx/svxdlg.hxx> //CHINA001
  95 #include <svx/dialogs.hrc> //CHINA001
  96 #include <svtools/intitem.hxx> //CHINA001
  97 #include <sfx2/request.hxx> //CHINA001
  98 #include "flagsdef.hxx" //CHINA001
  99
 100 using namespace ::com::sun::star;
 101
 102 // define ----------------------------------------------------------------
 103
 104 #define ISITEMSET       rSet.GetItemState(nWhich)>=SFX_ITEM_DEFAULT
 105
 106 #define CLEARTITEM      rSet.InvalidateItem(nWhich)
 107
 108 #define LW_NORMAL       0
 109 #define LW_GESPERRT 1
 110 #define LW_SCHMAL       2
 111
 112 // static ----------------------------------------------------------------
 113
 114 static USHORT pNameRanges[] =
 115 {
 116     SID_ATTR_CHAR_FONT,
 117     SID_ATTR_CHAR_WEIGHT,
 118     SID_ATTR_CHAR_FONTHEIGHT,
 119     SID_ATTR_CHAR_FONTHEIGHT,
 120     SID_ATTR_CHAR_COLOR,
 121     SID_ATTR_CHAR_COLOR,
 122     SID_ATTR_CHAR_LANGUAGE,
 123     SID_ATTR_CHAR_LANGUAGE,
 124     SID_ATTR_CHAR_CJK_FONT,
 125     SID_ATTR_CHAR_CJK_WEIGHT,
 126     SID_ATTR_CHAR_CTL_FONT,
 127     SID_ATTR_CHAR_CTL_WEIGHT,
 128     0
 129 };
 130
 131 static USHORT pEffectsRanges[] =
 132 {
 133     SID_ATTR_CHAR_SHADOWED,
 134     SID_ATTR_CHAR_UNDERLINE,
 135     SID_ATTR_CHAR_COLOR,
 136     SID_ATTR_CHAR_COLOR,
 137     SID_ATTR_CHAR_CASEMAP,
 138     SID_ATTR_CHAR_CASEMAP,
 139     SID_ATTR_FLASH,
 140     SID_ATTR_FLASH,
 141     SID_ATTR_CHAR_EMPHASISMARK,
 142     SID_ATTR_CHAR_EMPHASISMARK,
 143     SID_ATTR_CHAR_RELIEF,
 144     SID_ATTR_CHAR_RELIEF,
 145     SID_ATTR_CHAR_HIDDEN,
 146     SID_ATTR_CHAR_HIDDEN,
 147     SID_ATTR_CHAR_OVERLINE,
 148     SID_ATTR_CHAR_OVERLINE,
 149     0
 150 };
 151
 152 static USHORT pPositionRanges[] =
 153 {
 154     SID_ATTR_CHAR_KERNING,
 155     SID_ATTR_CHAR_KERNING,
 156     SID_ATTR_CHAR_ESCAPEMENT,
 157     SID_ATTR_CHAR_ESCAPEMENT,
 158     SID_ATTR_CHAR_AUTOKERN,
 159     SID_ATTR_CHAR_AUTOKERN,
 160     SID_ATTR_CHAR_ROTATED,
 161     SID_ATTR_CHAR_SCALEWIDTH,
 162     SID_ATTR_CHAR_WIDTH_FIT_TO_LINE,
 163     SID_ATTR_CHAR_WIDTH_FIT_TO_LINE,
 164     0
 165 };
 166
 167 static USHORT pTwoLinesRanges[] =
 168 {
 169     SID_ATTR_CHAR_TWO_LINES,
 170     SID_ATTR_CHAR_TWO_LINES,
 171     0
 172 };
 173
 174 // C-Funktion ------------------------------------------------------------
 175
 176 inline BOOL StateToAttr( TriState aState )
 177 {
 178     return ( STATE_CHECK == aState );
 179 }
 180
 181 // class SvxCharBasePage -------------------------------------------------
 182
 183 inline SvxFont& SvxCharBasePage::GetPreviewFont()
 184 {
 185     return m_aPreviewWin.GetFont();
 186 }
 187
 188 // -----------------------------------------------------------------------
 189
 190 inline SvxFont& SvxCharBasePage::GetPreviewCJKFont()
 191 {
 192     return m_aPreviewWin.GetCJKFont();
 193 }
 194 // -----------------------------------------------------------------------
 195
 196 inline SvxFont& SvxCharBasePage::GetPreviewCTLFont()
 197 {
 198     return m_aPreviewWin.GetCTLFont();
 199 }
 200
 201 // -----------------------------------------------------------------------
 202
 203 SvxCharBasePage::SvxCharBasePage( Window* pParent, const ResId& rResId, const SfxItemSet& rItemset,
 204                                  USHORT nResIdPrewievWin, USHORT nResIdFontTypeFT ):
 205     SfxTabPage( pParent, rResId, rItemset ),
 206     m_aPreviewWin( this, ResId( nResIdPrewievWin, *rResId.GetResMgr() ) ),
 207     m_aFontTypeFT( this, ResId( nResIdFontTypeFT, *rResId.GetResMgr() ) ),
 208     m_bPreviewBackgroundToCharacter( FALSE )
 209 {
 210 }
 211
 212 // -----------------------------------------------------------------------
 213
 214 SvxCharBasePage::~SvxCharBasePage()
 215 {
 216 }
 217
 218 // -----------------------------------------------------------------------
 219
 220 //void SvxCharBasePage::SetPrevFontAttributes( const SfxItemSet& rSet )
 221 void SvxCharBasePage::ActivatePage( const SfxItemSet& rSet )
 222 {
 223     SvxFont&            rFont = GetPreviewFont();
 224     SvxFont&            rCJKFont = GetPreviewCJKFont();
 225     SvxFont&            rCTLFont = GetPreviewCTLFont();
 226     USHORT                      nWhich;
 227
 228     nWhich = GetWhich( SID_CHAR_DLG_PREVIEW_STRING );
 229     if( ISITEMSET )
 230     {
 231         const SfxStringItem& rItem = ( SfxStringItem& ) rSet.Get( nWhich );
 232         ::rtl::OUString aString = rItem.GetValue();
 233         if( aString.getLength() != 0 )
 234             m_aPreviewWin.SetPreviewText( aString );
 235         else
 236             m_aPreviewWin.SetFontNameAsPreviewText();
 237     }
 238
 239     // Underline
 240     FontUnderline eUnderline;
 241     nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
 242     if( ISITEMSET )
 243     {
 244         const SvxUnderlineItem& rItem = ( SvxUnderlineItem& ) rSet.Get( nWhich );
 245         eUnderline = ( FontUnderline ) rItem.GetValue();
 246         m_aPreviewWin.SetTextLineColor( rItem.GetColor() );
 247     }
 248     else
 249         eUnderline = UNDERLINE_NONE;
 250
 251     rFont.SetUnderline( eUnderline );
 252     rCJKFont.SetUnderline( eUnderline );
 253     rCTLFont.SetUnderline( eUnderline );
 254
 255     // Overline
 256     FontUnderline eOverline;
 257     nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
 258     if( ISITEMSET )
 259     {
 260         const SvxOverlineItem& rItem = ( SvxOverlineItem& ) rSet.Get( nWhich );
 261         eOverline = ( FontUnderline ) rItem.GetValue();
 262         m_aPreviewWin.SetOverlineColor( rItem.GetColor() );
 263     }
 264     else
 265         eOverline = UNDERLINE_NONE;
 266
 267     rFont.SetOverline( eOverline );
 268     rCJKFont.SetOverline( eOverline );
 269     rCTLFont.SetOverline( eOverline );
 270
 271     //  Strikeout
 272     FontStrikeout eStrikeout;
 273     nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
 274     if( ISITEMSET )
 275     {
 276         const SvxCrossedOutItem& rItem = ( SvxCrossedOutItem& ) rSet.Get( nWhich );
 277         eStrikeout = ( FontStrikeout ) rItem.GetValue();
 278     }
 279     else
 280         eStrikeout = STRIKEOUT_NONE;
 281
 282     rFont.SetStrikeout( eStrikeout );
 283     rCJKFont.SetStrikeout( eStrikeout );
 284     rCTLFont.SetStrikeout( eStrikeout );
 285
 286     // WordLineMode
 287     nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
 288     if( ISITEMSET )
 289     {
 290         const SvxWordLineModeItem& rItem = ( SvxWordLineModeItem& ) rSet.Get( nWhich );
 291         rFont.SetWordLineMode( rItem.GetValue() );
 292         rCJKFont.SetWordLineMode( rItem.GetValue() );
 293         rCTLFont.SetWordLineMode( rItem.GetValue() );
 294     }
 295
 296     // Emphasis
 297     nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
 298     if( ISITEMSET )
 299     {
 300         const SvxEmphasisMarkItem& rItem = ( SvxEmphasisMarkItem& ) rSet.Get( nWhich );
 301         FontEmphasisMark eMark = rItem.GetEmphasisMark();
 302         rFont.SetEmphasisMark( eMark );
 303         rCJKFont.SetEmphasisMark( eMark );
 304         rCTLFont.SetEmphasisMark( eMark );
 305     }
 306
 307     // Relief
 308     nWhich = GetWhich( SID_ATTR_CHAR_RELIEF );
 309     if( ISITEMSET )
 310     {
 311         const SvxCharReliefItem& rItem = ( SvxCharReliefItem& ) rSet.Get( nWhich );
 312         FontRelief eFontRelief = ( FontRelief ) rItem.GetValue();
 313         rFont.SetRelief( eFontRelief );
 314         rCJKFont.SetRelief( eFontRelief );
 315         rCTLFont.SetRelief( eFontRelief );
 316     }
 317
 318     // Effects
 319     nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
 320     if( ISITEMSET )
 321     {
 322         const SvxCaseMapItem& rItem = ( SvxCaseMapItem& ) rSet.Get( nWhich );
 323         SvxCaseMap eCaseMap = ( SvxCaseMap ) rItem.GetValue();
 324         rFont.SetCaseMap( eCaseMap );
 325         rCJKFont.SetCaseMap( eCaseMap );
 326         // #i78474# small caps do not exist in CTL fonts
 327         rCTLFont.SetCaseMap( eCaseMap == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : eCaseMap );
 328     }
 329
 330     // Outline
 331     nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
 332     if( ISITEMSET )
 333     {
 334         const SvxContourItem& rItem = ( SvxContourItem& ) rSet.Get( nWhich );
 335         BOOL bOutline = rItem.GetValue();
 336         rFont.SetOutline( bOutline );
 337         rCJKFont.SetOutline( bOutline );
 338         rCTLFont.SetOutline( bOutline );
 339     }
 340
 341     // Shadow
 342     nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
 343     if( ISITEMSET )
 344     {
 345         const SvxShadowedItem& rItem = ( SvxShadowedItem& ) rSet.Get( nWhich );
 346         BOOL bShadow = rItem.GetValue();
 347         rFont.SetShadow( bShadow );
 348         rCJKFont.SetShadow( bShadow );
 349         rCTLFont.SetShadow( bShadow );
 350     }
 351
 352     // Background
 353     BOOL bTransparent;
 354     nWhich = GetWhich( m_bPreviewBackgroundToCharacter ? SID_ATTR_BRUSH : SID_ATTR_BRUSH_CHAR );
 355     if( ISITEMSET )
 356     {
 357          const SvxBrushItem& rBrush = ( SvxBrushItem& ) rSet.Get( nWhich );
 358          const Color& rColor = rBrush.GetColor();
 359          bTransparent = rColor.GetTransparency() > 0;
 360          rFont.SetFillColor( rColor );
 361          rCJKFont.SetFillColor( rColor );
 362          rCTLFont.SetFillColor( rColor );
 363     }
 364     else
 365         bTransparent = TRUE;
 366
 367     rFont.SetTransparent( bTransparent );
 368     rCJKFont.SetTransparent( bTransparent );
 369     rCTLFont.SetTransparent( bTransparent );
 370
 371     Color aBackCol( COL_TRANSPARENT );
 372     if( !m_bPreviewBackgroundToCharacter )
 373     {
 374         nWhich = GetWhich( SID_ATTR_BRUSH );
 375         if( ISITEMSET )
 376         {
 377             const SvxBrushItem& rBrush = ( SvxBrushItem& ) rSet.Get( nWhich );
 378             if( GPOS_NONE == rBrush.GetGraphicPos() )
 379                 aBackCol = rBrush.GetColor();
 380         }
 381     }
 382     m_aPreviewWin.SetBackColor( aBackCol );
 383
 384     // Font
 385     SetPrevFont( rSet, SID_ATTR_CHAR_FONT, rFont );
 386     SetPrevFont( rSet, SID_ATTR_CHAR_CJK_FONT, rCJKFont );
 387     SetPrevFont( rSet, SID_ATTR_CHAR_CTL_FONT, rCTLFont );
 388
 389     // Style
 390     SetPrevFontStyle( rSet, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, rFont );
 391     SetPrevFontStyle( rSet, SID_ATTR_CHAR_CJK_POSTURE, SID_ATTR_CHAR_CJK_WEIGHT, rCJKFont );
 392     SetPrevFontStyle( rSet, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT, rCTLFont );
 393
 394     // Size
 395     SetPrevFontSize( rSet, SID_ATTR_CHAR_FONTHEIGHT, rFont );
 396     SetPrevFontSize( rSet, SID_ATTR_CHAR_CJK_FONTHEIGHT, rCJKFont );
 397     SetPrevFontSize( rSet, SID_ATTR_CHAR_CTL_FONTHEIGHT, rCTLFont );
 398
 399     // Color
 400     nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
 401     if( ISITEMSET )
 402     {
 403         const SvxColorItem& rItem = ( SvxColorItem& ) rSet.Get( nWhich );
 404         Color aCol( rItem.GetValue() );
 405         rFont.SetColor( aCol );
 406         rCJKFont.SetColor( aCol );
 407         rCTLFont.SetColor( aCol );
 408
 409         m_aPreviewWin.AutoCorrectFontColor();   // handle color COL_AUTO
 410     }
 411
 412     // Kerning
 413     nWhich = GetWhich( SID_ATTR_CHAR_KERNING );
 414     if( ISITEMSET )
 415     {
 416         const SvxKerningItem& rItem = ( SvxKerningItem& ) rSet.Get( nWhich );
 417         short nKern = ( short )
 418                         LogicToLogic( rItem.GetValue(), ( MapUnit ) rSet.GetPool()->GetMetric( nWhich ), MAP_TWIP );
 419         rFont.SetFixKerning( nKern );
 420         rCJKFont.SetFixKerning( nKern );
 421         rCTLFont.SetFixKerning( nKern );
 422     }
 423
 424     // Escapement
 425     nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
 426     const BYTE nProp = 100;
 427     short nEsc;
 428     BYTE nEscProp;
 429     if( ISITEMSET )
 430     {
 431         const SvxEscapementItem& rItem = ( SvxEscapementItem& ) rSet.Get( nWhich );
 432         nEsc = rItem.GetEsc();
 433         nEscProp = rItem.GetProp();
 434
 435         if( nEsc == DFLT_ESC_AUTO_SUPER )
 436             nEsc = DFLT_ESC_SUPER;
 437         else if( nEsc == DFLT_ESC_AUTO_SUB )
 438             nEsc = DFLT_ESC_SUB;
 439     }
 440     else
 441     {
 442         nEsc  = 0;
 443         nEscProp = 100;
 444     }
 445
 446     SetPrevFontEscapement( nProp, nEscProp, nEsc );
 447
 448     // Font width scale
 449     SetPrevFontWidthScale( rSet );
 450
 451     m_aPreviewWin.Invalidate();
 452 }
 453
 454 // -----------------------------------------------------------------------
 455
 456 void SvxCharBasePage::SetPrevFontSize( const SfxItemSet& rSet, USHORT nSlot, SvxFont& rFont )
 457 {
 458     USHORT nWhich = GetWhich( nSlot );
 459     long nH;
 460     if( rSet.GetItemState( nWhich ) >= SFX_ITEM_SET )
 461     {
 462         nH = LogicToLogic(      ( ( SvxFontHeightItem& ) rSet.Get( nWhich ) ).GetHeight(),
 463                             ( MapUnit ) rSet.GetPool()->GetMetric( nWhich ),
 464                             MAP_TWIP );
 465     }
 466     else
 467         nH = 240;       // as default 12pt
 468
 469     rFont.SetSize( Size( 0, nH ) );
 470 }
 471
 472 // -----------------------------------------------------------------------
 473
 474 void SvxCharBasePage::SetPrevFont( const SfxItemSet& rSet, USHORT nSlot, SvxFont& rFont )
 475 {
 476     USHORT nWhich = GetWhich( nSlot );
 477     if( ISITEMSET )
 478     {
 479         const SvxFontItem& rFontItem = ( SvxFontItem& ) rSet.Get( nWhich );
 480         rFont.SetFamily( rFontItem.GetFamily() );
 481         rFont.SetName( rFontItem.GetFamilyName() );
 482         rFont.SetPitch( rFontItem.GetPitch() );
 483         rFont.SetCharSet( rFontItem.GetCharSet() );
 484         rFont.SetStyleName( rFontItem.GetStyleName() );
 485     }
 486 }
 487
 488 // -----------------------------------------------------------------------
 489
 490 void SvxCharBasePage::SetPrevFontStyle( const SfxItemSet& rSet, USHORT nPosture, USHORT nWeight, SvxFont& rFont )
 491 {
 492     USHORT nWhich = GetWhich( nPosture );
 493     if( ISITEMSET )
 494     {
 495         const SvxPostureItem& rItem = ( SvxPostureItem& ) rSet.Get( nWhich );
 496         rFont.SetItalic( ( FontItalic ) rItem.GetValue() != ITALIC_NONE ? ITALIC_NORMAL : ITALIC_NONE );
 497     }
 498
 499     nWhich = GetWhich( nWeight );
 500     if( ISITEMSET )
 501     {
 502         SvxWeightItem& rItem = ( SvxWeightItem& ) rSet.Get( nWhich );
 503         rFont.SetWeight( ( FontWeight ) rItem.GetValue() != WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL );
 504     }
 505 }
 506
 507 // -----------------------------------------------------------------------
 508
 509 void SvxCharBasePage::SetPrevFontWidthScale( const SfxItemSet& rSet )
 510 {
 511     USHORT      nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
 512     if( ISITEMSET )
 513     {
 514         const SvxCharScaleWidthItem&    rItem = ( SvxCharScaleWidthItem& ) rSet.Get( nWhich );
 515
 516         m_aPreviewWin.SetFontWidthScale( rItem.GetValue() );
 517     }
 518 }
 519
 520 // -----------------------------------------------------------------------
 521 namespace
 522 {
 523     // -----------------------------------------------------------------------
 524     void setPrevFontEscapement(SvxFont& _rFont,BYTE nProp, BYTE nEscProp, short nEsc )
 525     {
 526         _rFont.SetPropr( nProp );
 527         _rFont.SetProprRel( nEscProp );
 528         _rFont.SetEscapement( nEsc );
 529     }
 530     // -----------------------------------------------------------------------
 531     // -----------------------------------------------------------------------
 532 }
 533 // -----------------------------------------------------------------------
 534
 535 void SvxCharBasePage::SetPrevFontEscapement( BYTE nProp, BYTE nEscProp, short nEsc )
 536 {
 537     setPrevFontEscapement(GetPreviewFont(),nProp,nEscProp,nEsc);
 538     setPrevFontEscapement(GetPreviewCJKFont(),nProp,nEscProp,nEsc);
 539     setPrevFontEscapement(GetPreviewCTLFont(),nProp,nEscProp,nEsc);
 540     m_aPreviewWin.Invalidate();
 541 }
 542
 543 // SvxCharNamePage_Impl --------------------------------------------------
 544
 545 struct SvxCharNamePage_Impl
 546 {
 547     Timer                       m_aUpdateTimer;
 548     String                      m_aNoStyleText;
 549     String                      m_aTransparentText;
 550     const FontList*     m_pFontList;
 551     USHORT                      m_nExtraEntryPos;
 552     BOOL                        m_bMustDelete;
 553     BOOL                        m_bInSearchMode;
 554
 555     SvxCharNamePage_Impl() :
 556
 557         m_pFontList             ( NULL ),
 558         m_nExtraEntryPos( LISTBOX_ENTRY_NOTFOUND ),
 559         m_bMustDelete   ( FALSE ),
 560         m_bInSearchMode ( FALSE )
 561
 562     {
 563         m_aUpdateTimer.SetTimeout( 350 );
 564     }
 565
 566     ~SvxCharNamePage_Impl()
 567     {
 568         if ( m_bMustDelete )
 569             delete m_pFontList;
 570     }
 571 };
 572
 573 // class SvxCharNamePage -------------------------------------------------
 574
 575 SvxCharNamePage::SvxCharNamePage( Window* pParent, const SfxItemSet& rInSet ) :
 576
 577     SvxCharBasePage( pParent, SVX_RES( RID_SVXPAGE_CHAR_NAME ), rInSet, WIN_CHAR_PREVIEW, FT_CHAR_FONTTYPE ),
 578     m_pImpl                 ( new SvxCharNamePage_Impl )
 579 {
 580     m_pImpl->m_aNoStyleText = String( SVX_RES( STR_CHARNAME_NOSTYLE ) );
 581     m_pImpl->m_aTransparentText = String( SVX_RES( STR_CHARNAME_TRANSPARENT ) );
 582
 583     SvtLanguageOptions aLanguageOptions;
 584     sal_Bool bCJK = ( aLanguageOptions.IsCJKFontEnabled() || aLanguageOptions.IsCTLFontEnabled() );
 585
 586     m_pWestLine         = new FixedLine( this, SVX_RES( FL_WEST ) );
 587     m_pWestFontNameFT   = new FixedText( this, SVX_RES( bCJK ? FT_WEST_NAME : FT_WEST_NAME_NOCJK ) );
 588     m_pWestFontNameLB   = new FontNameBox( this, SVX_RES( bCJK ? LB_WEST_NAME : LB_WEST_NAME_NOCJK ) );
 589     m_pWestFontStyleFT  = new FixedText( this, SVX_RES( bCJK ? FT_WEST_STYLE : FT_WEST_STYLE_NOCJK ) );
 590     m_pWestFontStyleLB  = new FontStyleBox( this, SVX_RES( bCJK ? LB_WEST_STYLE : LB_WEST_STYLE_NOCJK ) );
 591     m_pWestFontSizeFT   = new FixedText( this, SVX_RES( bCJK ? FT_WEST_SIZE : FT_WEST_SIZE_NOCJK ) );
 592     m_pWestFontSizeLB   = new FontSizeBox( this, SVX_RES( bCJK ? LB_WEST_SIZE : LB_WEST_SIZE_NOCJK ) );
 593
 594     if( !bCJK )
 595     {
 596         m_pColorFL  = new FixedLine( this, SVX_RES( FL_COLOR2 ) );
 597         m_pColorFT  = new FixedText( this, SVX_RES( FT_COLOR2 ) );
 598         m_pColorLB  = new ColorListBox( this, SVX_RES( LB_COLOR2 ) );
 599     }
 600
 601     m_pWestFontLanguageFT   = new FixedText( this, SVX_RES( bCJK ? FT_WEST_LANG : FT_WEST_LANG_NOCJK ) );
 602     m_pWestFontLanguageLB   = new SvxLanguageBox( this, SVX_RES( bCJK ? LB_WEST_LANG : LB_WEST_LANG_NOCJK ) );
 603
 604     m_pEastLine             = new FixedLine( this, SVX_RES( FL_EAST ) );
 605     m_pEastFontNameFT       = new FixedText( this, SVX_RES( FT_EAST_NAME ) );
 606     m_pEastFontNameLB       = new FontNameBox( this, SVX_RES( LB_EAST_NAME ) );
 607     m_pEastFontStyleFT      = new FixedText( this, SVX_RES( FT_EAST_STYLE ) );
 608     m_pEastFontStyleLB      = new FontStyleBox( this, SVX_RES( LB_EAST_STYLE ) );
 609     m_pEastFontSizeFT       = new FixedText( this, SVX_RES( FT_EAST_SIZE ) );
 610     m_pEastFontSizeLB       = new FontSizeBox( this, SVX_RES( LB_EAST_SIZE ) );
 611     m_pEastFontLanguageFT   = new FixedText( this, SVX_RES( FT_EAST_LANG ) );
 612     m_pEastFontLanguageLB   = new SvxLanguageBox( this, SVX_RES( LB_EAST_LANG ) );
 613
 614     m_pCTLLine              = new FixedLine( this, SVX_RES( FL_CTL ) );
 615     m_pCTLFontNameFT        = new FixedText( this, SVX_RES( FT_CTL_NAME ) );
 616     m_pCTLFontNameLB        = new FontNameBox( this, SVX_RES( LB_CTL_NAME ) );
 617     m_pCTLFontStyleFT           = new FixedText( this, SVX_RES( FT_CTL_STYLE ) );
 618     m_pCTLFontStyleLB           = new FontStyleBox( this, SVX_RES( LB_CTL_STYLE ) );
 619     m_pCTLFontSizeFT            = new FixedText( this, SVX_RES( FT_CTL_SIZE ) );
 620     m_pCTLFontSizeLB            = new FontSizeBox( this, SVX_RES( LB_CTL_SIZE ) );
 621     m_pCTLFontLanguageFT        = new FixedText( this, SVX_RES( FT_CTL_LANG ) );
 622     m_pCTLFontLanguageLB        = new SvxLanguageBox( this, SVX_RES( LB_CTL_LANG ) );
 623
 624     if( bCJK )
 625     {
 626         m_pColorFL  = new FixedLine( this, SVX_RES( FL_COLOR2 ) );
 627         m_pColorFT  = new FixedText( this, SVX_RES( FT_COLOR2 ) );
 628         m_pColorLB  = new ColorListBox( this, SVX_RES( LB_COLOR2 ) );
 629     }
 630
 631     m_pWestLine             ->Show( bCJK );
 632     m_pColorFL              ->Show( bCJK );
 633
 634     bCJK = aLanguageOptions.IsCJKFontEnabled();
 635     m_pEastLine             ->Show( bCJK );
 636     m_pEastFontNameFT       ->Show( bCJK );
 637     m_pEastFontNameLB       ->Show( bCJK );
 638     m_pEastFontStyleFT      ->Show( bCJK );
 639     m_pEastFontStyleLB      ->Show( bCJK );
 640     m_pEastFontSizeFT       ->Show( bCJK );
 641     m_pEastFontSizeLB       ->Show( bCJK );
 642     m_pEastFontLanguageFT   ->Show( bCJK );
 643     m_pEastFontLanguageLB   ->Show( bCJK );
 644
 645     sal_Bool bShowCTL = aLanguageOptions.IsCTLFontEnabled();
 646     if ( bShowCTL && !bCJK )
 647     {
 648         // move CTL controls to the places of the CJK controls, if these controls aren't visible
 649         m_pCTLLine             ->SetPosPixel( m_pEastLine->GetPosPixel() );
 650         m_pCTLFontNameFT       ->SetPosPixel( m_pEastFontNameFT->GetPosPixel() );
 651         m_pCTLFontNameLB       ->SetPosPixel( m_pEastFontNameLB->GetPosPixel() );
 652         m_pCTLFontStyleFT      ->SetPosPixel( m_pEastFontStyleFT->GetPosPixel() );
 653         m_pCTLFontStyleLB      ->SetPosPixel( m_pEastFontStyleLB->GetPosPixel() );
 654         m_pCTLFontSizeFT       ->SetPosPixel( m_pEastFontSizeFT->GetPosPixel() );
 655         m_pCTLFontSizeLB       ->SetPosPixel( m_pEastFontSizeLB->GetPosPixel() );
 656         m_pCTLFontLanguageFT   ->SetPosPixel( m_pEastFontLanguageFT->GetPosPixel() );
 657         m_pCTLFontLanguageLB   ->SetPosPixel( m_pEastFontLanguageLB->GetPosPixel() );
 658     }
 659     m_pCTLLine             ->Show( bShowCTL );
 660     m_pCTLFontNameFT       ->Show( bShowCTL );
 661     m_pCTLFontNameLB       ->Show( bShowCTL );
 662     m_pCTLFontStyleFT      ->Show( bShowCTL );
 663     m_pCTLFontStyleLB      ->Show( bShowCTL );
 664     m_pCTLFontSizeFT       ->Show( bShowCTL );
 665     m_pCTLFontSizeLB       ->Show( bShowCTL );
 666     m_pCTLFontLanguageFT   ->Show( bShowCTL );
 667     m_pCTLFontLanguageLB   ->Show( bShowCTL );
 668
 669     FreeResource();
 670
 671     m_pWestFontLanguageLB->SetLanguageList( LANG_LIST_WESTERN,  TRUE, FALSE, TRUE );
 672     m_pEastFontLanguageLB->SetLanguageList( LANG_LIST_CJK,              TRUE, FALSE, TRUE );
 673     m_pCTLFontLanguageLB->SetLanguageList( LANG_LIST_CTL,               TRUE, FALSE, TRUE );
 674
 675     Initialize();
 676 }
 677
 678 // -----------------------------------------------------------------------
 679
 680 SvxCharNamePage::~SvxCharNamePage()
 681 {
 682     delete m_pImpl;
 683
 684     delete m_pWestLine;
 685     delete m_pWestFontNameFT;
 686     delete m_pWestFontNameLB;
 687     delete m_pWestFontStyleFT;
 688     delete m_pWestFontStyleLB;
 689     delete m_pWestFontSizeFT;
 690     delete m_pWestFontSizeLB;
 691     delete m_pWestFontLanguageFT;
 692     delete m_pWestFontLanguageLB;
 693
 694     delete m_pEastLine;
 695     delete m_pEastFontNameFT;
 696     delete m_pEastFontNameLB;
 697     delete m_pEastFontStyleFT;
 698     delete m_pEastFontStyleLB;
 699     delete m_pEastFontSizeFT;
 700     delete m_pEastFontSizeLB;
 701     delete m_pEastFontLanguageFT;
 702     delete m_pEastFontLanguageLB;
 703
 704     delete m_pCTLLine;
 705     delete m_pCTLFontNameFT;
 706     delete m_pCTLFontNameLB;
 707     delete m_pCTLFontStyleFT;
 708     delete m_pCTLFontStyleLB;
 709     delete m_pCTLFontSizeFT;
 710     delete m_pCTLFontSizeLB;
 711     delete m_pCTLFontLanguageFT;
 712     delete m_pCTLFontLanguageLB;
 713
 714     delete m_pColorFL;
 715     delete m_pColorFT;
 716     delete m_pColorLB;
 717 }
 718
 719 // -----------------------------------------------------------------------
 720
 721 void SvxCharNamePage::Initialize()
 722 {
 723     // to handle the changes of the other pages
 724     SetExchangeSupport();
 725
 726     // fill the color box
 727     SfxObjectShell* pDocSh = SfxObjectShell::Current();
 728     //DBG_ASSERT( pDocSh, "DocShell not found!" );
 729     XColorTable* pColorTable = NULL;
 730     FASTBOOL bKillTable = FALSE;
 731     const SfxPoolItem* pItem = NULL;
 732
 733     if ( pDocSh )
 734     {
 735         pItem = pDocSh->GetItem( SID_COLOR_TABLE );
 736         if ( pItem != NULL )
 737             pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
 738     }
 739
 740     if ( !pColorTable )
 741     {
 742         pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
 743         bKillTable = TRUE;
 744     }
 745
 746     m_pColorLB->SetUpdateMode( FALSE );
 747
 748     {
 749         SfxPoolItem* pDummy;
 750         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocSh );
 751         if( !pFrame || SFX_ITEM_DEFAULT > pFrame->GetBindings().QueryState(
 752                                     SID_ATTR_AUTO_COLOR_INVALID, pDummy ))
 753             m_pColorLB->InsertEntry( Color( COL_AUTO ),
 754                                      SVX_RESSTR( RID_SVXSTR_AUTOMATIC ));
 755     }
 756     for ( long i = 0; i < pColorTable->Count(); i++ )
 757     {
 758         XColorEntry* pEntry = pColorTable->GetColor(i);
 759         m_pColorLB->InsertEntry( pEntry->GetColor(), pEntry->GetName() );
 760     }
 761
 762     m_pColorLB->SetUpdateMode( TRUE );
 763
 764     if ( bKillTable )
 765         delete pColorTable;
 766
 767     m_pColorLB->SetSelectHdl( LINK( this, SvxCharNamePage, ColorBoxSelectHdl_Impl ) );
 768
 769     Link aLink = LINK( this, SvxCharNamePage, FontModifyHdl_Impl );
 770     m_pWestFontNameLB->SetModifyHdl( aLink );
 771     m_pWestFontStyleLB->SetModifyHdl( aLink );
 772     m_pWestFontSizeLB->SetModifyHdl( aLink );
 773     m_pEastFontNameLB->SetModifyHdl( aLink );
 774     m_pEastFontStyleLB->SetModifyHdl( aLink );
 775     m_pEastFontSizeLB->SetModifyHdl( aLink );
 776     m_pCTLFontNameLB->SetModifyHdl( aLink );
 777     m_pCTLFontStyleLB->SetModifyHdl( aLink );
 778     m_pCTLFontSizeLB->SetModifyHdl( aLink );
 779
 780     m_pImpl->m_aUpdateTimer.SetTimeoutHdl( LINK( this, SvxCharNamePage, UpdateHdl_Impl ) );
 781
 782     m_pColorFL->Hide();
 783     m_pColorFT->Hide();
 784     m_pColorLB->Hide();
 785 }
 786
 787 // -----------------------------------------------------------------------
 788
 789 const FontList* SvxCharNamePage::GetFontList() const
 790 {
 791     if ( !m_pImpl->m_pFontList )
 792     {
 793         SfxObjectShell* pDocSh = SfxObjectShell::Current();
 794         const SfxPoolItem* pItem;
 795
 796         /* #110771# SvxFontListItem::GetFontList can return NULL */
 797         if ( pDocSh )
 798         {
 799             pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST );
 800             if ( pItem != NULL )
 801             {
 802                 DBG_ASSERT(NULL != ( (SvxFontListItem*)pItem )->GetFontList(),
 803                            "Where is the font list?");
 804                     m_pImpl->m_pFontList =  static_cast<const SvxFontListItem*>(pItem )->GetFontList()->Clone();
 805                 m_pImpl->m_bMustDelete = TRUE;
 806             }
 807         }
 808         if(!m_pImpl->m_pFontList)
 809         {
 810             m_pImpl->m_pFontList =
 811                 new FontList( Application::GetDefaultDevice() );
 812             m_pImpl->m_bMustDelete = TRUE;
 813         }
 814     }
 815
 816     return m_pImpl->m_pFontList;
 817 }
 818
 819 // -----------------------------------------------------------------------------
 820 namespace
 821 {
 822     FontInfo calcFontInfo(      SvxFont& _rFont,
 823                     SvxCharNamePage* _pPage,
 824                     const FontNameBox* _pFontNameLB,
 825                     const FontStyleBox* _pFontStyleLB,
 826                     const FontSizeBox* _pFontSizeLB,
 827                     const FontList* _pFontList,
 828                     USHORT _nFontWhich,
 829                     USHORT _nFontHeightWhich)
 830     {
 831         Size aSize = _rFont.GetSize();
 832         aSize.Width() = 0;
 833         FontInfo aFontInfo;
 834         String sFontName(_pFontNameLB->GetText());
 835         BOOL bFontAvailable = _pFontList->IsAvailable( sFontName );
 836         if(bFontAvailable  || _pFontNameLB->GetSavedValue() != sFontName)
 837             aFontInfo = _pFontList->Get( sFontName, _pFontStyleLB->GetText() );
 838         else
 839         {
 840             //get the font from itemset
 841             SfxItemState eState = _pPage->GetItemSet().GetItemState( _nFontWhich );
 842             if ( eState >= SFX_ITEM_DEFAULT )
 843             {
 844                 const SvxFontItem* pFontItem = (const SvxFontItem*)&( _pPage->GetItemSet().Get( _nFontWhich ) );
 845                 aFontInfo.SetName(pFontItem->GetFamilyName());
 846                 aFontInfo.SetStyleName(pFontItem->GetStyleName());
 847                 aFontInfo.SetFamily(pFontItem->GetFamily());
 848                 aFontInfo.SetPitch(pFontItem->GetPitch());
 849                 aFontInfo.SetCharSet(pFontItem->GetCharSet());
 850             }
 851         }
 852         if ( _pFontSizeLB->IsRelative() )
 853         {
 854             DBG_ASSERT( _pPage->GetItemSet().GetParent(), "No parent set" );
 855             const SvxFontHeightItem& rOldItem = (SvxFontHeightItem&)_pPage->GetItemSet().GetParent()->Get( _nFontHeightWhich );
 856
 857             // alter Wert, skaliert
 858             long nHeight;
 859             if ( _pFontSizeLB->IsPtRelative() )
 860                 nHeight = rOldItem.GetHeight() + PointToTwips( static_cast<long>(_pFontSizeLB->GetValue() / 10) );
 861             else
 862                 nHeight = static_cast<long>(rOldItem.GetHeight() * _pFontSizeLB->GetValue() / 100);
 863
 864             // Umrechnung in twips fuer das Beispiel-Window
 865             aSize.Height() =
 866                 ItemToControl( nHeight, _pPage->GetItemSet().GetPool()->GetMetric( _nFontHeightWhich ), SFX_FUNIT_TWIP );
 867         }
 868         else if ( _pFontSizeLB->GetText().Len() )
 869             aSize.Height() = PointToTwips( static_cast<long>(_pFontSizeLB->GetValue() / 10) );
 870         else
 871             aSize.Height() = 200;       // default 10pt
 872         aFontInfo.SetSize( aSize );
 873
 874         _rFont.SetFamily( aFontInfo.GetFamily() );
 875         _rFont.SetName( aFontInfo.GetName() );
 876         _rFont.SetStyleName( aFontInfo.GetStyleName() );
 877         _rFont.SetPitch( aFontInfo.GetPitch() );
 878         _rFont.SetCharSet( aFontInfo.GetCharSet() );
 879         _rFont.SetWeight( aFontInfo.GetWeight() );
 880         _rFont.SetItalic( aFontInfo.GetItalic() );
 881         _rFont.SetSize( aFontInfo.GetSize() );
 882
 883         return aFontInfo;
 884     }
 885 }
 886
 887 // -----------------------------------------------------------------------
 888
 889 void SvxCharNamePage::UpdatePreview_Impl()
 890 {
 891     SvxFont& rFont = GetPreviewFont();
 892     SvxFont& rCJKFont = GetPreviewCJKFont();
 893     SvxFont& rCTLFont = GetPreviewCTLFont();
 894     // Size
 895     Size aSize = rFont.GetSize();
 896     aSize.Width() = 0;
 897     Size aCJKSize = rCJKFont.GetSize();
 898     aCJKSize.Width() = 0;
 899     Size aCTLSize = rCTLFont.GetSize();
 900     aCTLSize.Width() = 0;
 901     // Font
 902     const FontList* pFontList = GetFontList();
 903     FontInfo aFontInfo =
 904         calcFontInfo(rFont,this,m_pWestFontNameLB,m_pWestFontStyleLB,m_pWestFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_FONT ),GetWhich( SID_ATTR_CHAR_FONTHEIGHT ));
 905
 906     calcFontInfo(rCJKFont,this,m_pEastFontNameLB,m_pEastFontStyleLB,m_pEastFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_CJK_FONT ),GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ));
 907
 908     calcFontInfo(rCTLFont,this,m_pCTLFontNameLB,m_pCTLFontStyleLB,m_pCTLFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_CTL_FONT ),GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ));
 909
 910     m_aPreviewWin.Invalidate();
 911     m_aFontTypeFT.SetText( pFontList->GetFontMapText( aFontInfo ) );
 912 }
 913
 914 // -----------------------------------------------------------------------
 915
 916 void SvxCharNamePage::FillStyleBox_Impl( const FontNameBox* pNameBox )
 917 {
 918     const FontList* pFontList = GetFontList();
 919     DBG_ASSERT( pFontList, "no fontlist" );
 920
 921     FontStyleBox* pStyleBox = NULL;
 922
 923     if ( m_pWestFontNameLB == pNameBox )
 924         pStyleBox = m_pWestFontStyleLB;
 925     else if ( m_pEastFontNameLB == pNameBox )
 926         pStyleBox = m_pEastFontStyleLB;
 927     else if ( m_pCTLFontNameLB == pNameBox )
 928         pStyleBox = m_pCTLFontStyleLB;
 929     else
 930     {
 931         DBG_ERRORFILE( "invalid font name box" );
 932     }
 933
 934     pStyleBox->Fill( pNameBox->GetText(), pFontList );
 935
 936     if ( m_pImpl->m_bInSearchMode )
 937     {
 938         // Bei der Suche zus"atzliche Eintr"age:
 939         // "Nicht Fett" und "Nicht Kursiv"
 940         String aEntry = m_pImpl->m_aNoStyleText;
 941         const sal_Char sS[] = "%1";
 942         aEntry.SearchAndReplaceAscii( sS, pFontList->GetBoldStr() );
 943         m_pImpl->m_nExtraEntryPos = pStyleBox->InsertEntry( aEntry );
 944         aEntry = m_pImpl->m_aNoStyleText;
 945         aEntry.SearchAndReplaceAscii( sS, pFontList->GetItalicStr() );
 946         pStyleBox->InsertEntry( aEntry );
 947     }
 948 }
 949
 950 // -----------------------------------------------------------------------
 951
 952 void SvxCharNamePage::FillSizeBox_Impl( const FontNameBox* pNameBox )
 953 {
 954     const FontList* pFontList = GetFontList();
 955     DBG_ASSERT( pFontList, "no fontlist" );
 956
 957     FontStyleBox* pStyleBox = NULL;
 958     FontSizeBox* pSizeBox = NULL;
 959
 960     if ( m_pWestFontNameLB == pNameBox )
 961     {
 962         pStyleBox = m_pWestFontStyleLB;
 963         pSizeBox = m_pWestFontSizeLB;
 964     }
 965     else if ( m_pEastFontNameLB == pNameBox )
 966     {
 967         pStyleBox = m_pEastFontStyleLB;
 968         pSizeBox = m_pEastFontSizeLB;
 969     }
 970     else if ( m_pCTLFontNameLB == pNameBox )
 971     {
 972         pStyleBox = m_pCTLFontStyleLB;
 973         pSizeBox = m_pCTLFontSizeLB;
 974     }
 975     else
 976     {
 977         DBG_ERRORFILE( "invalid font name box" );
 978     }
 979
 980     FontInfo _aFontInfo( pFontList->Get( pNameBox->GetText(), pStyleBox->GetText() ) );
 981     pSizeBox->Fill( &_aFontInfo, pFontList );
 982 }
 983
 984 // -----------------------------------------------------------------------
 985
 986 void SvxCharNamePage::Reset_Impl( const SfxItemSet& rSet, LanguageGroup eLangGrp )
 987 {
 988     FixedText* pNameLabel = NULL;
 989     FontNameBox* pNameBox = NULL;
 990     FixedText* pStyleLabel = NULL;
 991     FontStyleBox* pStyleBox = NULL;
 992     FixedText* pSizeLabel = NULL;
 993     FontSizeBox* pSizeBox = NULL;
 994     FixedText* pLangFT = NULL;
 995     SvxLanguageBox* pLangBox = NULL;
 996     USHORT nWhich = 0;
 997
 998     switch ( eLangGrp )
 999     {
1000         case Western :
1001             pNameLabel = m_pWestFontNameFT;
1002             pNameBox = m_pWestFontNameLB;
1003             pStyleLabel = m_pWestFontStyleFT;
1004             pStyleBox = m_pWestFontStyleLB;
1005             pSizeLabel = m_pWestFontSizeFT;
1006             pSizeBox = m_pWestFontSizeLB;
1007             pLangFT = m_pWestFontLanguageFT;
1008             pLangBox = m_pWestFontLanguageLB;
1009             nWhich = GetWhich( SID_ATTR_CHAR_FONT );
1010             break;
1011
1012         case Asian :
1013             pNameLabel = m_pEastFontNameFT;
1014             pNameBox = m_pEastFontNameLB;
1015             pStyleLabel = m_pEastFontStyleFT;
1016             pStyleBox = m_pEastFontStyleLB;
1017             pSizeLabel = m_pEastFontSizeFT;
1018             pSizeBox = m_pEastFontSizeLB;
1019             pLangFT = m_pEastFontLanguageFT;
1020             pLangBox = m_pEastFontLanguageLB;
1021             nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONT );
1022             break;
1023
1024         case Ctl :
1025             pNameLabel = m_pCTLFontNameFT;
1026             pNameBox = m_pCTLFontNameLB;
1027             pStyleLabel = m_pCTLFontStyleFT;
1028             pStyleBox = m_pCTLFontStyleLB;
1029             pSizeLabel = m_pCTLFontSizeFT;
1030             pSizeBox = m_pCTLFontSizeLB;
1031             pLangFT = m_pCTLFontLanguageFT;
1032             pLangBox = m_pCTLFontLanguageLB;
1033             nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONT );
1034             break;
1035     }
1036
1037     // die FontListBox fuellen
1038     const FontList* pFontList = GetFontList();
1039     pNameBox->Fill( pFontList );
1040
1041     // Font ermitteln
1042     const SvxFontItem* pFontItem = NULL;
1043     SfxItemState eState = rSet.GetItemState( nWhich );
1044
1045     if ( eState >= SFX_ITEM_DEFAULT )
1046     {
1047         pFontItem = (const SvxFontItem*)&( rSet.Get( nWhich ) );
1048         pNameBox->SetText( pFontItem->GetFamilyName() );
1049     }
1050     else
1051     {
1052         pNameBox->SetText( String() );
1053     }
1054
1055     FillStyleBox_Impl( pNameBox );
1056
1057     FASTBOOL bStyle = FALSE;
1058     FASTBOOL bStyleAvailable = TRUE;
1059     FontItalic eItalic = ITALIC_NONE;
1060     FontWeight eWeight = WEIGHT_NORMAL;
1061     switch ( eLangGrp )
1062     {
1063         case Western : nWhich = GetWhich( SID_ATTR_CHAR_POSTURE ); break;
1064         case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_POSTURE ); break;
1065         case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_POSTURE ); break;
1066     }
1067     eState = rSet.GetItemState( nWhich );
1068
1069     if ( eState >= SFX_ITEM_DEFAULT )
1070     {
1071         const SvxPostureItem& rItem = (SvxPostureItem&)rSet.Get( nWhich );
1072         eItalic = (FontItalic)rItem.GetValue();
1073         bStyle = TRUE;
1074     }
1075     bStyleAvailable = bStyleAvailable && (eState >= SFX_ITEM_DONTCARE);
1076
1077     switch ( eLangGrp )
1078     {
1079         case Western : nWhich = GetWhich( SID_ATTR_CHAR_WEIGHT ); break;
1080         case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_WEIGHT ); break;
1081         case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_WEIGHT ); break;
1082     }
1083     eState = rSet.GetItemState( nWhich );
1084
1085     if ( eState >= SFX_ITEM_DEFAULT )
1086     {
1087         SvxWeightItem& rItem = (SvxWeightItem&)rSet.Get( nWhich );
1088         eWeight = (FontWeight)rItem.GetValue();
1089     }
1090     else
1091         bStyle = FALSE;
1092     bStyleAvailable = bStyleAvailable && (eState >= SFX_ITEM_DONTCARE);
1093
1094     // Aktuell eingestellter Font
1095     if ( bStyle && pFontItem )
1096     {
1097         FontInfo aInfo = pFontList->Get( pFontItem->GetFamilyName(), eWeight, eItalic );
1098         pStyleBox->SetText( pFontList->GetStyleName( aInfo ) );
1099     }
1100     else if ( !m_pImpl->m_bInSearchMode || !bStyle )
1101     {
1102         pStyleBox->SetText( String() );
1103     }
1104     else if ( bStyle )
1105     {
1106         FontInfo aInfo = pFontList->Get( String(), eWeight, eItalic );
1107         pStyleBox->SetText( pFontList->GetStyleName( aInfo ) );
1108     }
1109     if (!bStyleAvailable)
1110     {
1111         pStyleBox->Disable( );
1112         pStyleLabel->Disable( );
1113     }
1114
1115     // SizeBox fuellen
1116     FillSizeBox_Impl( pNameBox );
1117     switch ( eLangGrp )
1118     {
1119         case Western : nWhich = GetWhich( SID_ATTR_CHAR_FONTHEIGHT ); break;
1120         case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ); break;
1121         case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ); break;
1122     }
1123     eState = rSet.GetItemState( nWhich );
1124
1125     if ( pSizeBox->IsRelativeMode() )
1126     {
1127         SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
1128         const SvxFontHeightItem& rItem = (SvxFontHeightItem&)rSet.Get( nWhich );
1129
1130         if( rItem.GetProp() != 100 || SFX_MAPUNIT_RELATIVE != rItem.GetPropUnit() )
1131         {
1132             BOOL bPtRel = SFX_MAPUNIT_POINT == rItem.GetPropUnit();
1133             pSizeBox->SetPtRelative( bPtRel );
1134             pSizeBox->SetValue( bPtRel ? ((short)rItem.GetProp()) * 10 : rItem.GetProp() );
1135         }
1136         else
1137         {
1138             pSizeBox->SetRelative();
1139             pSizeBox->SetValue( (long)CalcToPoint( rItem.GetHeight(), eUnit, 10 ) );
1140         }
1141     }
1142     else if ( eState >= SFX_ITEM_DEFAULT )
1143     {
1144         SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
1145         const SvxFontHeightItem& rItem = (SvxFontHeightItem&)rSet.Get( nWhich );
1146         pSizeBox->SetValue( (long)CalcToPoint( rItem.GetHeight(), eUnit, 10 ) );
1147     }
1148     else
1149     {
1150         pSizeBox->SetText( String() );
1151         if ( eState <= SFX_ITEM_READONLY )
1152         {
1153             pSizeBox->Disable( );
1154             pSizeLabel->Disable( );
1155         }
1156     }
1157
1158     switch ( eLangGrp )
1159     {
1160         case Western : nWhich = GetWhich( SID_ATTR_CHAR_LANGUAGE ); break;
1161         case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_LANGUAGE ); break;
1162         case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_LANGUAGE ); break;
1163     }
1164     pLangBox->SetNoSelection();
1165     eState = rSet.GetItemState( nWhich );
1166
1167     switch ( eState )
1168     {
1169         case SFX_ITEM_UNKNOWN:
1170             pLangFT->Hide();
1171             pLangBox->Hide();
1172             break;
1173
1174         case SFX_ITEM_DISABLED:
1175         case SFX_ITEM_READONLY:
1176             pLangFT->Disable();
1177             pLangBox->Disable();
1178             break;
1179
1180         case SFX_ITEM_DEFAULT:
1181         case SFX_ITEM_SET:
1182         {
1183             const SvxLanguageItem& rItem = (SvxLanguageItem&)rSet.Get( nWhich );
1184             LanguageType eLangType = (LanguageType)rItem.GetValue();
1185             DBG_ASSERT( eLangType != LANGUAGE_SYSTEM, "LANGUAGE_SYSTEM not allowed" );
1186             if ( eLangType != LANGUAGE_DONTKNOW )
1187                 pLangBox->SelectLanguage( eLangType );
1188             break;
1189         }
1190     }
1191
1192     if ( Western == eLangGrp )
1193         m_aFontTypeFT.SetText( pFontList->GetFontMapText(
1194             pFontList->Get( pNameBox->GetText(), pStyleBox->GetText() ) ) );
1195
1196     // save these settings
1197     pNameBox->SaveValue();
1198     pStyleBox->SaveValue();
1199     pSizeBox->SaveValue();
1200     pLangBox->SaveValue();
1201 }
1202
1203 // -----------------------------------------------------------------------
1204
1205 BOOL SvxCharNamePage::FillItemSet_Impl( SfxItemSet& rSet, LanguageGroup eLangGrp )
1206 {
1207     BOOL bModified = FALSE;
1208
1209     FontNameBox* pNameBox = NULL;
1210     FontStyleBox* pStyleBox = NULL;
1211     FontSizeBox* pSizeBox = NULL;
1212     SvxLanguageBox* pLangBox = NULL;
1213     USHORT nWhich = 0;
1214     USHORT nSlot = 0;
1215
1216     switch ( eLangGrp )
1217     {
1218         case Western :
1219             pNameBox = m_pWestFontNameLB;
1220             pStyleBox = m_pWestFontStyleLB;
1221             pSizeBox = m_pWestFontSizeLB;
1222             pLangBox = m_pWestFontLanguageLB;
1223             nSlot = SID_ATTR_CHAR_FONT;
1224             break;
1225
1226         case Asian :
1227             pNameBox = m_pEastFontNameLB;
1228             pStyleBox = m_pEastFontStyleLB;
1229             pSizeBox = m_pEastFontSizeLB;
1230             pLangBox = m_pEastFontLanguageLB;
1231             nSlot = SID_ATTR_CHAR_CJK_FONT;
1232             break;
1233
1234         case Ctl :
1235             pNameBox = m_pCTLFontNameLB;
1236             pStyleBox = m_pCTLFontStyleLB;
1237             pSizeBox = m_pCTLFontSizeLB;
1238             pLangBox = m_pCTLFontLanguageLB;
1239             nSlot = SID_ATTR_CHAR_CTL_FONT;
1240             break;
1241     }
1242
1243     nWhich = GetWhich( nSlot );
1244     const SfxPoolItem* pItem = NULL;
1245     const SfxItemSet& rOldSet = GetItemSet();
1246     const SfxPoolItem* pOld = NULL;
1247
1248     const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
1249
1250     FASTBOOL bChanged = TRUE;
1251     const String& rFontName  = pNameBox->GetText();
1252     const FontList* pFontList = GetFontList();
1253     String aStyleBoxText =pStyleBox->GetText();
1254     USHORT nEntryPos = pStyleBox->GetEntryPos( aStyleBoxText );
1255     if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
1256         aStyleBoxText.Erase();
1257     FontInfo aInfo( pFontList->Get( rFontName, aStyleBoxText ) );
1258     SvxFontItem aFontItem( aInfo.GetFamily(), aInfo.GetName(), aInfo.GetStyleName(),
1259                            aInfo.GetPitch(), aInfo.GetCharSet(), nWhich );
1260     pOld = GetOldItem( rSet, nSlot );
1261
1262     if ( pOld )
1263     {
1264         const SvxFontItem& rItem = *( (const SvxFontItem*)pOld );
1265
1266         if ( rItem.GetFamilyName() == aFontItem.GetFamilyName() )
1267             bChanged = FALSE;
1268     }
1269
1270     if ( !bChanged )
1271         bChanged = !pNameBox->GetSavedValue().Len();
1272
1273     if ( !bChanged && pExampleSet &&
1274          pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
1275          ( (SvxFontItem*)pItem )->GetFamilyName() != aFontItem.GetFamilyName() )
1276         bChanged = TRUE;
1277
1278     if ( bChanged && rFontName.Len() )
1279     {
1280         rSet.Put( aFontItem );
1281         bModified |= TRUE;
1282     }
1283     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1284         rSet.ClearItem( nWhich );
1285
1286
1287     bChanged = TRUE;
1288     switch ( eLangGrp )
1289     {
1290         case Western : nSlot = SID_ATTR_CHAR_WEIGHT; break;
1291         case Asian : nSlot = SID_ATTR_CHAR_CJK_WEIGHT; break;
1292         case Ctl : nSlot = SID_ATTR_CHAR_CTL_WEIGHT; break;
1293     }
1294     nWhich = GetWhich( nSlot );
1295     FontWeight eWeight = aInfo.GetWeight();
1296     if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
1297         eWeight = WEIGHT_NORMAL;
1298     SvxWeightItem aWeightItem( eWeight, nWhich );
1299     pOld = GetOldItem( rSet, nSlot );
1300
1301     if ( pOld )
1302     {
1303         const SvxWeightItem& rItem = *( (const SvxWeightItem*)pOld );
1304
1305         if ( rItem.GetValue() == aWeightItem.GetValue() )
1306             bChanged = FALSE;
1307     }
1308
1309     if ( !bChanged )
1310     {
1311         bChanged = !pStyleBox->GetSavedValue().Len();
1312
1313         if ( m_pImpl->m_bInSearchMode && bChanged &&
1314              aInfo.GetWeight() == WEIGHT_NORMAL && aInfo.GetItalic() != ITALIC_NONE )
1315             bChanged = FALSE;
1316     }
1317
1318     if ( !bChanged && pExampleSet &&
1319          pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
1320          ( (SvxWeightItem*)pItem )->GetValue() != aWeightItem.GetValue() )
1321         bChanged = TRUE;
1322
1323     if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
1324         bChanged = ( nEntryPos == m_pImpl->m_nExtraEntryPos );
1325
1326     String aText( pStyleBox->GetText() ); // Tristate, dann Text leer
1327
1328     if ( bChanged && aText.Len() )
1329     {
1330         rSet.Put( aWeightItem );
1331         bModified |= TRUE;
1332     }
1333     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1334         CLEARTITEM;
1335
1336     bChanged = TRUE;
1337     switch ( eLangGrp )
1338     {
1339         case Western : nSlot = SID_ATTR_CHAR_POSTURE; break;
1340         case Asian : nSlot = SID_ATTR_CHAR_CJK_POSTURE; break;
1341         case Ctl : nSlot = SID_ATTR_CHAR_CTL_POSTURE; break;
1342     }
1343     nWhich = GetWhich( nSlot );
1344     FontItalic eItalic = aInfo.GetItalic();
1345     if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
1346         eItalic = ITALIC_NONE;
1347     SvxPostureItem aPostureItem( eItalic, nWhich );
1348     pOld = GetOldItem( rSet, nSlot );
1349
1350     if ( pOld )
1351     {
1352         const SvxPostureItem& rItem = *( (const SvxPostureItem*)pOld );
1353
1354         if ( rItem.GetValue() == aPostureItem.GetValue() )
1355             bChanged = FALSE;
1356     }
1357
1358     if ( !bChanged )
1359     {
1360         bChanged = !pStyleBox->GetSavedValue().Len();
1361
1362         if ( m_pImpl->m_bInSearchMode && bChanged &&
1363              aInfo.GetItalic() == ITALIC_NONE && aInfo.GetWeight() != WEIGHT_NORMAL )
1364             bChanged = FALSE;
1365     }
1366
1367     if ( !bChanged && pExampleSet &&
1368          pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
1369          ( (SvxPostureItem*)pItem )->GetValue() != aPostureItem.GetValue() )
1370         bChanged = TRUE;
1371
1372     if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
1373         bChanged = ( nEntryPos == ( m_pImpl->m_nExtraEntryPos + 1 ) );
1374
1375     if ( bChanged && aText.Len() )
1376     {
1377         rSet.Put( aPostureItem );
1378         bModified |= TRUE;
1379     }
1380     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1381         CLEARTITEM;
1382
1383     // FontSize
1384     long nSize = static_cast<long>(pSizeBox->GetValue());
1385
1386     if ( !pSizeBox->GetText().Len() )   // GetValue() gibt dann Min-Wert zurueck
1387         nSize = 0;
1388     long nSavedSize = pSizeBox->GetSavedValue().ToInt32();
1389     FASTBOOL bRel = TRUE;
1390
1391     if ( !pSizeBox->IsRelative() )
1392     {
1393         nSavedSize *= 10;
1394         bRel = FALSE;
1395     }
1396
1397     switch ( eLangGrp )
1398     {
1399         case Western : nSlot = SID_ATTR_CHAR_FONTHEIGHT; break;
1400         case Asian : nSlot = SID_ATTR_CHAR_CJK_FONTHEIGHT; break;
1401         case Ctl : nSlot = SID_ATTR_CHAR_CTL_FONTHEIGHT; break;
1402     }
1403     nWhich = GetWhich( nSlot );
1404     const SvxFontHeightItem* pOldHeight = (const SvxFontHeightItem*)GetOldItem( rSet, nSlot );
1405     bChanged = ( nSize != nSavedSize );
1406
1407     if ( !bChanged && pExampleSet &&
1408          pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET )
1409     {
1410         float fSize = (float)nSize / 10;
1411         long nVal = CalcToUnit( fSize, rSet.GetPool()->GetMetric( nWhich ) );
1412         if ( ( (SvxFontHeightItem*)pItem )->GetHeight() != (UINT32)nVal )
1413             bChanged = TRUE;
1414     }
1415
1416     if ( bChanged || !pOldHeight ||
1417          bRel != ( SFX_MAPUNIT_RELATIVE != pOldHeight->GetPropUnit() || 100 != pOldHeight->GetProp() ) )
1418     {
1419         SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
1420         if ( pSizeBox->IsRelative() )
1421         {
1422             DBG_ASSERT( GetItemSet().GetParent(), "No parent set" );
1423             const SvxFontHeightItem& rOldItem =
1424                 (const SvxFontHeightItem&)GetItemSet().GetParent()->Get( nWhich );
1425
1426             SvxFontHeightItem aHeight( 240, 100, nWhich );
1427             if ( pSizeBox->IsPtRelative() )
1428                 aHeight.SetHeight( rOldItem.GetHeight(), (USHORT)( nSize / 10 ), SFX_MAPUNIT_POINT, eUnit );
1429             else
1430                 aHeight.SetHeight( rOldItem.GetHeight(), (USHORT)nSize, SFX_MAPUNIT_RELATIVE );
1431             rSet.Put( aHeight );
1432         }
1433         else
1434         {
1435             float fSize = (float)nSize / 10;
1436             rSet.Put( SvxFontHeightItem( CalcToUnit( fSize, eUnit ), 100, nWhich ) );
1437         }
1438         bModified |= TRUE;
1439     }
1440     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1441         CLEARTITEM;
1442
1443     bChanged = TRUE;
1444     switch ( eLangGrp )
1445     {
1446         case Western : nSlot = SID_ATTR_CHAR_LANGUAGE; break;
1447         case Asian : nSlot = SID_ATTR_CHAR_CJK_LANGUAGE; break;
1448         case Ctl : nSlot = SID_ATTR_CHAR_CTL_LANGUAGE; break;
1449     }
1450     nWhich = GetWhich( nSlot );
1451     pOld = GetOldItem( rSet, nSlot );
1452     USHORT nLangPos = pLangBox->GetSelectEntryPos();
1453     LanguageType eLangType = (LanguageType)(ULONG)pLangBox->GetEntryData( nLangPos );
1454
1455     if ( pOld )
1456     {
1457         const SvxLanguageItem& rItem = *( (const SvxLanguageItem*)pOld );
1458
1459         if ( nLangPos == LISTBOX_ENTRY_NOTFOUND || eLangType == (LanguageType)rItem.GetValue() )
1460             bChanged = FALSE;
1461     }
1462
1463     if ( !bChanged )
1464         bChanged = ( pLangBox->GetSavedValue() == LISTBOX_ENTRY_NOTFOUND );
1465
1466     if ( bChanged && nLangPos != LISTBOX_ENTRY_NOTFOUND )
1467     {
1468         rSet.Put( SvxLanguageItem( eLangType, nWhich ) );
1469         bModified |= TRUE;
1470     }
1471     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1472         CLEARTITEM;
1473
1474     return bModified;
1475 }
1476
1477 // -----------------------------------------------------------------------
1478
1479 void SvxCharNamePage::ResetColor_Impl( const SfxItemSet& rSet )
1480 {
1481     USHORT nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
1482     SfxItemState eState = rSet.GetItemState( nWhich );
1483
1484     switch ( eState )
1485     {
1486         case SFX_ITEM_UNKNOWN:
1487             m_pColorLB->Hide();
1488             break;
1489
1490         case SFX_ITEM_DISABLED:
1491         case SFX_ITEM_READONLY:
1492             m_pColorLB->Disable();
1493             break;
1494
1495         case SFX_ITEM_DONTCARE:
1496             m_pColorLB->SetNoSelection();
1497             break;
1498
1499         case SFX_ITEM_DEFAULT:
1500         case SFX_ITEM_SET:
1501         {
1502             SvxFont& rFont = GetPreviewFont();
1503             SvxFont& rCJKFont = GetPreviewCJKFont();
1504             SvxFont& rCTLFont = GetPreviewCTLFont();
1505             const SvxColorItem& rItem = (SvxColorItem&)rSet.Get( nWhich );
1506             Color aColor = rItem.GetValue();
1507             rFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
1508             rCJKFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
1509             rCTLFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
1510             m_aPreviewWin.Invalidate();
1511             USHORT nSelPos = m_pColorLB->GetEntryPos( aColor );
1512             if ( nSelPos == LISTBOX_ENTRY_NOTFOUND && aColor == Color( COL_TRANSPARENT ) )
1513                 nSelPos = m_pColorLB->GetEntryPos( m_pImpl->m_aTransparentText );
1514
1515             if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
1516                 m_pColorLB->SelectEntryPos( nSelPos );
1517             else
1518             {
1519                 nSelPos = m_pColorLB->GetEntryPos( aColor );
1520                 if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
1521                     m_pColorLB->SelectEntryPos( nSelPos );
1522                 else
1523                     m_pColorLB->SelectEntryPos(
1524                         m_pColorLB->InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
1525             }
1526             break;
1527         }
1528     }
1529 }
1530
1531 // -----------------------------------------------------------------------
1532
1533 BOOL SvxCharNamePage::FillItemSetColor_Impl( SfxItemSet& rSet )
1534 {
1535     USHORT nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
1536     const SvxColorItem* pOld = (const SvxColorItem*)GetOldItem( rSet, SID_ATTR_CHAR_COLOR );
1537     const SvxColorItem* pItem = NULL;
1538     BOOL bChanged = TRUE;
1539     const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
1540     const SfxItemSet& rOldSet = GetItemSet();
1541
1542     Color aSelectedColor;
1543     if ( m_pColorLB->GetSelectEntry() == m_pImpl->m_aTransparentText )
1544         aSelectedColor = Color( COL_TRANSPARENT );
1545     else
1546         aSelectedColor = m_pColorLB->GetSelectEntryColor();
1547
1548     if ( pOld && pOld->GetValue() == aSelectedColor )
1549         bChanged = FALSE;
1550
1551     if ( !bChanged )
1552         bChanged = ( m_pColorLB->GetSavedValue() == LISTBOX_ENTRY_NOTFOUND );
1553
1554     if ( !bChanged && pExampleSet &&
1555          pExampleSet->GetItemState( nWhich, FALSE, (const SfxPoolItem**)&pItem ) == SFX_ITEM_SET &&
1556          ( (SvxColorItem*)pItem )->GetValue() != aSelectedColor )
1557         bChanged = TRUE;
1558
1559     BOOL bModified = FALSE;
1560
1561     if ( bChanged && m_pColorLB->GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND )
1562     {
1563         rSet.Put( SvxColorItem( aSelectedColor, nWhich ) );
1564         bModified = TRUE;
1565     }
1566     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1567         CLEARTITEM;
1568
1569     return bModified;
1570 }
1571
1572 // -----------------------------------------------------------------------
1573
1574 IMPL_LINK( SvxCharNamePage, UpdateHdl_Impl, Timer*, EMPTYARG )
1575 {
1576     UpdatePreview_Impl();
1577     return 0;
1578 }
1579
1580 // -----------------------------------------------------------------------
1581
1582 IMPL_LINK( SvxCharNamePage, FontModifyHdl_Impl, void*, pNameBox )
1583 {
1584     m_pImpl->m_aUpdateTimer.Start();
1585
1586     if ( m_pWestFontNameLB == pNameBox || m_pEastFontNameLB == pNameBox || m_pCTLFontNameLB == pNameBox )
1587     {
1588         FillStyleBox_Impl( (FontNameBox*)pNameBox );
1589         FillSizeBox_Impl( (FontNameBox*)pNameBox );
1590     }
1591     return 0;
1592 }
1593
1594 // -----------------------------------------------------------------------
1595
1596 IMPL_LINK( SvxCharNamePage, ColorBoxSelectHdl_Impl, ColorListBox*, pBox )
1597 {
1598     SvxFont& rFont = GetPreviewFont();
1599     SvxFont& rCJKFont = GetPreviewCJKFont();
1600     SvxFont& rCTLFont = GetPreviewCTLFont();
1601     Color aSelectedColor;
1602     if ( pBox->GetSelectEntry() == m_pImpl->m_aTransparentText )
1603         aSelectedColor = Color( COL_TRANSPARENT );
1604     else
1605         aSelectedColor = pBox->GetSelectEntryColor();
1606     rFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
1607     rCJKFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
1608     rCTLFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
1609     m_aPreviewWin.Invalidate();
1610     return 0;
1611 }
1612
1613 // -----------------------------------------------------------------------
1614
1615 void SvxCharNamePage::ActivatePage( const SfxItemSet& rSet )
1616 {
1617     SvxCharBasePage::ActivatePage( rSet );
1618
1619     UpdatePreview_Impl();               // instead of asynchronous calling in ctor
1620 }
1621
1622 // -----------------------------------------------------------------------
1623
1624 int SvxCharNamePage::DeactivatePage( SfxItemSet* _pSet )
1625 {
1626     if ( _pSet )
1627         FillItemSet( *_pSet );
1628     return LEAVE_PAGE;
1629 }
1630
1631 // -----------------------------------------------------------------------
1632
1633 SfxTabPage* SvxCharNamePage::Create( Window* pParent, const SfxItemSet& rSet )
1634 {
1635     return new SvxCharNamePage( pParent, rSet );
1636 }
1637
1638 // -----------------------------------------------------------------------
1639
1640 USHORT* SvxCharNamePage::GetRanges()
1641 {
1642     return pNameRanges;
1643 }
1644
1645 // -----------------------------------------------------------------------
1646
1647 void SvxCharNamePage::Reset( const SfxItemSet& rSet )
1648 {
1649     Reset_Impl( rSet, Western );
1650     Reset_Impl( rSet, Asian );
1651     Reset_Impl( rSet, Ctl );
1652     ResetColor_Impl( rSet );
1653     m_pColorLB->SaveValue();
1654
1655     SetPrevFontWidthScale( rSet );
1656     UpdatePreview_Impl();
1657 }
1658
1659 // -----------------------------------------------------------------------
1660
1661 BOOL SvxCharNamePage::FillItemSet( SfxItemSet& rSet )
1662 {
1663     BOOL bModified = FillItemSet_Impl( rSet, Western );
1664     bModified |= FillItemSet_Impl( rSet, Asian );
1665     bModified |= FillItemSet_Impl( rSet, Ctl );
1666 //!     bModified |= FillItemSetColor_Impl( rSet );
1667     return bModified;
1668 }
1669
1670 // -----------------------------------------------------------------------
1671
1672 void SvxCharNamePage::SetFontList( const SvxFontListItem& rItem )
1673 {
1674     if ( m_pImpl->m_bMustDelete )
1675     {
1676         delete m_pImpl->m_pFontList;
1677     }
1678     m_pImpl->m_pFontList = rItem.GetFontList()->Clone();
1679     m_pImpl->m_bMustDelete = TRUE;
1680 }
1681
1682 // -----------------------------------------------------------------------
1683 namespace
1684 {
1685     void enableRelativeMode( SvxCharNamePage* _pPage, FontSizeBox* _pFontSizeLB, USHORT _nHeightWhich )
1686     {
1687         _pFontSizeLB->EnableRelativeMode( 5, 995, 5 ); // min 5%, max 995%, step 5
1688
1689         const SvxFontHeightItem& rHeightItem =
1690             (SvxFontHeightItem&)_pPage->GetItemSet().GetParent()->Get( _nHeightWhich );
1691         SfxMapUnit eUnit = _pPage->GetItemSet().GetPool()->GetMetric( _nHeightWhich );
1692         short nCurHeight =
1693             static_cast< short >( CalcToPoint( rHeightItem.GetHeight(), eUnit, 1 ) * 10 );
1694
1695         // ausgehend von der akt. Hoehe:
1696         //              - negativ bis minimal 2 pt
1697         //              - positiv bis maximal 999 pt
1698         _pFontSizeLB->EnablePtRelativeMode( sal::static_int_cast< short >(-(nCurHeight - 20)), (9999 - nCurHeight), 10 );
1699     }
1700 }
1701 // -----------------------------------------------------------------------------
1702
1703 void SvxCharNamePage::EnableRelativeMode()
1704 {
1705     DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no ParentSet!" );
1706     enableRelativeMode(this,m_pWestFontSizeLB,GetWhich( SID_ATTR_CHAR_FONTHEIGHT ));
1707     enableRelativeMode(this,m_pEastFontSizeLB,GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ));
1708     enableRelativeMode(this,m_pCTLFontSizeLB,GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ));
1709 }
1710
1711 // -----------------------------------------------------------------------
1712
1713 void SvxCharNamePage::EnableSearchMode()
1714 {
1715     m_pImpl->m_bInSearchMode = TRUE;
1716 }
1717 // -----------------------------------------------------------------------
1718 void SvxCharNamePage::DisableControls( USHORT nDisable )
1719 {
1720     if ( DISABLE_LANGUAGE & nDisable )
1721     {
1722         if ( m_pWestFontLanguageFT ) m_pWestFontLanguageFT->Disable();
1723         if ( m_pWestFontLanguageLB ) m_pWestFontLanguageLB->Disable();
1724         if ( m_pEastFontLanguageFT ) m_pEastFontLanguageFT->Disable();
1725         if ( m_pEastFontLanguageLB ) m_pEastFontLanguageLB->Disable();
1726         if ( m_pCTLFontLanguageFT ) m_pCTLFontLanguageFT->Disable();
1727         if ( m_pCTLFontLanguageLB ) m_pCTLFontLanguageLB->Disable();
1728     }
1729
1730     if ( DISABLE_HIDE_LANGUAGE & nDisable )
1731     {
1732         if ( m_pWestFontLanguageFT ) m_pWestFontLanguageFT->Hide();
1733         if ( m_pWestFontLanguageLB ) m_pWestFontLanguageLB->Hide();
1734         if ( m_pEastFontLanguageFT ) m_pEastFontLanguageFT->Hide();
1735         if ( m_pEastFontLanguageLB ) m_pEastFontLanguageLB->Hide();
1736         if ( m_pCTLFontLanguageFT ) m_pCTLFontLanguageFT->Hide();
1737         if ( m_pCTLFontLanguageLB ) m_pCTLFontLanguageLB->Hide();
1738     }
1739 }
1740
1741 // -----------------------------------------------------------------------
1742 void SvxCharNamePage::SetPreviewBackgroundToCharacter()
1743 {
1744     m_bPreviewBackgroundToCharacter = sal_True;
1745 }
1746
1747 // -----------------------------------------------------------------------
1748 void SvxCharNamePage::PageCreated (SfxAllItemSet aSet) //add CHINA001
1749 {
1750     SFX_ITEMSET_ARG (&aSet,pFontListItem,SvxFontListItem,SID_ATTR_CHAR_FONTLIST,sal_False);
1751     SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
1752     SFX_ITEMSET_ARG (&aSet,pDisalbeItem,SfxUInt16Item,SID_DISABLE_CTL,sal_False);
1753     if (pFontListItem)
1754         SetFontList(*pFontListItem);
1755         //CHINA001 SetFontList(pFontListItem->GetFontList());
1756
1757     if (pFlagItem)
1758     {
1759         UINT32 nFlags=pFlagItem->GetValue();
1760         if ( ( nFlags & SVX_RELATIVE_MODE ) == SVX_RELATIVE_MODE )
1761             EnableRelativeMode();
1762         if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
1763             SetPreviewBackgroundToCharacter();
1764     }
1765     if (pDisalbeItem)
1766         DisableControls(pDisalbeItem->GetValue());
1767 }
1768 // class SvxCharEffectsPage ----------------------------------------------
1769
1770 SvxCharEffectsPage::SvxCharEffectsPage( Window* pParent, const SfxItemSet& rInSet ) :
1771
1772     SvxCharBasePage( pParent, SVX_RES( RID_SVXPAGE_CHAR_EFFECTS ), rInSet, WIN_EFFECTS_PREVIEW, FT_EFFECTS_FONTTYPE ),
1773
1774     m_aFontColorFT          ( this, SVX_RES( FT_FONTCOLOR ) ),
1775     m_aFontColorLB          ( this, SVX_RES( LB_FONTCOLOR ) ),
1776
1777     m_aEffectsFT                        ( this, SVX_RES( FT_EFFECTS ) ),
1778     m_aEffectsLB                        ( this, 0 ),
1779
1780     m_aEffects2LB                       ( this, SVX_RES( LB_EFFECTS2 ) ),
1781
1782     m_aReliefFT             ( this, SVX_RES( FT_RELIEF ) ),
1783     m_aReliefLB             ( this, SVX_RES( LB_RELIEF ) ),
1784
1785     m_aOutlineBtn                       ( this, SVX_RES( CB_OUTLINE ) ),
1786     m_aShadowBtn                        ( this, SVX_RES( CB_SHADOW ) ),
1787     m_aBlinkingBtn                      ( this, SVX_RES( CB_BLINKING ) ),
1788     m_aHiddenBtn            ( this, SVX_RES( CB_CHARHIDDEN ) ),
1789
1790     m_aVerticalLine                     ( this, SVX_RES( FL_EFFECTS_VERTICAL ) ),
1791
1792     m_aOverlineFT                       ( this, SVX_RES( FT_OVERLINE ) ),
1793     m_aOverlineLB                       ( this, SVX_RES( LB_OVERLINE ) ),
1794     m_aOverlineColorFT          ( this, SVX_RES( FT_OVERLINE_COLOR ) ),
1795     m_aOverlineColorLB          ( this, SVX_RES( LB_OVERLINE_COLOR ) ),
1796     m_aStrikeoutFT                      ( this, SVX_RES( FT_STRIKEOUT ) ),
1797     m_aStrikeoutLB                      ( this, SVX_RES( LB_STRIKEOUT ) ),
1798     m_aUnderlineFT                      ( this, SVX_RES( FT_UNDERLINE ) ),
1799     m_aUnderlineLB                      ( this, SVX_RES( LB_UNDERLINE ) ),
1800     m_aUnderlineColorFT         ( this, SVX_RES( FT_UNDERLINE_COLOR ) ),
1801     m_aUnderlineColorLB         ( this, SVX_RES( LB_UNDERLINE_COLOR ) ),
1802     m_aIndividualWordsBtn       ( this, SVX_RES( CB_INDIVIDUALWORDS ) ),
1803
1804     m_aAsianLine                        ( this, SVX_RES( FL_EFFECTS_ASIAN ) ),
1805
1806     m_aEmphasisFT                       ( this, SVX_RES( FT_EMPHASIS ) ),
1807     m_aEmphasisLB                       ( this, SVX_RES( LB_EMPHASIS ) ),
1808     m_aPositionFT                       ( this, SVX_RES( FT_POSITION ) ),
1809     m_aPositionLB                       ( this, SVX_RES( LB_POSITION ) ),
1810
1811     m_aTransparentColorName     ( SVX_RES( STR_CHARNAME_TRANSPARENT ) )
1812
1813 {
1814     m_aEffectsLB.Hide();
1815     FreeResource();
1816     Initialize();
1817 }
1818
1819 // -----------------------------------------------------------------------
1820
1821 void SvxCharEffectsPage::Initialize()
1822 {
1823     // to handle the changes of the other pages
1824     SetExchangeSupport();
1825
1826     // HTML-Mode
1827     const SfxPoolItem* pItem;
1828     SfxObjectShell* pShell;
1829     if ( SFX_ITEM_SET == GetItemSet().GetItemState( SID_HTML_MODE, FALSE, &pItem ) ||
1830          ( NULL != ( pShell = SfxObjectShell::Current() ) &&
1831            NULL != ( pItem = pShell->GetItem( SID_HTML_MODE ) ) ) )
1832     {
1833         m_nHtmlMode = ( (const SfxUInt16Item*)pItem )->GetValue();
1834         if ( ( m_nHtmlMode & HTMLMODE_ON ) == HTMLMODE_ON )
1835         {
1836             //!!! hide some controls please
1837         }
1838     }
1839
1840     // fill the color box
1841     SfxObjectShell* pDocSh = SfxObjectShell::Current();
1842     DBG_ASSERT( pDocSh, "DocShell not found!" );
1843     XColorTable* pColorTable = NULL;
1844     FASTBOOL bKillTable = FALSE;
1845
1846     if ( pDocSh )
1847     {
1848         pItem = pDocSh->GetItem( SID_COLOR_TABLE );
1849         if ( pItem != NULL )
1850             pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
1851     }
1852
1853     if ( !pColorTable )
1854     {
1855         pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
1856         bKillTable = TRUE;
1857     }
1858
1859     m_aUnderlineColorLB.SetUpdateMode( FALSE );
1860     m_aOverlineColorLB.SetUpdateMode( FALSE );
1861     m_aFontColorLB.SetUpdateMode( FALSE );
1862
1863     {
1864         SfxPoolItem* pDummy;
1865         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocSh );
1866         if ( !pFrame ||
1867              SFX_ITEM_DEFAULT > pFrame->GetBindings().QueryState( SID_ATTR_AUTO_COLOR_INVALID, pDummy ) )
1868         {
1869             m_aUnderlineColorLB.InsertAutomaticEntry();
1870             m_aOverlineColorLB.InsertAutomaticEntry();
1871             m_aFontColorLB.InsertAutomaticEntry();
1872         }
1873     }
1874     for ( long i = 0; i < pColorTable->Count(); i++ )
1875     {
1876         XColorEntry* pEntry = pColorTable->GetColor(i);
1877         m_aUnderlineColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1878         m_aOverlineColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1879         m_aFontColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
1880     }
1881
1882     m_aUnderlineColorLB.SetUpdateMode( TRUE );
1883     m_aOverlineColorLB.SetUpdateMode( TRUE );
1884     m_aFontColorLB.SetUpdateMode( TRUE );
1885     m_aFontColorLB.SetSelectHdl( LINK( this, SvxCharEffectsPage, ColorBoxSelectHdl_Impl ) );
1886
1887     if ( bKillTable )
1888         delete pColorTable;
1889
1890     // handler
1891     Link aLink = LINK( this, SvxCharEffectsPage, SelectHdl_Impl );
1892     m_aUnderlineLB.SetSelectHdl( aLink );
1893     m_aUnderlineColorLB.SetSelectHdl( aLink );
1894     m_aOverlineLB.SetSelectHdl( aLink );
1895     m_aOverlineColorLB.SetSelectHdl( aLink );
1896     m_aStrikeoutLB.SetSelectHdl( aLink );
1897     m_aEmphasisLB.SetSelectHdl( aLink );
1898     m_aPositionLB.SetSelectHdl( aLink );
1899     m_aEffects2LB.SetSelectHdl( aLink );
1900     m_aReliefLB.SetSelectHdl( aLink );
1901
1902     m_aUnderlineLB.SelectEntryPos( 0 );
1903     m_aUnderlineColorLB.SelectEntryPos( 0 );
1904     m_aOverlineLB.SelectEntryPos( 0 );
1905     m_aOverlineColorLB.SelectEntryPos( 0 );
1906     m_aStrikeoutLB.SelectEntryPos( 0 );
1907     m_aEmphasisLB.SelectEntryPos( 0 );
1908     m_aPositionLB.SelectEntryPos( 0 );
1909     SelectHdl_Impl( NULL );
1910     SelectHdl_Impl( &m_aEmphasisLB );
1911
1912     m_aEffects2LB.SelectEntryPos( 0 );
1913
1914     m_aIndividualWordsBtn.SetClickHdl( LINK( this, SvxCharEffectsPage, CbClickHdl_Impl ) );
1915     aLink = LINK( this, SvxCharEffectsPage, TristClickHdl_Impl );
1916     m_aOutlineBtn.SetClickHdl( aLink );
1917     m_aShadowBtn.SetClickHdl( aLink );
1918
1919     if ( !SvtLanguageOptions().IsAsianTypographyEnabled() )
1920     {
1921         m_aAsianLine.Hide();
1922         m_aEmphasisFT.Hide();
1923         m_aEmphasisLB.Hide();
1924         m_aPositionFT.Hide();
1925         m_aPositionLB.Hide();
1926     }
1927 }
1928 // -----------------------------------------------------------------------
1929
1930 void SvxCharEffectsPage::UpdatePreview_Impl()
1931 {
1932     SvxFont& rFont = GetPreviewFont();
1933     SvxFont& rCJKFont = GetPreviewCJKFont();
1934     SvxFont& rCTLFont = GetPreviewCTLFont();
1935
1936     USHORT nPos = m_aUnderlineLB.GetSelectEntryPos();
1937     FontUnderline eUnderline = (FontUnderline)(ULONG)m_aUnderlineLB.GetEntryData( nPos );
1938     nPos = m_aOverlineLB.GetSelectEntryPos();
1939     FontUnderline eOverline = (FontUnderline)(ULONG)m_aOverlineLB.GetEntryData( nPos );
1940     nPos = m_aStrikeoutLB.GetSelectEntryPos();
1941     FontStrikeout eStrikeout = (FontStrikeout)(ULONG)m_aStrikeoutLB.GetEntryData( nPos );
1942     rFont.SetUnderline( eUnderline );
1943     rCJKFont.SetUnderline( eUnderline );
1944     rCTLFont.SetUnderline( eUnderline );
1945     m_aPreviewWin.SetTextLineColor( m_aUnderlineColorLB.GetSelectEntryColor() );
1946     rFont.SetOverline( eOverline );
1947     rCJKFont.SetOverline( eOverline );
1948     rCTLFont.SetOverline( eOverline );
1949     m_aPreviewWin.SetOverlineColor( m_aOverlineColorLB.GetSelectEntryColor() );
1950     rFont.SetStrikeout( eStrikeout );
1951     rCJKFont.SetStrikeout( eStrikeout );
1952     rCTLFont.SetStrikeout( eStrikeout );
1953
1954     nPos = m_aPositionLB.GetSelectEntryPos();
1955     BOOL bUnder = ( CHRDLG_POSITION_UNDER == (ULONG)m_aPositionLB.GetEntryData( nPos ) );
1956     FontEmphasisMark eMark = (FontEmphasisMark)m_aEmphasisLB.GetSelectEntryPos();
1957     eMark |= bUnder ? EMPHASISMARK_POS_BELOW : EMPHASISMARK_POS_ABOVE;
1958     rFont.SetEmphasisMark( eMark );
1959     rCJKFont.SetEmphasisMark( eMark );
1960     rCTLFont.SetEmphasisMark( eMark );
1961
1962     USHORT nRelief = m_aReliefLB.GetSelectEntryPos();
1963     if(LISTBOX_ENTRY_NOTFOUND != nRelief)
1964     {
1965         rFont.SetRelief( (FontRelief)nRelief );
1966         rCJKFont.SetRelief( (FontRelief)nRelief );
1967         rCTLFont.SetRelief( (FontRelief)nRelief );
1968     }
1969
1970     rFont.SetOutline( StateToAttr( m_aOutlineBtn.GetState() ) );
1971     rCJKFont.SetOutline( rFont.IsOutline() );
1972     rCTLFont.SetOutline( rFont.IsOutline() );
1973
1974     rFont.SetShadow( StateToAttr( m_aShadowBtn.GetState() ) );
1975     rCJKFont.SetShadow( rFont.IsShadow() );
1976     rCTLFont.SetShadow( rFont.IsShadow() );
1977
1978     USHORT nCapsPos = m_aEffects2LB.GetSelectEntryPos();
1979     if ( nCapsPos != LISTBOX_ENTRY_NOTFOUND )
1980     {
1981         rFont.SetCaseMap( (SvxCaseMap)nCapsPos );
1982         rCJKFont.SetCaseMap( (SvxCaseMap)nCapsPos );
1983         // #i78474# small caps do not exist in CTL fonts
1984         rCTLFont.SetCaseMap( static_cast<SvxCaseMap>( nCapsPos == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : (SvxCaseMap)nCapsPos) );
1985     }
1986
1987     BOOL bWordLine = m_aIndividualWordsBtn.IsChecked();
1988     rFont.SetWordLineMode( bWordLine );
1989     rCJKFont.SetWordLineMode( bWordLine );
1990     rCTLFont.SetWordLineMode( bWordLine );
1991
1992     m_aPreviewWin.Invalidate();
1993 }
1994
1995 // -----------------------------------------------------------------------
1996
1997 void SvxCharEffectsPage::SetCaseMap_Impl( SvxCaseMap eCaseMap )
1998 {
1999     if ( SVX_CASEMAP_END > eCaseMap )
2000         m_aEffects2LB.SelectEntryPos(
2001             sal::static_int_cast< USHORT >( eCaseMap ) );
2002     else
2003     {
2004         m_aEffects2LB.SetNoSelection();
2005         eCaseMap = SVX_CASEMAP_NOT_MAPPED;
2006     }
2007
2008     UpdatePreview_Impl();
2009 }
2010
2011 // -----------------------------------------------------------------------
2012
2013 void SvxCharEffectsPage::ResetColor_Impl( const SfxItemSet& rSet )
2014 {
2015     USHORT nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
2016     SfxItemState eState = rSet.GetItemState( nWhich );
2017
2018     switch ( eState )
2019     {
2020         case SFX_ITEM_UNKNOWN:
2021             m_aFontColorFT.Hide();
2022             m_aFontColorLB.Hide();
2023             break;
2024
2025         case SFX_ITEM_DISABLED:
2026         case SFX_ITEM_READONLY:
2027             m_aFontColorFT.Disable();
2028             m_aFontColorLB.Disable();
2029             break;
2030
2031         case SFX_ITEM_DONTCARE:
2032             m_aFontColorLB.SetNoSelection();
2033             break;
2034
2035         case SFX_ITEM_DEFAULT:
2036         case SFX_ITEM_SET:
2037         {
2038             SvxFont& rFont = GetPreviewFont();
2039             SvxFont& rCJKFont = GetPreviewCJKFont();
2040             SvxFont& rCTLFont = GetPreviewCTLFont();
2041
2042             const SvxColorItem& rItem = (SvxColorItem&)rSet.Get( nWhich );
2043             Color aColor = rItem.GetValue();
2044             rFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
2045             rCJKFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
2046             rCTLFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
2047
2048             m_aPreviewWin.Invalidate();
2049             USHORT nSelPos = m_aFontColorLB.GetEntryPos( aColor );
2050             if ( nSelPos == LISTBOX_ENTRY_NOTFOUND && aColor == Color( COL_TRANSPARENT ) )
2051                 nSelPos = m_aFontColorLB.GetEntryPos( m_aTransparentColorName );
2052
2053             if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
2054                 m_aFontColorLB.SelectEntryPos( nSelPos );
2055             else
2056             {
2057                 nSelPos = m_aFontColorLB.GetEntryPos( aColor );
2058                 if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
2059                     m_aFontColorLB.SelectEntryPos( nSelPos );
2060                 else
2061                     m_aFontColorLB.SelectEntryPos(
2062                         m_aFontColorLB.InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
2063             }
2064             break;
2065         }
2066     }
2067 }
2068
2069 // -----------------------------------------------------------------------
2070
2071 BOOL SvxCharEffectsPage::FillItemSetColor_Impl( SfxItemSet& rSet )
2072 {
2073     USHORT nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
2074     const SvxColorItem* pOld = (const SvxColorItem*)GetOldItem( rSet, SID_ATTR_CHAR_COLOR );
2075     const SvxColorItem* pItem = NULL;
2076     BOOL bChanged = TRUE;
2077     const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
2078     const SfxItemSet& rOldSet = GetItemSet();
2079
2080     Color aSelectedColor;
2081     if ( m_aFontColorLB.GetSelectEntry() == m_aTransparentColorName )
2082         aSelectedColor = Color( COL_TRANSPARENT );
2083     else
2084         aSelectedColor = m_aFontColorLB.GetSelectEntryColor();
2085
2086     if ( pOld && pOld->GetValue() == aSelectedColor )
2087         bChanged = FALSE;
2088
2089     if ( !bChanged )
2090         bChanged = ( m_aFontColorLB.GetSavedValue() == LISTBOX_ENTRY_NOTFOUND );
2091
2092     if ( !bChanged && pExampleSet &&
2093          pExampleSet->GetItemState( nWhich, FALSE, (const SfxPoolItem**)&pItem ) == SFX_ITEM_SET &&
2094          ( (SvxColorItem*)pItem )->GetValue() != aSelectedColor )
2095         bChanged = TRUE;
2096
2097     BOOL bModified = FALSE;
2098
2099     if ( bChanged && m_aFontColorLB.GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND )
2100     {
2101         rSet.Put( SvxColorItem( aSelectedColor, nWhich ) );
2102         bModified = TRUE;
2103     }
2104     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2105         CLEARTITEM;
2106
2107     return bModified;
2108 }
2109
2110 // -----------------------------------------------------------------------
2111
2112 IMPL_LINK( SvxCharEffectsPage, SelectHdl_Impl, ListBox*, pBox )
2113 {
2114     if ( &m_aEmphasisLB == pBox )
2115     {
2116         USHORT nEPos = m_aEmphasisLB.GetSelectEntryPos();
2117         BOOL bEnable = ( nEPos > 0 && nEPos != LISTBOX_ENTRY_NOTFOUND );
2118         m_aPositionFT.Enable( bEnable );
2119         m_aPositionLB.Enable( bEnable );
2120     }
2121     else if( &m_aReliefLB == pBox)
2122     {
2123         BOOL bEnable = ( pBox->GetSelectEntryPos() == 0 );
2124         m_aOutlineBtn.Enable( bEnable );
2125         m_aShadowBtn.Enable( bEnable );
2126     }
2127     else if ( &m_aPositionLB != pBox )
2128     {
2129         USHORT nUPos = m_aUnderlineLB.GetSelectEntryPos(),
2130                nOPos = m_aOverlineLB.GetSelectEntryPos(),
2131                nSPos = m_aStrikeoutLB.GetSelectEntryPos();
2132         BOOL bUEnable = ( nUPos > 0 && nUPos != LISTBOX_ENTRY_NOTFOUND );
2133         BOOL bOEnable = ( nOPos > 0 && nOPos != LISTBOX_ENTRY_NOTFOUND );
2134         m_aUnderlineColorFT.Enable( bUEnable );
2135         m_aUnderlineColorLB.Enable( bUEnable );
2136         m_aOverlineColorFT.Enable( bOEnable );
2137         m_aOverlineColorLB.Enable( bOEnable );
2138         m_aIndividualWordsBtn.Enable( bUEnable || bOEnable || ( nSPos > 0 && nSPos != LISTBOX_ENTRY_NOTFOUND ) );
2139     }
2140     UpdatePreview_Impl();
2141     return 0;
2142 }
2143
2144 // -----------------------------------------------------------------------
2145
2146 IMPL_LINK( SvxCharEffectsPage, UpdatePreview_Impl, ListBox*, EMPTYARG )
2147 {
2148     bool bEnable = ( ( m_aUnderlineLB.GetSelectEntryPos() > 0 ) ||
2149                      ( m_aOverlineLB.GetSelectEntryPos()  > 0 ) ||
2150                      ( m_aStrikeoutLB.GetSelectEntryPos() > 0 ) );
2151     m_aIndividualWordsBtn.Enable( bEnable );
2152
2153     UpdatePreview_Impl();
2154     return 0;
2155 }
2156
2157 // -----------------------------------------------------------------------
2158
2159 IMPL_LINK( SvxCharEffectsPage, CbClickHdl_Impl, CheckBox*, EMPTYARG )
2160 {
2161     UpdatePreview_Impl();
2162     return 0;
2163 }
2164
2165 // -----------------------------------------------------------------------
2166
2167 IMPL_LINK( SvxCharEffectsPage, TristClickHdl_Impl, TriStateBox*, EMPTYARG )
2168 {
2169     UpdatePreview_Impl();
2170     return 0;
2171 }
2172
2173 // -----------------------------------------------------------------------
2174
2175 IMPL_LINK( SvxCharEffectsPage, ColorBoxSelectHdl_Impl, ColorListBox*, pBox )
2176 {
2177     SvxFont& rFont = GetPreviewFont();
2178     SvxFont& rCJKFont = GetPreviewCJKFont();
2179     SvxFont& rCTLFont = GetPreviewCTLFont();
2180
2181     Color aSelectedColor;
2182     if ( pBox->GetSelectEntry() == m_aTransparentColorName )
2183         aSelectedColor = Color( COL_TRANSPARENT );
2184     else
2185         aSelectedColor = pBox->GetSelectEntryColor();
2186     rFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
2187     rCJKFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
2188     rCTLFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
2189
2190     m_aPreviewWin.Invalidate();
2191     return 0;
2192 }
2193 // -----------------------------------------------------------------------
2194
2195 int SvxCharEffectsPage::DeactivatePage( SfxItemSet* _pSet )
2196 {
2197     if ( _pSet )
2198         FillItemSet( *_pSet );
2199     return LEAVE_PAGE;
2200 }
2201
2202 // -----------------------------------------------------------------------
2203
2204 SfxTabPage* SvxCharEffectsPage::Create( Window* pParent, const SfxItemSet& rSet )
2205 {
2206     return new SvxCharEffectsPage( pParent, rSet );
2207 }
2208
2209 // -----------------------------------------------------------------------
2210
2211 USHORT* SvxCharEffectsPage::GetRanges()
2212 {
2213     return pEffectsRanges;
2214 }
2215
2216 // -----------------------------------------------------------------------
2217
2218 void SvxCharEffectsPage::Reset( const SfxItemSet& rSet )
2219 {
2220     SvxFont& rFont = GetPreviewFont();
2221     SvxFont& rCJKFont = GetPreviewCJKFont();
2222     SvxFont& rCTLFont = GetPreviewCTLFont();
2223
2224     BOOL bEnable = FALSE;
2225
2226     // Underline
2227     USHORT nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
2228     rFont.SetUnderline( UNDERLINE_NONE );
2229     rCJKFont.SetUnderline( UNDERLINE_NONE );
2230     rCTLFont.SetUnderline( UNDERLINE_NONE );
2231
2232     m_aUnderlineLB.SelectEntryPos( 0 );
2233     SfxItemState eState = rSet.GetItemState( nWhich );
2234
2235     if ( eState >= SFX_ITEM_DONTCARE )
2236     {
2237         if ( eState == SFX_ITEM_DONTCARE )
2238             m_aUnderlineLB.SetNoSelection();
2239         else
2240         {
2241             const SvxUnderlineItem& rItem = (SvxUnderlineItem&)rSet.Get( nWhich );
2242             FontUnderline eUnderline = (FontUnderline)rItem.GetValue();
2243             rFont.SetUnderline( eUnderline );
2244             rCJKFont.SetUnderline( eUnderline );
2245             rCTLFont.SetUnderline( eUnderline );
2246
2247             if ( eUnderline != UNDERLINE_NONE )
2248             {
2249                 for ( USHORT i = 0; i < m_aUnderlineLB.GetEntryCount(); ++i )
2250                 {
2251                     if ( (FontUnderline)(ULONG)m_aUnderlineLB.GetEntryData(i) == eUnderline )
2252                     {
2253                         m_aUnderlineLB.SelectEntryPos(i);
2254                         bEnable |= TRUE;
2255                         break;
2256                     }
2257                 }
2258
2259                 Color aColor = rItem.GetColor();
2260                 USHORT nPos = m_aUnderlineColorLB.GetEntryPos( aColor );
2261
2262                 if ( LISTBOX_ENTRY_NOTFOUND != nPos )
2263                     m_aUnderlineColorLB.SelectEntryPos( nPos );
2264                 else
2265                 {
2266                     nPos = m_aUnderlineColorLB.GetEntryPos( aColor );
2267                     if ( LISTBOX_ENTRY_NOTFOUND != nPos )
2268                         m_aUnderlineColorLB.SelectEntryPos( nPos );
2269                     else
2270                         m_aUnderlineColorLB.SelectEntryPos(
2271                             m_aUnderlineColorLB.InsertEntry( aColor,
2272                                 String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
2273                 }
2274             }
2275             else
2276             {
2277                 m_aUnderlineColorLB.SelectEntry( Color( COL_AUTO ));
2278                 m_aUnderlineColorLB.Disable();
2279             }
2280         }
2281     }
2282
2283     // Overline
2284     nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
2285     rFont.SetOverline( UNDERLINE_NONE );
2286     rCJKFont.SetOverline( UNDERLINE_NONE );
2287     rCTLFont.SetOverline( UNDERLINE_NONE );
2288
2289     m_aOverlineLB.SelectEntryPos( 0 );
2290     eState = rSet.GetItemState( nWhich );
2291
2292     if ( eState >= SFX_ITEM_DONTCARE )
2293     {
2294         if ( eState == SFX_ITEM_DONTCARE )
2295             m_aOverlineLB.SetNoSelection();
2296         else
2297         {
2298             const SvxOverlineItem& rItem = (SvxOverlineItem&)rSet.Get( nWhich );
2299             FontUnderline eOverline = (FontUnderline)rItem.GetValue();
2300             rFont.SetOverline( eOverline );
2301             rCJKFont.SetOverline( eOverline );
2302             rCTLFont.SetOverline( eOverline );
2303
2304             if ( eOverline != UNDERLINE_NONE )
2305             {
2306                 for ( USHORT i = 0; i < m_aOverlineLB.GetEntryCount(); ++i )
2307                 {
2308                     if ( (FontUnderline)(ULONG)m_aOverlineLB.GetEntryData(i) == eOverline )
2309                     {
2310                         m_aOverlineLB.SelectEntryPos(i);
2311                         bEnable |= TRUE;
2312                         break;
2313                     }
2314                 }
2315
2316                 Color aColor = rItem.GetColor();
2317                 USHORT nPos = m_aOverlineColorLB.GetEntryPos( aColor );
2318
2319                 if ( LISTBOX_ENTRY_NOTFOUND != nPos )
2320                     m_aOverlineColorLB.SelectEntryPos( nPos );
2321                 else
2322                 {
2323                     nPos = m_aOverlineColorLB.GetEntryPos( aColor );
2324                     if ( LISTBOX_ENTRY_NOTFOUND != nPos )
2325                         m_aOverlineColorLB.SelectEntryPos( nPos );
2326                     else
2327                         m_aOverlineColorLB.SelectEntryPos(
2328                             m_aOverlineColorLB.InsertEntry( aColor,
2329                                 String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
2330                 }
2331             }
2332             else
2333             {
2334                 m_aOverlineColorLB.SelectEntry( Color( COL_AUTO ));
2335                 m_aOverlineColorLB.Disable();
2336             }
2337         }
2338     }
2339
2340     //  Strikeout
2341     nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
2342     rFont.SetStrikeout( STRIKEOUT_NONE );
2343     rCJKFont.SetStrikeout( STRIKEOUT_NONE );
2344     rCTLFont.SetStrikeout( STRIKEOUT_NONE );
2345
2346     m_aStrikeoutLB.SelectEntryPos( 0 );
2347     eState = rSet.GetItemState( nWhich );
2348
2349     if ( eState >= SFX_ITEM_DONTCARE )
2350     {
2351         if ( eState == SFX_ITEM_DONTCARE )
2352             m_aStrikeoutLB.SetNoSelection();
2353         else
2354         {
2355             const SvxCrossedOutItem& rItem = (SvxCrossedOutItem&)rSet.Get( nWhich );
2356             FontStrikeout eStrikeout = (FontStrikeout)rItem.GetValue();
2357             rFont.SetStrikeout( eStrikeout );
2358             rCJKFont.SetStrikeout( eStrikeout );
2359             rCTLFont.SetStrikeout( eStrikeout );
2360
2361             if ( eStrikeout != STRIKEOUT_NONE )
2362             {
2363                 for ( USHORT i = 0; i < m_aStrikeoutLB.GetEntryCount(); ++i )
2364                 {
2365                     if ( (FontStrikeout)(ULONG)m_aStrikeoutLB.GetEntryData(i) == eStrikeout )
2366                     {
2367                         m_aStrikeoutLB.SelectEntryPos(i);
2368                         bEnable |= TRUE;
2369                         break;
2370                     }
2371                 }
2372             }
2373         }
2374     }
2375
2376     // WordLineMode
2377     nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
2378     switch ( eState )
2379     {
2380         case SFX_ITEM_UNKNOWN:
2381             m_aIndividualWordsBtn.Hide();
2382             break;
2383
2384         case SFX_ITEM_DISABLED:
2385         case SFX_ITEM_READONLY:
2386             m_aIndividualWordsBtn.Disable();
2387             break;
2388
2389         case SFX_ITEM_DONTCARE:
2390             m_aIndividualWordsBtn.SetState( STATE_DONTKNOW );
2391             break;
2392
2393         case SFX_ITEM_DEFAULT:
2394         case SFX_ITEM_SET:
2395         {
2396             const SvxWordLineModeItem& rItem = (SvxWordLineModeItem&)rSet.Get( nWhich );
2397             rFont.SetWordLineMode( rItem.GetValue() );
2398             rCJKFont.SetWordLineMode( rItem.GetValue() );
2399             rCTLFont.SetWordLineMode( rItem.GetValue() );
2400
2401             m_aIndividualWordsBtn.Check( rItem.GetValue() );
2402             m_aIndividualWordsBtn.Enable( bEnable );
2403             break;
2404         }
2405     }
2406
2407     // Emphasis
2408     nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
2409     eState = rSet.GetItemState( nWhich );
2410
2411     if ( eState >= SFX_ITEM_DEFAULT )
2412     {
2413         const SvxEmphasisMarkItem& rItem = (SvxEmphasisMarkItem&)rSet.Get( nWhich );
2414         FontEmphasisMark eMark = rItem.GetEmphasisMark();
2415         rFont.SetEmphasisMark( eMark );
2416         rCJKFont.SetEmphasisMark( eMark );
2417         rCTLFont.SetEmphasisMark( eMark );
2418
2419         m_aEmphasisLB.SelectEntryPos( (USHORT)( eMark & EMPHASISMARK_STYLE ) );
2420         eMark &= ~EMPHASISMARK_STYLE;
2421         ULONG nEntryData = ( eMark == EMPHASISMARK_POS_ABOVE )
2422             ? CHRDLG_POSITION_OVER
2423             : ( eMark == EMPHASISMARK_POS_BELOW ) ? CHRDLG_POSITION_UNDER : 0;
2424
2425         for ( USHORT i = 0; i < m_aPositionLB.GetEntryCount(); i++ )
2426         {
2427             if ( nEntryData == (ULONG)m_aPositionLB.GetEntryData(i) )
2428             {
2429                 m_aPositionLB.SelectEntryPos(i);
2430                 break;
2431             }
2432         }
2433     }
2434     else if ( eState == SFX_ITEM_DONTCARE )
2435         m_aEmphasisLB.SetNoSelection( );
2436     else if ( eState == SFX_ITEM_UNKNOWN )
2437     {
2438         m_aEmphasisFT.Hide();
2439         m_aEmphasisLB.Hide();
2440     }
2441     else // SFX_ITEM_DISABLED or SFX_ITEM_READONLY
2442     {
2443         m_aEmphasisFT.Disable();
2444         m_aEmphasisLB.Disable();
2445     }
2446
2447     // the select handler for the underline/overline/strikeout list boxes
2448 //      SelectHdl_Impl( NULL );
2449     DBG_ASSERT(m_aUnderlineLB.GetSelectHdl() == m_aOverlineLB.GetSelectHdl(),
2450         "SvxCharEffectsPage::Reset: inconsistence (1)!");
2451     DBG_ASSERT(m_aUnderlineLB.GetSelectHdl() == m_aStrikeoutLB.GetSelectHdl(),
2452         "SvxCharEffectsPage::Reset: inconsistence (1)!");
2453     m_aUnderlineLB.GetSelectHdl().Call(NULL);
2454         // don't call SelectHdl_Impl directly!
2455         // in DisableControls, we may have re-reouted the select handler
2456         // 30.05.2001 - 86262 - frank.schoenheit@germany.sun.com
2457
2458     // the select handler for the emphasis listbox
2459 //      SelectHdl_Impl( &m_aEmphasisLB );
2460     DBG_ASSERT(m_aEmphasisLB.GetSelectHdl() == LINK(this, SvxCharEffectsPage, SelectHdl_Impl),
2461         "SvxCharEffectsPage::Reset: inconsistence (2)!");
2462     m_aEmphasisLB.GetSelectHdl().Call( &m_aEmphasisLB );
2463         // this is for consistency only. Here it would be allowed to call SelectHdl_Impl directly ...
2464
2465     // Effects
2466     SvxCaseMap eCaseMap = SVX_CASEMAP_END;
2467     nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
2468     eState = rSet.GetItemState( nWhich );
2469     switch ( eState )
2470     {
2471         case SFX_ITEM_UNKNOWN:
2472             m_aEffectsFT.Hide();
2473             m_aEffects2LB.Hide();
2474             break;
2475
2476         case SFX_ITEM_DISABLED:
2477         case SFX_ITEM_READONLY:
2478             m_aEffectsFT.Disable();
2479             m_aEffects2LB.Disable();
2480             break;
2481
2482         case SFX_ITEM_DONTCARE:
2483             m_aEffects2LB.SetNoSelection();
2484             break;
2485
2486         case SFX_ITEM_DEFAULT:
2487         case SFX_ITEM_SET:
2488         {
2489             const SvxCaseMapItem& rItem = (const SvxCaseMapItem&)rSet.Get( nWhich );
2490             eCaseMap = (SvxCaseMap)rItem.GetValue();
2491             break;
2492         }
2493     }
2494     SetCaseMap_Impl( eCaseMap );
2495
2496     //Relief
2497     nWhich = GetWhich(SID_ATTR_CHAR_RELIEF);
2498     eState = rSet.GetItemState( nWhich );
2499     switch ( eState )
2500     {
2501         case SFX_ITEM_UNKNOWN:
2502             m_aReliefFT.Hide();
2503             m_aReliefLB.Hide();
2504             break;
2505
2506         case SFX_ITEM_DISABLED:
2507         case SFX_ITEM_READONLY:
2508             m_aReliefFT.Disable();
2509             m_aReliefLB.Disable();
2510             break;
2511
2512         case SFX_ITEM_DONTCARE:
2513             m_aReliefLB.SetNoSelection();
2514             break;
2515
2516         case SFX_ITEM_DEFAULT:
2517         case SFX_ITEM_SET:
2518         {
2519             const SvxCharReliefItem& rItem = (const SvxCharReliefItem&)rSet.Get( nWhich );
2520             m_aReliefLB.SelectEntryPos(rItem.GetValue());
2521             SelectHdl_Impl(&m_aReliefLB);
2522             break;
2523         }
2524     }
2525
2526     // Outline
2527     nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
2528     eState = rSet.GetItemState( nWhich );
2529     switch ( eState )
2530     {
2531         case SFX_ITEM_UNKNOWN:
2532             m_aOutlineBtn.Hide();
2533             break;
2534
2535         case SFX_ITEM_DISABLED:
2536         case SFX_ITEM_READONLY:
2537             m_aOutlineBtn.Disable();
2538             break;
2539
2540         case SFX_ITEM_DONTCARE:
2541             m_aOutlineBtn.SetState( STATE_DONTKNOW );
2542             break;
2543
2544         case SFX_ITEM_DEFAULT:
2545         case SFX_ITEM_SET:
2546         {
2547             const SvxContourItem& rItem = (SvxContourItem&)rSet.Get( nWhich );
2548             m_aOutlineBtn.SetState( (TriState)rItem.GetValue() );
2549             m_aOutlineBtn.EnableTriState( FALSE );
2550             break;
2551         }
2552     }
2553
2554     // Shadow
2555     nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
2556     eState = rSet.GetItemState( nWhich );
2557
2558     switch ( eState )
2559     {
2560         case SFX_ITEM_UNKNOWN:
2561             m_aShadowBtn.Hide();
2562             break;
2563
2564         case SFX_ITEM_DISABLED:
2565         case SFX_ITEM_READONLY:
2566             m_aShadowBtn.Disable();
2567             break;
2568
2569         case SFX_ITEM_DONTCARE:
2570             m_aShadowBtn.SetState( STATE_DONTKNOW );
2571             break;
2572
2573         case SFX_ITEM_DEFAULT:
2574         case SFX_ITEM_SET:
2575         {
2576             const SvxShadowedItem& rItem = (SvxShadowedItem&)rSet.Get( nWhich );
2577             m_aShadowBtn.SetState( (TriState)rItem.GetValue() );
2578             m_aShadowBtn.EnableTriState( FALSE );
2579             break;
2580         }
2581     }
2582
2583     // Blinking
2584     nWhich = GetWhich( SID_ATTR_FLASH );
2585     eState = rSet.GetItemState( nWhich );
2586
2587     switch ( eState )
2588     {
2589         case SFX_ITEM_UNKNOWN:
2590             m_aBlinkingBtn.Hide();
2591             break;
2592
2593         case SFX_ITEM_DISABLED:
2594         case SFX_ITEM_READONLY:
2595             m_aBlinkingBtn.Disable();
2596             break;
2597
2598         case SFX_ITEM_DONTCARE:
2599             m_aBlinkingBtn.SetState( STATE_DONTKNOW );
2600             break;
2601
2602         case SFX_ITEM_DEFAULT:
2603         case SFX_ITEM_SET:
2604         {
2605             const SvxBlinkItem& rItem = (SvxBlinkItem&)rSet.Get( nWhich );
2606             m_aBlinkingBtn.SetState( (TriState)rItem.GetValue() );
2607             m_aBlinkingBtn.EnableTriState( FALSE );
2608             break;
2609         }
2610     }
2611     // Hidden
2612     nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN );
2613     eState = rSet.GetItemState( nWhich );
2614
2615     switch ( eState )
2616     {
2617         case SFX_ITEM_UNKNOWN:
2618             m_aHiddenBtn.Hide();
2619             break;
2620
2621         case SFX_ITEM_DISABLED:
2622         case SFX_ITEM_READONLY:
2623             m_aHiddenBtn.Disable();
2624             break;
2625
2626         case SFX_ITEM_DONTCARE:
2627             m_aHiddenBtn.SetState( STATE_DONTKNOW );
2628             break;
2629
2630         case SFX_ITEM_DEFAULT:
2631         case SFX_ITEM_SET:
2632         {
2633             const SvxCharHiddenItem& rItem = (SvxCharHiddenItem&)rSet.Get( nWhich );
2634             m_aHiddenBtn.SetState( (TriState)rItem.GetValue() );
2635             m_aHiddenBtn.EnableTriState( FALSE );
2636             break;
2637         }
2638     }
2639
2640     SetPrevFontWidthScale( rSet );
2641     ResetColor_Impl( rSet );
2642
2643     // preview update
2644     m_aPreviewWin.Invalidate();
2645
2646     // save this settings
2647     m_aUnderlineLB.SaveValue();
2648     m_aUnderlineColorLB.SaveValue();
2649     m_aOverlineLB.SaveValue();
2650     m_aOverlineColorLB.SaveValue();
2651     m_aStrikeoutLB.SaveValue();
2652     m_aIndividualWordsBtn.SaveValue();
2653     m_aEmphasisLB.SaveValue();
2654     m_aPositionLB.SaveValue();
2655     m_aEffects2LB.SaveValue();
2656     m_aReliefLB.SaveValue();
2657     m_aOutlineBtn.SaveValue();
2658     m_aShadowBtn.SaveValue();
2659     m_aBlinkingBtn.SaveValue();
2660     m_aHiddenBtn.SaveValue();
2661     m_aFontColorLB.SaveValue();
2662 }
2663
2664 // -----------------------------------------------------------------------
2665
2666 BOOL SvxCharEffectsPage::FillItemSet( SfxItemSet& rSet )
2667 {
2668     const SfxPoolItem* pOld = 0;
2669     const SfxItemSet& rOldSet = GetItemSet();
2670     BOOL bModified = FALSE;
2671     FASTBOOL bChanged = TRUE;
2672
2673     // Underline
2674     USHORT nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
2675     pOld = GetOldItem( rSet, SID_ATTR_CHAR_UNDERLINE );
2676     USHORT nPos = m_aUnderlineLB.GetSelectEntryPos();
2677     FontUnderline eUnder = (FontUnderline)(ULONG)m_aUnderlineLB.GetEntryData( nPos );
2678
2679     if ( pOld )
2680     {
2681         //! if there are different underline styles in the selection the
2682         //! item-state in the 'rOldSet' will be invalid. In this case
2683         //! changing the underline style will be allowed if a style is
2684         //! selected in the listbox.
2685         BOOL bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
2686                          SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, TRUE );
2687
2688         const SvxUnderlineItem& rItem = *( (const SvxUnderlineItem*)pOld );
2689         if ( (FontUnderline)rItem.GetValue() == eUnder &&
2690              ( UNDERLINE_NONE == eUnder || rItem.GetColor() == m_aUnderlineColorLB.GetSelectEntryColor() ) &&
2691              ! bAllowChg )
2692             bChanged = FALSE;
2693     }
2694
2695     if ( bChanged )
2696     {
2697         SvxUnderlineItem aNewItem( eUnder, nWhich );
2698         aNewItem.SetColor( m_aUnderlineColorLB.GetSelectEntryColor() );
2699         rSet.Put( aNewItem );
2700         bModified |= TRUE;
2701     }
2702      else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2703         CLEARTITEM;
2704
2705     bChanged = TRUE;
2706
2707     // Overline
2708     nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
2709     pOld = GetOldItem( rSet, SID_ATTR_CHAR_OVERLINE );
2710     nPos = m_aOverlineLB.GetSelectEntryPos();
2711     FontUnderline eOver = (FontUnderline)(ULONG)m_aOverlineLB.GetEntryData( nPos );
2712
2713     if ( pOld )
2714     {
2715         //! if there are different underline styles in the selection the
2716         //! item-state in the 'rOldSet' will be invalid. In this case
2717         //! changing the underline style will be allowed if a style is
2718         //! selected in the listbox.
2719         BOOL bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
2720                          SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, TRUE );
2721
2722         const SvxOverlineItem& rItem = *( (const SvxOverlineItem*)pOld );
2723         if ( (FontUnderline)rItem.GetValue() == eOver &&
2724              ( UNDERLINE_NONE == eOver || rItem.GetColor() == m_aOverlineColorLB.GetSelectEntryColor() ) &&
2725              ! bAllowChg )
2726             bChanged = FALSE;
2727     }
2728
2729     if ( bChanged )
2730     {
2731         SvxOverlineItem aNewItem( eOver, nWhich );
2732         aNewItem.SetColor( m_aOverlineColorLB.GetSelectEntryColor() );
2733         rSet.Put( aNewItem );
2734         bModified |= TRUE;
2735     }
2736      else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2737         CLEARTITEM;
2738
2739     bChanged = TRUE;
2740
2741     // Strikeout
2742     nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
2743     pOld = GetOldItem( rSet, SID_ATTR_CHAR_STRIKEOUT );
2744     nPos = m_aStrikeoutLB.GetSelectEntryPos();
2745     FontStrikeout eStrike = (FontStrikeout)(ULONG)m_aStrikeoutLB.GetEntryData( nPos );
2746
2747     if ( pOld )
2748     {
2749         //! if there are different strikeout styles in the selection the
2750         //! item-state in the 'rOldSet' will be invalid. In this case
2751         //! changing the strikeout style will be allowed if a style is
2752         //! selected in the listbox.
2753         BOOL bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
2754                          SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, TRUE );
2755
2756         const SvxCrossedOutItem& rItem = *( (const SvxCrossedOutItem*)pOld );
2757         if ( !m_aStrikeoutLB.IsEnabled()
2758             || ((FontStrikeout)rItem.GetValue() == eStrike  && !bAllowChg) )
2759             bChanged = FALSE;
2760     }
2761
2762     if ( bChanged )
2763     {
2764         rSet.Put( SvxCrossedOutItem( eStrike, nWhich ) );
2765         bModified |= TRUE;
2766     }
2767     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2768         CLEARTITEM;
2769
2770     bChanged = TRUE;
2771
2772     // Individual words
2773     nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
2774     pOld = GetOldItem( rSet, SID_ATTR_CHAR_WORDLINEMODE );
2775
2776     if ( pOld )
2777     {
2778         const SvxWordLineModeItem& rItem = *( (const SvxWordLineModeItem*)pOld );
2779         if ( rItem.GetValue() == m_aIndividualWordsBtn.IsChecked() )
2780             bChanged = FALSE;
2781     }
2782
2783     if ( rOldSet.GetItemState( nWhich ) == SFX_ITEM_DONTCARE &&
2784          m_aIndividualWordsBtn.IsChecked() == m_aIndividualWordsBtn.GetSavedValue() )
2785         bChanged = FALSE;
2786
2787     if ( bChanged )
2788     {
2789         rSet.Put( SvxWordLineModeItem( m_aIndividualWordsBtn.IsChecked(), nWhich ) );
2790         bModified |= TRUE;
2791     }
2792     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2793         CLEARTITEM;
2794
2795     bChanged = TRUE;
2796
2797     // Emphasis
2798     nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
2799     pOld = GetOldItem( rSet, SID_ATTR_CHAR_EMPHASISMARK );
2800     USHORT nMarkPos = m_aEmphasisLB.GetSelectEntryPos();
2801     USHORT nPosPos = m_aPositionLB.GetSelectEntryPos();
2802     FontEmphasisMark eMark = (FontEmphasisMark)nMarkPos;
2803     if ( m_aPositionLB.IsEnabled() )
2804     {
2805         eMark |= ( CHRDLG_POSITION_UNDER == (ULONG)m_aPositionLB.GetEntryData( nPosPos ) )
2806             ? EMPHASISMARK_POS_BELOW : EMPHASISMARK_POS_ABOVE;
2807     }
2808
2809     if ( pOld )
2810     {
2811         if( rOldSet.GetItemState( nWhich ) != SFX_ITEM_DONTCARE )
2812         {
2813             const SvxEmphasisMarkItem& rItem = *( (const SvxEmphasisMarkItem*)pOld );
2814             if ( rItem.GetEmphasisMark() == eMark )
2815                 bChanged = FALSE;
2816         }
2817     }
2818
2819     if ( rOldSet.GetItemState( nWhich ) == SFX_ITEM_DONTCARE &&
2820          m_aEmphasisLB.GetSavedValue() == nMarkPos && m_aPositionLB.GetSavedValue() == nPosPos )
2821         bChanged = FALSE;
2822
2823     if ( bChanged )
2824     {
2825         rSet.Put( SvxEmphasisMarkItem( eMark, nWhich ) );
2826         bModified |= TRUE;
2827     }
2828     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2829         CLEARTITEM;
2830
2831     bChanged = TRUE;
2832
2833     // Effects
2834     nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
2835     pOld = GetOldItem( rSet, SID_ATTR_CHAR_CASEMAP );
2836     SvxCaseMap eCaseMap = SVX_CASEMAP_NOT_MAPPED;
2837     FASTBOOL bChecked = FALSE;
2838     USHORT nCapsPos = m_aEffects2LB.GetSelectEntryPos();
2839     if ( nCapsPos != LISTBOX_ENTRY_NOTFOUND )
2840     {
2841         eCaseMap = (SvxCaseMap)nCapsPos;
2842         bChecked = TRUE;
2843     }
2844
2845     if ( pOld )
2846     {
2847         //! if there are different effect styles in the selection the
2848         //! item-state in the 'rOldSet' will be invalid. In this case
2849         //! changing the effect style will be allowed if a style is
2850         //! selected in the listbox.
2851         BOOL bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
2852                          SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, TRUE );
2853
2854         const SvxCaseMapItem& rItem = *( (const SvxCaseMapItem*)pOld );
2855         if ( (SvxCaseMap)rItem.GetValue() == eCaseMap  &&  !bAllowChg )
2856             bChanged = FALSE;
2857     }
2858
2859     if ( bChanged && bChecked )
2860     {
2861         rSet.Put( SvxCaseMapItem( eCaseMap, nWhich ) );
2862         bModified |= TRUE;
2863     }
2864     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2865         CLEARTITEM;
2866
2867     bChanged = TRUE;
2868
2869     //Relief
2870     nWhich = GetWhich(SID_ATTR_CHAR_RELIEF);
2871     if(m_aReliefLB.GetSelectEntryPos() != m_aReliefLB.GetSavedValue())
2872     {
2873         m_aReliefLB.SaveValue();
2874         SvxCharReliefItem aRelief((FontRelief)m_aReliefLB.GetSelectEntryPos(), nWhich);
2875         rSet.Put(aRelief);
2876     }
2877
2878     // Outline
2879     const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
2880     nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
2881     pOld = GetOldItem( rSet, SID_ATTR_CHAR_CONTOUR );
2882     TriState eState = m_aOutlineBtn.GetState();
2883     const SfxPoolItem* pItem;
2884
2885     if ( pOld )
2886     {
2887         const SvxContourItem& rItem = *( (const SvxContourItem*)pOld );
2888         if ( rItem.GetValue() == StateToAttr( eState ) && m_aOutlineBtn.GetSavedValue() == eState )
2889             bChanged = FALSE;
2890     }
2891
2892     if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
2893          !StateToAttr( eState ) && ( (SvxContourItem*)pItem )->GetValue() )
2894         bChanged = TRUE;
2895
2896     if ( bChanged && eState != STATE_DONTKNOW )
2897     {
2898         rSet.Put( SvxContourItem( StateToAttr( eState ), nWhich ) );
2899         bModified |= TRUE;
2900     }
2901     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2902         CLEARTITEM;
2903
2904     bChanged = TRUE;
2905
2906     // Shadow
2907     nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
2908     pOld = GetOldItem( rSet, SID_ATTR_CHAR_SHADOWED );
2909     eState = m_aShadowBtn.GetState();
2910
2911     if ( pOld )
2912     {
2913         const SvxShadowedItem& rItem = *( (const SvxShadowedItem*)pOld );
2914         if ( rItem.GetValue() == StateToAttr( eState ) && m_aShadowBtn.GetSavedValue() == eState )
2915             bChanged = FALSE;
2916     }
2917
2918     if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
2919          !StateToAttr( eState ) && ( (SvxShadowedItem*)pItem )->GetValue() )
2920         bChanged = TRUE;
2921
2922     if ( bChanged && eState != STATE_DONTKNOW )
2923     {
2924         rSet.Put( SvxShadowedItem( StateToAttr( eState ), nWhich ) );
2925         bModified = TRUE;
2926     }
2927     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2928         CLEARTITEM;
2929
2930     bChanged = TRUE;
2931
2932     // Blinking
2933     nWhich = GetWhich( SID_ATTR_FLASH );
2934     pOld = GetOldItem( rSet, SID_ATTR_FLASH );
2935     eState = m_aBlinkingBtn.GetState();
2936
2937     if ( pOld )
2938     {
2939         const SvxBlinkItem& rItem = *( (const SvxBlinkItem*)pOld );
2940         if ( rItem.GetValue() == StateToAttr( eState ) && m_aBlinkingBtn.GetSavedValue() == eState )
2941             bChanged = FALSE;
2942     }
2943
2944     if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
2945          !StateToAttr( eState ) && ( (SvxBlinkItem*)pItem )->GetValue() )
2946         bChanged = TRUE;
2947
2948     if ( bChanged && eState != STATE_DONTKNOW )
2949     {
2950         rSet.Put( SvxBlinkItem( StateToAttr( eState ), nWhich ) );
2951         bModified = TRUE;
2952     }
2953     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2954         CLEARTITEM;
2955
2956     // Hidden
2957     nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN );
2958     pOld = GetOldItem( rSet, SID_ATTR_CHAR_HIDDEN );
2959     eState = m_aHiddenBtn.GetState();
2960     bChanged = TRUE;
2961
2962     if ( pOld )
2963     {
2964         const SvxCharHiddenItem& rItem = *( (const SvxCharHiddenItem*)pOld );
2965         if ( rItem.GetValue() == StateToAttr( eState ) && m_aHiddenBtn.GetSavedValue() == eState )
2966             bChanged = FALSE;
2967     }
2968
2969     if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, FALSE, &pItem ) == SFX_ITEM_SET &&
2970          !StateToAttr( eState ) && ( (SvxCharHiddenItem*)pItem )->GetValue() )
2971         bChanged = TRUE;
2972
2973     if ( bChanged && eState != STATE_DONTKNOW )
2974     {
2975         rSet.Put( SvxCharHiddenItem( StateToAttr( eState ), nWhich ) );
2976         bModified = TRUE;
2977     }
2978     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
2979         CLEARTITEM;
2980
2981     bModified |= FillItemSetColor_Impl( rSet );
2982
2983     return bModified;
2984 }
2985
2986 void SvxCharEffectsPage::DisableControls( USHORT nDisable )
2987 {
2988     if ( ( DISABLE_CASEMAP & nDisable ) == DISABLE_CASEMAP )
2989     {
2990         m_aEffectsFT.Disable();
2991         m_aEffects2LB.Disable();
2992     }
2993
2994     if ( ( DISABLE_WORDLINE & nDisable ) == DISABLE_WORDLINE )
2995         m_aIndividualWordsBtn.Disable();
2996
2997     if ( ( DISABLE_BLINK & nDisable ) == DISABLE_BLINK )
2998         m_aBlinkingBtn.Disable();
2999
3000     if ( ( DISABLE_UNDERLINE_COLOR & nDisable ) == DISABLE_UNDERLINE_COLOR )
3001     {
3002         // disable the controls
3003         m_aUnderlineColorFT.Disable( );
3004         m_aUnderlineColorLB.Disable( );
3005         // and reroute the selection handler of the controls which normally would affect the color box dis-/enabling
3006         m_aUnderlineLB.SetSelectHdl(LINK(this, SvxCharEffectsPage, UpdatePreview_Impl));
3007         m_aStrikeoutLB.SetSelectHdl(LINK(this, SvxCharEffectsPage, UpdatePreview_Impl));
3008     }
3009 }
3010
3011 void SvxCharEffectsPage::EnableFlash()
3012 {
3013     if ( !( ( m_nHtmlMode & HTMLMODE_ON ) && !( m_nHtmlMode & HTMLMODE_BLINK ) ) )
3014         m_aBlinkingBtn.Show();
3015 }
3016
3017 // -----------------------------------------------------------------------
3018 void SvxCharEffectsPage::SetPreviewBackgroundToCharacter()
3019 {
3020     m_bPreviewBackgroundToCharacter = TRUE;
3021 }
3022
3023 // -----------------------------------------------------------------------
3024 void SvxCharEffectsPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
3025 {
3026     SFX_ITEMSET_ARG (&aSet,pDisableCtlItem,SfxUInt16Item,SID_DISABLE_CTL,sal_False);
3027     SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
3028     if (pDisableCtlItem)
3029         DisableControls(pDisableCtlItem->GetValue());
3030
3031     if (pFlagItem)
3032     {
3033         UINT32 nFlags=pFlagItem->GetValue();
3034         if ( ( nFlags & SVX_ENABLE_FLASH ) == SVX_ENABLE_FLASH )
3035             EnableFlash();
3036         if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
3037             SetPreviewBackgroundToCharacter();
3038     }
3039 }
3040
3041 // class SvxCharPositionPage ---------------------------------------------
3042
3043 SvxCharPositionPage::SvxCharPositionPage( Window* pParent, const SfxItemSet& rInSet ) :
3044
3045     SvxCharBasePage( pParent, SVX_RES( RID_SVXPAGE_CHAR_POSITION ), rInSet, WIN_POS_PREVIEW, FT_POS_FONTTYPE ),
3046
3047     m_aPositionLine             ( this, SVX_RES( FL_POSITION ) ),
3048     m_aHighPosBtn               ( this, SVX_RES( RB_HIGHPOS ) ),
3049     m_aNormalPosBtn             ( this, SVX_RES( RB_NORMALPOS ) ),
3050     m_aLowPosBtn                ( this, SVX_RES( RB_LOWPOS ) ),
3051     m_aHighLowFT                ( this, SVX_RES( FT_HIGHLOW ) ),
3052     m_aHighLowEdit              ( this, SVX_RES( ED_HIGHLOW ) ),
3053     m_aHighLowRB                ( this, SVX_RES( CB_HIGHLOW ) ),
3054     m_aFontSizeFT               ( this, SVX_RES( FT_FONTSIZE ) ),
3055     m_aFontSizeEdit             ( this, SVX_RES( ED_FONTSIZE ) ),
3056     m_aRotationScalingFL( this, SVX_RES( FL_ROTATION_SCALING ) ),
3057     m_aScalingFL                ( this, SVX_RES( FL_SCALING ) ),
3058     m_a0degRB                   ( this, SVX_RES( RB_0_DEG ) ),
3059     m_a90degRB                  ( this, SVX_RES( RB_90_DEG ) ),
3060     m_a270degRB                 ( this, SVX_RES( RB_270_DEG ) ),
3061     m_aFitToLineCB              ( this, SVX_RES( CB_FIT_TO_LINE ) ),
3062     m_aScaleWidthFT             ( this, SVX_RES( FT_SCALE_WIDTH ) ),
3063     m_aScaleWidthMF             ( this, SVX_RES( MF_SCALE_WIDTH ) ),
3064
3065     m_aKerningLine              ( this, SVX_RES( FL_KERNING2 ) ),
3066     m_aKerningLB                ( this, SVX_RES( LB_KERNING2 ) ),
3067     m_aKerningFT                ( this, SVX_RES( FT_KERNING2 ) ),
3068     m_aKerningEdit              ( this, SVX_RES( ED_KERNING2 ) ),
3069     m_aPairKerningBtn   ( this, SVX_RES( CB_PAIRKERNING ) ),
3070
3071     m_nSuperEsc                 ( (short)DFLT_ESC_SUPER ),
3072     m_nSubEsc                   ( (short)DFLT_ESC_SUB ),
3073     m_nScaleWidthItemSetVal     ( 100 ),
3074     m_nScaleWidthInitialVal     ( 100 ),
3075     m_nSuperProp                ( (BYTE)DFLT_ESC_PROP ),
3076     m_nSubProp          ( (BYTE)DFLT_ESC_PROP )
3077 {
3078     FreeResource();
3079     Initialize();
3080 }
3081
3082 // -----------------------------------------------------------------------
3083
3084 void SvxCharPositionPage::Initialize()
3085 {
3086     // to handle the changes of the other pages
3087     SetExchangeSupport();
3088
3089     GetPreviewFont().SetSize( Size( 0, 240 ) );
3090     GetPreviewCJKFont().SetSize( Size( 0, 240 ) );
3091     GetPreviewCTLFont().SetSize( Size( 0, 240 ) );
3092
3093     m_aNormalPosBtn.Check();
3094     PositionHdl_Impl( &m_aNormalPosBtn );
3095     m_aKerningLB.SelectEntryPos( 0 );
3096     KerningSelectHdl_Impl( NULL );
3097
3098     Link aLink = LINK( this, SvxCharPositionPage, PositionHdl_Impl );
3099     m_aHighPosBtn.SetClickHdl( aLink );
3100     m_aNormalPosBtn.SetClickHdl( aLink );
3101     m_aLowPosBtn.SetClickHdl( aLink );
3102
3103     aLink = LINK( this, SvxCharPositionPage, RotationHdl_Impl );
3104     m_a0degRB  .SetClickHdl( aLink );
3105     m_a90degRB .SetClickHdl( aLink );
3106     m_a270degRB.SetClickHdl( aLink );
3107
3108     aLink = LINK( this, SvxCharPositionPage, FontModifyHdl_Impl );
3109     m_aHighLowEdit.SetModifyHdl( aLink );
3110     m_aFontSizeEdit.SetModifyHdl( aLink );
3111
3112     aLink = LINK( this, SvxCharPositionPage, LoseFocusHdl_Impl );
3113     m_aHighLowEdit.SetLoseFocusHdl( aLink );
3114     m_aFontSizeEdit.SetLoseFocusHdl( aLink );
3115
3116     m_aHighLowRB.SetClickHdl( LINK( this, SvxCharPositionPage, AutoPositionHdl_Impl ) );
3117     m_aFitToLineCB.SetClickHdl( LINK( this, SvxCharPositionPage, FitToLineHdl_Impl ) );
3118     m_aKerningLB.SetSelectHdl( LINK( this, SvxCharPositionPage, KerningSelectHdl_Impl ) );
3119     m_aKerningEdit.SetModifyHdl( LINK( this, SvxCharPositionPage, KerningModifyHdl_Impl ) );
3120     m_aPairKerningBtn.SetClickHdl( LINK( this, SvxCharPositionPage, PairKerningHdl_Impl ) );
3121     m_aScaleWidthMF.SetModifyHdl( LINK( this, SvxCharPositionPage, ScaleWidthModifyHdl_Impl ) );
3122 }
3123
3124 // -----------------------------------------------------------------------
3125
3126 void SvxCharPositionPage::UpdatePreview_Impl( BYTE nProp, BYTE nEscProp, short nEsc )
3127 {
3128     SetPrevFontEscapement( nProp, nEscProp, nEsc );
3129 }
3130
3131 // -----------------------------------------------------------------------
3132
3133 void SvxCharPositionPage::SetEscapement_Impl( USHORT nEsc )
3134 {
3135     SvxEscapementItem aEscItm( (SvxEscapement)nEsc, SID_ATTR_CHAR_ESCAPEMENT );
3136
3137     if ( SVX_ESCAPEMENT_SUPERSCRIPT == nEsc )
3138     {
3139         aEscItm.GetEsc() = m_nSuperEsc;
3140         aEscItm.GetProp() = m_nSuperProp;
3141     }
3142     else if ( SVX_ESCAPEMENT_SUBSCRIPT == nEsc )
3143     {
3144         aEscItm.GetEsc() = m_nSubEsc;
3145         aEscItm.GetProp() = m_nSubProp;
3146     }
3147
3148     short nFac = aEscItm.GetEsc() < 0 ? -1 : 1;
3149
3150     m_aHighLowEdit.SetValue( aEscItm.GetEsc() * nFac );
3151     m_aFontSizeEdit.SetValue( aEscItm.GetProp() );
3152
3153     if ( SVX_ESCAPEMENT_OFF == nEsc )
3154     {
3155         m_aHighLowFT.Disable();
3156         m_aHighLowEdit.Disable();
3157         m_aFontSizeFT.Disable();
3158         m_aFontSizeEdit.Disable();
3159         m_aHighLowRB.Disable();
3160     }
3161     else
3162     {
3163         m_aFontSizeFT.Enable();
3164         m_aFontSizeEdit.Enable();
3165         m_aHighLowRB.Enable();
3166
3167         if ( !m_aHighLowRB.IsChecked() )
3168         {
3169             m_aHighLowFT.Enable();
3170             m_aHighLowEdit.Enable();
3171         }
3172         else
3173             AutoPositionHdl_Impl( &m_aHighLowRB );
3174     }
3175
3176     UpdatePreview_Impl( 100, aEscItm.GetProp(), aEscItm.GetEsc() );
3177 }
3178
3179 // -----------------------------------------------------------------------
3180
3181 IMPL_LINK( SvxCharPositionPage, PositionHdl_Impl, RadioButton*, pBtn )
3182 {
3183     USHORT nEsc = SVX_ESCAPEMENT_OFF;   // also when pBtn == NULL
3184
3185     if ( &m_aHighPosBtn == pBtn )
3186         nEsc = SVX_ESCAPEMENT_SUPERSCRIPT;
3187     else if ( &m_aLowPosBtn == pBtn )
3188         nEsc = SVX_ESCAPEMENT_SUBSCRIPT;
3189
3190     SetEscapement_Impl( nEsc );
3191     return 0;
3192 }
3193
3194 // -----------------------------------------------------------------------
3195
3196 IMPL_LINK( SvxCharPositionPage, RotationHdl_Impl, RadioButton*, pBtn )
3197 {
3198     BOOL bEnable = FALSE;
3199     if (&m_a90degRB == pBtn  ||  &m_a270degRB == pBtn)
3200         bEnable = TRUE;
3201     else
3202         OSL_ENSURE( &m_a0degRB == pBtn, "unexpected button" );
3203     m_aFitToLineCB.Enable( bEnable );
3204     return 0;
3205 }
3206
3207 // -----------------------------------------------------------------------
3208
3209 IMPL_LINK( SvxCharPositionPage, FontModifyHdl_Impl, MetricField*, EMPTYARG )
3210 {
3211     BYTE nEscProp = (BYTE)m_aFontSizeEdit.GetValue();
3212     short nEsc  = (short)m_aHighLowEdit.GetValue();
3213     nEsc *= m_aLowPosBtn.IsChecked() ? -1 : 1;
3214     UpdatePreview_Impl( 100, nEscProp, nEsc );
3215     return 0;
3216 }
3217
3218 // -----------------------------------------------------------------------
3219
3220 IMPL_LINK( SvxCharPositionPage, AutoPositionHdl_Impl, CheckBox*, pBox )
3221 {
3222     if ( pBox->IsChecked() )
3223     {
3224         m_aHighLowFT.Disable();
3225         m_aHighLowEdit.Disable();
3226     }
3227     else
3228         PositionHdl_Impl( m_aHighPosBtn.IsChecked() ? &m_aHighPosBtn
3229                                                       : m_aLowPosBtn.IsChecked() ? &m_aLowPosBtn
3230                                                                                    : &m_aNormalPosBtn );
3231     return 0;
3232 }
3233
3234 // -----------------------------------------------------------------------
3235
3236 IMPL_LINK( SvxCharPositionPage, FitToLineHdl_Impl, CheckBox*, pBox )
3237 {
3238     if ( &m_aFitToLineCB == pBox)
3239     {
3240         UINT16 nVal = m_nScaleWidthInitialVal;
3241         if (m_aFitToLineCB.IsChecked())
3242             nVal = m_nScaleWidthItemSetVal;
3243         m_aScaleWidthMF.SetValue( nVal );
3244
3245         m_aPreviewWin.SetFontWidthScale( nVal );
3246     }
3247     return 0;
3248 }
3249
3250 // -----------------------------------------------------------------------
3251
3252 IMPL_LINK( SvxCharPositionPage, KerningSelectHdl_Impl, ListBox*, EMPTYARG )
3253 {
3254     if ( m_aKerningLB.GetSelectEntryPos() > 0 )
3255     {
3256         m_aKerningFT.Enable();
3257         m_aKerningEdit.Enable();
3258
3259         if ( m_aKerningLB.GetSelectEntryPos() == 2 )
3260         {
3261             // Condensed -> max value == 1/6 of the current font height
3262             SvxFont& rFont = GetPreviewFont();
3263             long nMax = rFont.GetSize().Height() / 6;
3264             m_aKerningEdit.SetMax( m_aKerningEdit.Normalize( nMax ), FUNIT_TWIP );
3265             m_aKerningEdit.SetLast( m_aKerningEdit.GetMax( m_aKerningEdit.GetUnit() ) );
3266         }
3267         else
3268         {
3269             m_aKerningEdit.SetMax( 9999 );
3270             m_aKerningEdit.SetLast( 9999 );
3271         }
3272     }
3273     else
3274     {
3275         m_aKerningEdit.SetValue( 0 );
3276         m_aKerningFT.Disable();
3277         m_aKerningEdit.Disable();
3278     }
3279
3280     KerningModifyHdl_Impl( NULL );
3281
3282     return 0;
3283 }
3284
3285 // -----------------------------------------------------------------------
3286
3287 IMPL_LINK( SvxCharPositionPage, KerningModifyHdl_Impl, MetricField*, EMPTYARG )
3288 {
3289     long nVal = static_cast<long>(m_aKerningEdit.GetValue());
3290     nVal = LogicToLogic( nVal, MAP_POINT, MAP_TWIP );
3291     long nKern = (short)m_aKerningEdit.Denormalize( nVal );
3292
3293     // Condensed? -> then negative
3294     if ( m_aKerningLB.GetSelectEntryPos() == 2 )
3295         nKern *= -1;
3296
3297     SvxFont& rFont = GetPreviewFont();
3298     SvxFont& rCJKFont = GetPreviewCJKFont();
3299     SvxFont& rCTLFont = GetPreviewCTLFont();
3300
3301     rFont.SetFixKerning( (short)nKern );
3302     rCJKFont.SetFixKerning( (short)nKern );
3303     rCTLFont.SetFixKerning( (short)nKern );
3304     m_aPreviewWin.Invalidate();
3305     return 0;
3306 }
3307
3308 // -----------------------------------------------------------------------
3309
3310 IMPL_LINK( SvxCharPositionPage, PairKerningHdl_Impl, CheckBox*, EMPTYARG )
3311 {
3312     return 0;
3313 }
3314
3315 // -----------------------------------------------------------------------
3316
3317 IMPL_LINK( SvxCharPositionPage, LoseFocusHdl_Impl, MetricField*, pField )
3318 {
3319 #ifdef DBG_UTIL
3320     sal_Bool bHigh = m_aHighPosBtn.IsChecked();
3321 #endif
3322     sal_Bool bLow = m_aLowPosBtn.IsChecked();
3323     DBG_ASSERT( bHigh || bLow, "normal position is not valid" );
3324
3325     if ( &m_aHighLowEdit == pField )
3326     {
3327         if ( bLow )
3328             m_nSubEsc = (short)m_aHighLowEdit.GetValue() * -1;
3329         else
3330             m_nSuperEsc = (short)m_aHighLowEdit.GetValue();
3331     }
3332     else if ( &m_aFontSizeEdit == pField )
3333     {
3334         if ( bLow )
3335             m_nSubProp = (BYTE)m_aFontSizeEdit.GetValue();
3336         else
3337             m_nSuperProp = (BYTE)m_aFontSizeEdit.GetValue();
3338     }
3339     return 0;
3340 }
3341
3342 // -----------------------------------------------------------------------
3343
3344 IMPL_LINK( SvxCharPositionPage, ScaleWidthModifyHdl_Impl, MetricField*, EMPTYARG )
3345 {
3346     m_aPreviewWin.SetFontWidthScale( USHORT( m_aScaleWidthMF.GetValue() ) );
3347
3348     return 0;
3349 }
3350
3351 /* -----------------28.08.2003 12:12-----------------
3352
3353  --------------------------------------------------*/
3354 void  SvxCharPositionPage::ActivatePage( const SfxItemSet& rSet )
3355 {
3356     //update the preview
3357     SvxCharBasePage::ActivatePage( rSet );
3358
3359     //the only thing that has to be checked is the max. allowed value for the
3360     //condense edit field
3361     if ( m_aKerningLB.GetSelectEntryPos() == 2 )
3362     {
3363         // Condensed -> max value == 1/6 of the current font height
3364         SvxFont& rFont = GetPreviewFont();
3365         long nMax = rFont.GetSize().Height() / 6;
3366         long nKern = (short)m_aKerningEdit.Denormalize( LogicToLogic( static_cast<long>(m_aKerningEdit.GetValue()), MAP_POINT, MAP_TWIP ) );
3367         m_aKerningEdit.SetMax( m_aKerningEdit.Normalize( nKern > nMax ? nKern : nMax ), FUNIT_TWIP );
3368         m_aKerningEdit.SetLast( m_aKerningEdit.GetMax( m_aKerningEdit.GetUnit() ) );
3369     }
3370 }
3371
3372 // -----------------------------------------------------------------------
3373
3374 int SvxCharPositionPage::DeactivatePage( SfxItemSet* _pSet )
3375 {
3376     if ( _pSet )
3377         FillItemSet( *_pSet );
3378     return LEAVE_PAGE;
3379 }
3380
3381 // -----------------------------------------------------------------------
3382
3383 SfxTabPage* SvxCharPositionPage::Create( Window* pParent, const SfxItemSet& rSet )
3384 {
3385     return new SvxCharPositionPage( pParent, rSet );
3386 }
3387
3388 // -----------------------------------------------------------------------
3389
3390 USHORT* SvxCharPositionPage::GetRanges()
3391 {
3392     return pPositionRanges;
3393 }
3394
3395 // -----------------------------------------------------------------------
3396 #define ENABLE_AND_CHECK( aCheckBox )   \
3397     if ( !aCheckBox.IsEnabled() )               \
3398         aCheckBox.Enable();                             \
3399     aCheckBox.Check( TRUE )
3400
3401 void SvxCharPositionPage::Reset( const SfxItemSet& rSet )
3402 {
3403     String sUser = GetUserData();
3404
3405     if ( sUser.Len() )
3406     {
3407         m_nSuperEsc = (short)sUser.GetToken( 0 ).ToInt32();
3408         m_nSubEsc = (short)sUser.GetToken( 1 ).ToInt32();
3409         m_nSuperProp = (BYTE)sUser.GetToken( 2 ).ToInt32();
3410         m_nSubProp = (BYTE)sUser.GetToken( 3 ).ToInt32();
3411     }
3412
3413     short nEsc = 0;
3414     BYTE nEscProp = 100;
3415     BYTE nProp = 100;
3416
3417     m_aHighLowFT.Disable();
3418     m_aHighLowEdit.Disable();
3419     m_aFontSizeFT.Disable();
3420     m_aFontSizeEdit.Disable();
3421
3422     SvxFont& rFont = GetPreviewFont();
3423     SvxFont& rCJKFont = GetPreviewCJKFont();
3424     SvxFont& rCTLFont = GetPreviewCTLFont();
3425     USHORT nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
3426
3427     if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
3428     {
3429         const SvxEscapementItem& rItem = (SvxEscapementItem&)rSet.Get( nWhich );
3430         nEsc = rItem.GetEsc();
3431         nEscProp = rItem.GetProp();
3432
3433         if ( nEsc != 0 )
3434         {
3435             m_aHighLowFT.Enable();
3436             m_aHighLowEdit.Enable();
3437             m_aFontSizeFT.Enable();
3438             m_aFontSizeEdit.Enable();
3439
3440             short nFac;
3441
3442             if ( nEsc > 0 )
3443             {
3444                 nFac = 1;
3445                 m_aHighPosBtn.Check( TRUE );
3446                 if ( nEsc == DFLT_ESC_AUTO_SUPER )
3447                 {
3448                     ENABLE_AND_CHECK( m_aHighLowRB );
3449                     nEsc = DFLT_ESC_SUPER;
3450                 }
3451             }
3452             else
3453             {
3454                 nFac = -1;
3455                 m_aLowPosBtn.Check( TRUE );
3456                 if ( nEsc == DFLT_ESC_AUTO_SUB )
3457                 {
3458                     ENABLE_AND_CHECK( m_aHighLowRB );
3459                     nEsc = DFLT_ESC_SUB;
3460                 }
3461             }
3462
3463             if ( m_aHighLowRB.IsChecked() )
3464             {
3465                 m_aHighLowFT.Disable();
3466                 m_aHighLowEdit.Disable();
3467             }
3468             m_aHighLowEdit.SetValue( m_aHighLowEdit.Normalize( nFac * nEsc ) );
3469         }
3470         else
3471         {
3472             m_aNormalPosBtn.Check( TRUE );
3473             m_aHighLowRB.Check( TRUE );
3474             PositionHdl_Impl( NULL );
3475         }
3476         //the height has to be set after the handler is called to keep the value also if the escapement is zero
3477         m_aFontSizeEdit.SetValue( m_aFontSizeEdit.Normalize( nEscProp ) );
3478     }
3479     else
3480     {
3481         m_aHighPosBtn.Check( FALSE );
3482         m_aNormalPosBtn.Check( FALSE );
3483         m_aLowPosBtn.Check( FALSE );
3484     }
3485
3486     // BspFont setzen
3487     SetPrevFontEscapement( nProp, nEscProp, nEsc );
3488
3489     // Kerning
3490     nWhich = GetWhich( SID_ATTR_CHAR_KERNING );
3491
3492     if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
3493     {
3494         const SvxKerningItem& rItem = (SvxKerningItem&)rSet.Get( nWhich );
3495         SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
3496         MapUnit eOrgUnit = (MapUnit)eUnit;
3497         MapUnit ePntUnit( MAP_POINT );
3498         long nBig = static_cast<long>(m_aKerningEdit.Normalize( static_cast<long>(rItem.GetValue()) ));
3499         long nKerning = LogicToLogic( nBig, eOrgUnit, ePntUnit );
3500
3501         // Kerning am Font setzen, vorher in Twips umrechnen
3502         long nKern = LogicToLogic( rItem.GetValue(), (MapUnit)eUnit, MAP_TWIP );
3503         rFont.SetFixKerning( (short)nKern );
3504         rCJKFont.SetFixKerning( (short)nKern );
3505         rCTLFont.SetFixKerning( (short)nKern );
3506
3507         if ( nKerning > 0 )
3508         {
3509             m_aKerningLB.SelectEntryPos( LW_GESPERRT );
3510         }
3511         else if ( nKerning < 0 )
3512         {
3513             m_aKerningLB.SelectEntryPos( LW_SCHMAL );
3514             nKerning = -nKerning;
3515         }
3516         else
3517         {
3518             nKerning = 0;
3519             m_aKerningLB.SelectEntryPos( LW_NORMAL );
3520         }
3521         //enable/disable and set min/max of the Edit
3522         KerningSelectHdl_Impl(&m_aKerningLB);
3523         //the attribute value must be displayed also if it's above the maximum allowed value
3524         long nVal = static_cast<long>(m_aKerningEdit.GetMax());
3525         if(nVal < nKerning)
3526             m_aKerningEdit.SetMax( nKerning );
3527         m_aKerningEdit.SetValue( nKerning );
3528     }
3529     else
3530         m_aKerningEdit.SetText( String() );
3531
3532     // Pair kerning
3533     nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN );
3534
3535     if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
3536     {
3537         const SvxAutoKernItem& rItem = (SvxAutoKernItem&)rSet.Get( nWhich );
3538         m_aPairKerningBtn.Check( rItem.GetValue() );
3539     }
3540     else
3541         m_aPairKerningBtn.Check( FALSE );
3542
3543     // Scale Width
3544     nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
3545     if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
3546     {
3547         const SvxCharScaleWidthItem& rItem = ( SvxCharScaleWidthItem& ) rSet.Get( nWhich );
3548         m_nScaleWidthInitialVal = rItem.GetValue();
3549         m_aScaleWidthMF.SetValue( m_nScaleWidthInitialVal );
3550     }
3551     else
3552         m_aScaleWidthMF.SetValue( 100 );
3553
3554     nWhich = GetWhich( SID_ATTR_CHAR_WIDTH_FIT_TO_LINE );
3555     if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
3556         m_nScaleWidthItemSetVal = ((SfxUInt16Item&) rSet.Get( nWhich )).GetValue();
3557
3558     // Rotation
3559     nWhich = GetWhich( SID_ATTR_CHAR_ROTATED );
3560     SfxItemState eState = rSet.GetItemState( nWhich );
3561     if( SFX_ITEM_UNKNOWN == eState )
3562     {
3563         m_aRotationScalingFL.Hide();
3564         m_aScalingFL.Show();
3565         m_a0degRB.Hide();
3566         m_a90degRB.Hide();
3567         m_a270degRB.Hide();
3568         m_aFitToLineCB.Hide();
3569         m_aFitToLineCB .Hide();
3570
3571
3572         // move the following controls upwards
3573         Window* aCntrlArr[] = {
3574             &m_aScaleWidthFT, &m_aScaleWidthMF, &m_aKerningLine,
3575             &m_aKerningLB, &m_aKerningFT, &m_aKerningEdit, &m_aPairKerningBtn,
3576             0 };
3577
3578         long nDiff = m_aScaleWidthMF.GetPosPixel().Y() -
3579                         m_a0degRB.GetPosPixel().Y();
3580
3581         for( Window** ppW = aCntrlArr; *ppW; ++ppW )
3582         {
3583             Point aPnt( (*ppW)->GetPosPixel() );
3584             aPnt.Y() -= nDiff;
3585             (*ppW)->SetPosPixel( aPnt );
3586         }
3587     }
3588     else
3589     {
3590         m_aScalingFL.Hide();
3591
3592         Link aOldLink( m_aFitToLineCB.GetClickHdl() );
3593         m_aFitToLineCB.SetClickHdl( Link() );
3594         if( eState >= SFX_ITEM_DEFAULT )
3595         {
3596             const SvxCharRotateItem& rItem =
3597                     (SvxCharRotateItem&) rSet.Get( nWhich );
3598             if (rItem.IsBottomToTop())
3599                 m_a90degRB.Check( TRUE );
3600             else if (rItem.IsTopToBotton())
3601                 m_a270degRB.Check( TRUE );
3602             else
3603             {
3604                 DBG_ASSERT( 0 == rItem.GetValue(), "incorrect value" );
3605                 m_a0degRB.Check( TRUE );
3606             }
3607             m_aFitToLineCB.Check( rItem.IsFitToLine() );
3608         }
3609         else
3610         {
3611             if( eState == SFX_ITEM_DONTCARE )
3612             {
3613                 m_a0degRB.Check( FALSE );
3614                 m_a90degRB.Check( FALSE );
3615                 m_a270degRB.Check( FALSE );
3616             }
3617             else
3618                 m_a0degRB.Check( TRUE );
3619
3620             m_aFitToLineCB.Check( FALSE );
3621         }
3622         m_aFitToLineCB.SetClickHdl( aOldLink );
3623         m_aFitToLineCB.Enable( !m_a0degRB.IsChecked() );
3624
3625         // is this value set?
3626         if( SFX_ITEM_UNKNOWN == rSet.GetItemState( GetWhich(
3627                                         SID_ATTR_CHAR_WIDTH_FIT_TO_LINE ) ))
3628             m_aFitToLineCB.Hide();
3629     }
3630
3631     m_aHighPosBtn.SaveValue();
3632     m_aNormalPosBtn.SaveValue();
3633     m_aLowPosBtn.SaveValue();
3634     m_a0degRB.SaveValue();
3635     m_a90degRB.SaveValue();
3636     m_a270degRB.SaveValue();
3637     m_aFitToLineCB.SaveValue();
3638     m_aScaleWidthMF.SaveValue();
3639     m_aKerningLB.SaveValue();
3640     m_aKerningEdit.SaveValue();
3641     m_aPairKerningBtn.SaveValue();
3642 }
3643
3644 // -----------------------------------------------------------------------
3645
3646 BOOL SvxCharPositionPage::FillItemSet( SfxItemSet& rSet )
3647 {
3648     //  Position (hoch, normal oder tief)
3649     const SfxItemSet& rOldSet = GetItemSet();
3650     BOOL bModified = FALSE, bChanged = TRUE;
3651     USHORT nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
3652     const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_CHAR_ESCAPEMENT );
3653     const FASTBOOL bHigh = m_aHighPosBtn.IsChecked();
3654     short nEsc;
3655     BYTE  nEscProp;
3656
3657     if ( bHigh || m_aLowPosBtn.IsChecked() )
3658     {
3659         if ( m_aHighLowRB.IsChecked() )
3660             nEsc = bHigh ? DFLT_ESC_AUTO_SUPER : DFLT_ESC_AUTO_SUB;
3661         else
3662         {
3663             nEsc = (short)m_aHighLowEdit.Denormalize( m_aHighLowEdit.GetValue() );
3664             nEsc *= bHigh ? 1 : -1;
3665         }
3666         nEscProp = (BYTE)m_aFontSizeEdit.Denormalize( m_aFontSizeEdit.GetValue() );
3667     }
3668     else
3669     {
3670         nEsc  = 0;
3671         nEscProp = 100;
3672     }
3673
3674     if ( pOld )
3675     {
3676         const SvxEscapementItem& rItem = *( (const SvxEscapementItem*)pOld );
3677         if ( rItem.GetEsc() == nEsc && rItem.GetProp() == nEscProp      )
3678             bChanged = FALSE;
3679     }
3680
3681     if ( !bChanged && !m_aHighPosBtn.GetSavedValue() &&
3682          !m_aNormalPosBtn.GetSavedValue() && !m_aLowPosBtn.GetSavedValue() )
3683         bChanged = TRUE;
3684
3685     if ( bChanged &&
3686          ( m_aHighPosBtn.IsChecked() || m_aNormalPosBtn.IsChecked() || m_aLowPosBtn.IsChecked() ) )
3687     {
3688         rSet.Put( SvxEscapementItem( nEsc, nEscProp, nWhich ) );
3689         bModified = TRUE;
3690     }
3691     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
3692         CLEARTITEM;
3693
3694     bChanged = TRUE;
3695
3696     // Kerning
3697     nWhich = GetWhich( SID_ATTR_CHAR_KERNING );
3698     pOld = GetOldItem( rSet, SID_ATTR_CHAR_KERNING );
3699     USHORT nPos = m_aKerningLB.GetSelectEntryPos();
3700     short nKerning = 0;
3701     SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
3702
3703     if ( nPos == LW_GESPERRT || nPos == LW_SCHMAL )
3704     {
3705         long nTmp = static_cast<long>(m_aKerningEdit.GetValue());
3706         long nVal = LogicToLogic( nTmp, MAP_POINT, (MapUnit)eUnit );
3707         nKerning = (short)m_aKerningEdit.Denormalize( nVal );
3708
3709         if ( nPos == LW_SCHMAL )
3710             nKerning *= - 1;
3711     }
3712
3713     if ( pOld )
3714     {
3715         const SvxKerningItem& rItem = *( (const SvxKerningItem*)pOld );
3716         if ( rItem.GetValue() == nKerning )
3717             bChanged = FALSE;
3718     }
3719
3720     if ( !bChanged &&
3721          ( m_aKerningLB.GetSavedValue() == LISTBOX_ENTRY_NOTFOUND ||
3722            ( !m_aKerningEdit.GetSavedValue().Len() && m_aKerningEdit.IsEnabled() ) ) )
3723         bChanged = TRUE;
3724
3725     if ( bChanged && nPos != LISTBOX_ENTRY_NOTFOUND )
3726     {
3727         rSet.Put( SvxKerningItem( nKerning, nWhich ) );
3728         bModified |= TRUE;
3729     }
3730     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
3731         CLEARTITEM;
3732
3733     bChanged = TRUE;
3734
3735     // Pair-Kerning
3736     nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN );
3737
3738     if ( m_aPairKerningBtn.IsChecked() != m_aPairKerningBtn.GetSavedValue() )
3739     {
3740         rSet.Put( SvxAutoKernItem( m_aPairKerningBtn.IsChecked(), nWhich ) );
3741         bModified |= TRUE;
3742     }
3743     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
3744         CLEARTITEM;
3745
3746     // Scale Width
3747     nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
3748     if ( m_aScaleWidthMF.GetText() != m_aScaleWidthMF.GetSavedValue() )
3749     {
3750         rSet.Put( SvxCharScaleWidthItem( (USHORT)m_aScaleWidthMF.GetValue(), nWhich ) );
3751         bModified |= TRUE;
3752     }
3753     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
3754         CLEARTITEM;
3755
3756     // Rotation
3757     nWhich = GetWhich( SID_ATTR_CHAR_ROTATED );
3758     if ( m_a0degRB     .IsChecked() != m_a0degRB     .GetSavedValue()  ||
3759          m_a90degRB    .IsChecked() != m_a90degRB    .GetSavedValue()  ||
3760          m_a270degRB   .IsChecked() != m_a270degRB   .GetSavedValue()  ||
3761          m_aFitToLineCB.IsChecked() != m_aFitToLineCB.GetSavedValue() )
3762     {
3763         SvxCharRotateItem aItem( 0, m_aFitToLineCB.IsChecked(), nWhich );
3764         if (m_a90degRB.IsChecked())
3765             aItem.SetBottomToTop();
3766         else if (m_a270degRB.IsChecked())
3767             aItem.SetTopToBotton();
3768         rSet.Put( aItem );
3769         bModified |= TRUE;
3770     }
3771     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
3772         CLEARTITEM;
3773
3774     return bModified;
3775 }
3776
3777 // -----------------------------------------------------------------------
3778
3779 void SvxCharPositionPage::FillUserData()
3780 {
3781     const sal_Unicode cTok = ';';
3782
3783     String sUser( UniString::CreateFromInt32( m_nSuperEsc ) );
3784     sUser.Append( cTok );
3785     sUser.Append( UniString::CreateFromInt32( m_nSubEsc ) );
3786     sUser.Append( cTok );
3787     sUser.Append( UniString::CreateFromInt32( m_nSuperProp ) );
3788     sUser.Append( cTok );
3789     sUser.Append( UniString::CreateFromInt32( m_nSubProp ) );
3790     SetUserData( sUser );
3791 }
3792
3793 // -----------------------------------------------------------------------
3794 void SvxCharPositionPage::SetPreviewBackgroundToCharacter()
3795 {
3796     m_bPreviewBackgroundToCharacter = TRUE;
3797 }
3798 // -----------------------------------------------------------------------
3799 void SvxCharPositionPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
3800 {
3801     SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
3802     if (pFlagItem)
3803     {
3804         UINT32 nFlags=pFlagItem->GetValue();
3805         if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
3806             SetPreviewBackgroundToCharacter();
3807     }
3808 }
3809 // class SvxCharTwoLinesPage ------------------------------------------------
3810
3811 SvxCharTwoLinesPage::SvxCharTwoLinesPage( Window* pParent, const SfxItemSet& rInSet ) :
3812
3813     SvxCharBasePage( pParent, SVX_RES( RID_SVXPAGE_CHAR_TWOLINES ), rInSet, WIN_TWOLINES_PREVIEW, FT_TWOLINES_FONTTYPE ),
3814
3815     m_aSwitchOnLine             ( this, SVX_RES( FL_SWITCHON ) ),
3816     m_aTwoLinesBtn              ( this, SVX_RES( CB_TWOLINES ) ),
3817
3818     m_aEncloseLine              ( this, SVX_RES( FL_ENCLOSE ) ),
3819     m_aStartBracketFT   ( this, SVX_RES( FT_STARTBRACKET ) ),
3820     m_aStartBracketLB   ( this, SVX_RES( ED_STARTBRACKET ) ),
3821     m_aEndBracketFT             ( this, SVX_RES( FT_ENDBRACKET ) ),
3822     m_aEndBracketLB             ( this, SVX_RES( ED_ENDBRACKET ) ),
3823     m_nStartBracketPosition( 0 ),
3824     m_nEndBracketPosition( 0 )
3825 {
3826     FreeResource();
3827     Initialize();
3828 }
3829
3830 // -----------------------------------------------------------------------
3831
3832 void SvxCharTwoLinesPage::Initialize()
3833 {
3834     Size aSize = m_aStartBracketLB.GetSizePixel();
3835     aSize.Height() = m_aStartBracketLB.CalcSize( 1, 6 ).Height();
3836     m_aStartBracketLB.SetSizePixel( aSize );
3837     aSize = m_aEndBracketLB.GetSizePixel();
3838     aSize.Height() = m_aEndBracketLB.CalcSize( 1, 6 ).Height();
3839     m_aEndBracketLB.SetSizePixel( aSize );
3840
3841     m_aTwoLinesBtn.Check( FALSE );
3842     TwoLinesHdl_Impl( NULL );
3843
3844     m_aTwoLinesBtn.SetClickHdl( LINK( this, SvxCharTwoLinesPage, TwoLinesHdl_Impl ) );
3845
3846     Link aLink = LINK( this, SvxCharTwoLinesPage, CharacterMapHdl_Impl );
3847     m_aStartBracketLB.SetSelectHdl( aLink );
3848     m_aEndBracketLB.SetSelectHdl( aLink );
3849
3850     SvxFont& rFont = GetPreviewFont();
3851     SvxFont& rCJKFont = GetPreviewCJKFont();
3852     SvxFont& rCTLFont = GetPreviewCTLFont();
3853     rFont.SetSize( Size( 0, 220 ) );
3854     rCJKFont.SetSize( Size( 0, 220 ) );
3855     rCTLFont.SetSize( Size( 0, 220 ) );
3856 }
3857
3858 // -----------------------------------------------------------------------
3859
3860 void SvxCharTwoLinesPage::SelectCharacter( ListBox* pBox )
3861 {
3862     //CHINA001 SvxCharacterMap aDlg( this );
3863     bool bStart = pBox == &m_aStartBracketLB;
3864     //SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
3865     //if(pFact)
3866     {
3867         //AbstractSvxCharacterMap* aDlg = pFact->CreateSvxCharacterMap( this,  RID_SVXDLG_CHARMAP );
3868         SvxCharacterMap* aDlg = new SvxCharacterMap( this );
3869         aDlg->DisableFontSelection();//CHINA001 aDlg.DisableFontSelection();
3870
3871         if ( aDlg->Execute() == RET_OK )//CHINA001 ( aDlg.Execute() == RET_OK )
3872         {
3873             sal_Unicode cChar = (sal_Unicode) aDlg->GetChar();//CHINA001 aDlg.GetChar();
3874             SetBracket( cChar, bStart );
3875         }
3876         else
3877         {
3878             pBox->SelectEntryPos( bStart ? m_nStartBracketPosition : m_nEndBracketPosition );
3879         }
3880         delete aDlg; //add CHINA001
3881     }
3882 }
3883
3884 // -----------------------------------------------------------------------
3885
3886 void SvxCharTwoLinesPage::SetBracket( sal_Unicode cBracket, BOOL bStart )
3887 {
3888     USHORT nEntryPos = 0;
3889     ListBox* pBox = bStart ? &m_aStartBracketLB : &m_aEndBracketLB;
3890     if ( 0 == cBracket )
3891         pBox->SelectEntryPos(0);
3892     else
3893     {
3894         FASTBOOL bFound = FALSE;
3895         for ( USHORT i = 1; i < pBox->GetEntryCount(); ++i )
3896         {
3897             if ( (ULONG)pBox->GetEntryData(i) != CHRDLG_ENCLOSE_SPECIAL_CHAR )
3898             {
3899                 const sal_Unicode cChar = pBox->GetEntry(i).GetChar(0);
3900                 if ( cChar == cBracket )
3901                 {
3902                     pBox->SelectEntryPos(i);
3903                     nEntryPos = i;
3904                     bFound = TRUE;
3905                     break;
3906                 }
3907             }
3908         }
3909
3910         if ( !bFound )
3911         {
3912             nEntryPos = pBox->InsertEntry( String( cBracket ) );
3913             pBox->SelectEntryPos( nEntryPos );
3914         }
3915     }
3916     if( bStart )
3917         m_nStartBracketPosition = nEntryPos;
3918     else
3919         m_nEndBracketPosition = nEntryPos;
3920 }
3921
3922 // -----------------------------------------------------------------------
3923
3924 IMPL_LINK( SvxCharTwoLinesPage, TwoLinesHdl_Impl, CheckBox*, EMPTYARG )
3925 {
3926     BOOL bChecked = m_aTwoLinesBtn.IsChecked();
3927     m_aStartBracketFT.Enable( bChecked );
3928     m_aStartBracketLB.Enable( bChecked );
3929     m_aEndBracketFT.Enable( bChecked );
3930     m_aEndBracketLB.Enable( bChecked );
3931
3932     UpdatePreview_Impl();
3933     return 0;
3934 }
3935
3936 // -----------------------------------------------------------------------
3937
3938 IMPL_LINK( SvxCharTwoLinesPage, CharacterMapHdl_Impl, ListBox*, pBox )
3939 {
3940     USHORT nPos = pBox->GetSelectEntryPos();
3941     if ( CHRDLG_ENCLOSE_SPECIAL_CHAR == (ULONG)pBox->GetEntryData( nPos ) )
3942         SelectCharacter( pBox );
3943     else
3944     {
3945         bool bStart = pBox == &m_aStartBracketLB;
3946         if( bStart )
3947             m_nStartBracketPosition = nPos;
3948         else
3949             m_nEndBracketPosition = nPos;
3950     }
3951     UpdatePreview_Impl();
3952     return 0;
3953 }
3954
3955 // -----------------------------------------------------------------------
3956
3957 void SvxCharTwoLinesPage::ActivatePage( const SfxItemSet& rSet )
3958 {
3959     SvxCharBasePage::ActivatePage( rSet );
3960 }
3961
3962 // -----------------------------------------------------------------------
3963
3964 int SvxCharTwoLinesPage::DeactivatePage( SfxItemSet* _pSet )
3965 {
3966     if ( _pSet )
3967         FillItemSet( *_pSet );
3968     return LEAVE_PAGE;
3969 }
3970
3971 // -----------------------------------------------------------------------
3972
3973 SfxTabPage* SvxCharTwoLinesPage::Create( Window* pParent, const SfxItemSet& rSet )
3974 {
3975     return new SvxCharTwoLinesPage( pParent, rSet );
3976 }
3977
3978 // -----------------------------------------------------------------------
3979
3980 USHORT* SvxCharTwoLinesPage::GetRanges()
3981 {
3982     return pTwoLinesRanges;
3983 }
3984
3985 // -----------------------------------------------------------------------
3986
3987 void SvxCharTwoLinesPage::Reset( const SfxItemSet& rSet )
3988 {
3989     m_aTwoLinesBtn.Check( FALSE );
3990     USHORT nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES );
3991     SfxItemState eState = rSet.GetItemState( nWhich );
3992
3993     if ( eState >= SFX_ITEM_DONTCARE )
3994     {
3995         const SvxTwoLinesItem& rItem = (SvxTwoLinesItem&)rSet.Get( nWhich );
3996         m_aTwoLinesBtn.Check( rItem.GetValue() );
3997
3998         if ( rItem.GetValue() )
3999         {
4000             SetBracket( rItem.GetStartBracket(), TRUE );
4001             SetBracket( rItem.GetEndBracket(), FALSE );
4002         }
4003     }
4004     TwoLinesHdl_Impl( NULL );
4005
4006     SetPrevFontWidthScale( rSet );
4007 }
4008
4009 // -----------------------------------------------------------------------
4010
4011 BOOL SvxCharTwoLinesPage::FillItemSet( SfxItemSet& rSet )
4012 {
4013     const SfxItemSet& rOldSet = GetItemSet();
4014     BOOL bModified = FALSE, bChanged = TRUE;
4015     USHORT nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES );
4016     const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_CHAR_TWO_LINES );
4017     sal_Bool bOn = m_aTwoLinesBtn.IsChecked();
4018     sal_Unicode cStart = ( bOn && m_aStartBracketLB.GetSelectEntryPos() > 0 )
4019         ? m_aStartBracketLB.GetSelectEntry().GetChar(0) : 0;
4020     sal_Unicode cEnd = ( bOn && m_aEndBracketLB.GetSelectEntryPos() > 0 )
4021         ? m_aEndBracketLB.GetSelectEntry().GetChar(0) : 0;
4022
4023     if ( pOld )
4024     {
4025         const SvxTwoLinesItem& rItem = *( (const SvxTwoLinesItem*)pOld );
4026         if ( rItem.GetValue() ==  bOn &&
4027              ( !bOn || ( rItem.GetStartBracket() == cStart && rItem.GetEndBracket() == cEnd ) ) )
4028             bChanged = FALSE;
4029     }
4030
4031     if ( bChanged )
4032     {
4033         rSet.Put( SvxTwoLinesItem( bOn, cStart, cEnd, nWhich ) );
4034         bModified |= TRUE;
4035     }
4036     else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
4037         CLEARTITEM;
4038
4039     return bModified;
4040 }
4041 /* -----------------------------04.12.00 09:48--------------------------------
4042
4043  ---------------------------------------------------------------------------*/
4044 void    SvxCharTwoLinesPage::UpdatePreview_Impl()
4045 {
4046     sal_Unicode cStart = m_aStartBracketLB.GetSelectEntryPos() > 0
4047         ? m_aStartBracketLB.GetSelectEntry().GetChar(0) : 0;
4048     sal_Unicode cEnd = m_aEndBracketLB.GetSelectEntryPos() > 0
4049         ? m_aEndBracketLB.GetSelectEntry().GetChar(0) : 0;
4050     m_aPreviewWin.SetBrackets(cStart, cEnd);
4051     m_aPreviewWin.SetTwoLines(m_aTwoLinesBtn.IsChecked());
4052     m_aPreviewWin.Invalidate();
4053 }
4054 // -----------------------------------------------------------------------
4055 void SvxCharTwoLinesPage::SetPreviewBackgroundToCharacter()
4056 {
4057     m_bPreviewBackgroundToCharacter = TRUE;
4058 }
4059
4060 // -----------------------------------------------------------------------
4061 void SvxCharTwoLinesPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
4062 {
4063     SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
4064     if (pFlagItem)
4065     {
4066         UINT32 nFlags=pFlagItem->GetValue();
4067         if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
4068             SetPreviewBackgroundToCharacter();
4069     }
4070 }