svx/source/cui/paragrph.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: paragrph.cxx,v $
  10  * $Revision: 1.54 $
  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 #include <svtools/style.hxx>
  38 #include <sfx2/app.hxx>
  39 #include <sfx2/objsh.hxx>
  40 #include <sfx2/module.hxx>
  41 #include <vcl/mnemonic.hxx>
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56 #define _SVX_PARAGRPH_CXX   0
  57
  58
  59
  60
  61 #include <svtools/languageoptions.hxx>
  62 #include <pgrditem.hxx>
  63 #include <svx/dialogs.hrc>
  64 #include "paragrph.hrc"
  65 #include "paragrph.hxx"
  66 #include <svx/frmdiritem.hxx>
  67
  68 #include <svx/lspcitem.hxx>
  69 #include <svx/adjitem.hxx>
  70 #include <svx/orphitem.hxx>
  71 #include <svx/widwitem.hxx>
  72 #include <svx/tstpitem.hxx>
  73 #include <svx/pmdlitem.hxx>
  74 #include <svx/spltitem.hxx>
  75 #include <svx/hyznitem.hxx>
  76 #include <svx/ulspitem.hxx>
  77 #include <svx/lrspitem.hxx>
  78 #include <svx/brkitem.hxx>
  79 #include <svx/keepitem.hxx>
  80 #include "dlgutil.hxx"
  81 #include <svx/dialmgr.hxx>
  82 #include "htmlmode.hxx"
  83 #include <svx/paravertalignitem.hxx>
  84 #include <svtools/eitem.hxx> //add CHINA001
  85 #include <sfx2/request.hxx> //add CHINA001
  86 #include <svtools/intitem.hxx> //add CHINA001
  87 #ifndef _SVTOOLS_CJKOPTIONS_HXX
  88 #include <svtools/cjkoptions.hxx>
  89 #endif
  90
  91 // static ----------------------------------------------------------------
  92
  93 static USHORT pStdRanges[] =
  94 {
  95     SID_ATTR_PARA_LINESPACE,            // 10033
  96     SID_ATTR_PARA_LINESPACE,
  97     SID_ATTR_LRSPACE,                           // 10048 -
  98     SID_ATTR_ULSPACE,                           // 10049
  99     SID_ATTR_PARA_REGISTER,                     // 10413
 100     SID_ATTR_PARA_REGISTER,
 101     0
 102 };
 103
 104 static USHORT pAlignRanges[] =
 105 {
 106     SID_ATTR_PARA_ADJUST,                       // 10027
 107     SID_ATTR_PARA_ADJUST,
 108     0
 109 };
 110
 111 static USHORT pExtRanges[] =
 112 {
 113     SID_ATTR_PARA_PAGEBREAK,            // 10037 -
 114     SID_ATTR_PARA_WIDOWS,                       // 10041
 115     SID_ATTR_PARA_MODEL,                        // 10065 -
 116     SID_ATTR_PARA_KEEP,                         // 10066
 117     0
 118 };
 119
 120 // define ----------------------------------------------------------------
 121
 122 #define MAX_DURCH 5670      // 10 cm ist sinnvoll als maximaler Durchschuss
 123                             // laut BP
 124 #define FIX_DIST_DEF 283    // Standard-Fix-Abstand 0,5cm
 125
 126 // enum ------------------------------------------------------------------
 127
 128 enum LineSpaceList
 129 {
 130     LLINESPACE_1    = 0,
 131     LLINESPACE_15   = 1,
 132     LLINESPACE_2    = 2,
 133     LLINESPACE_PROP = 3,
 134     LLINESPACE_MIN  = 4,
 135     LLINESPACE_DURCH= 5,
 136     LLINESPACE_FIX      = 6,
 137     LLINESPACE_END
 138 };
 139
 140 // C-Funktion ------------------------------------------------------------
 141
 142 void SetLineSpace_Impl( SvxLineSpacingItem&, int, long lValue = 0 );
 143
 144 void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace,
 145                         int eSpace, long lValue )
 146 {
 147     switch ( eSpace )
 148     {
 149         case LLINESPACE_1:
 150             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 151             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 152             break;
 153
 154         case LLINESPACE_15:
 155             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 156             rLineSpace.SetPropLineSpace( 150 );
 157             break;
 158
 159         case LLINESPACE_2:
 160             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 161             rLineSpace.SetPropLineSpace( 200 );
 162             break;
 163
 164         case LLINESPACE_PROP:
 165             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 166             rLineSpace.SetPropLineSpace( (BYTE)lValue );
 167             break;
 168
 169         case LLINESPACE_MIN:
 170             rLineSpace.SetLineHeight( (USHORT)lValue );
 171             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 172             break;
 173
 174         case LLINESPACE_DURCH:
 175             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 176             rLineSpace.SetInterLineSpace( (USHORT)lValue );
 177             break;
 178
 179         case LLINESPACE_FIX:
 180             rLineSpace.SetLineHeight((USHORT)lValue);
 181             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_FIX;
 182             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 183         break;
 184     }
 185 }
 186
 187
 188 USHORT GetHtmlMode_Impl(const SfxItemSet& rSet)
 189 {
 190     USHORT nHtmlMode = 0;
 191     const SfxPoolItem* pItem = 0;
 192     SfxObjectShell* pShell;
 193     if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, FALSE, &pItem) ||
 194         ( 0 != (pShell = SfxObjectShell::Current()) &&
 195                     0 != (pItem = pShell->GetItem(SID_HTML_MODE))))
 196     {
 197         nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
 198     }
 199     return nHtmlMode;
 200
 201 }
 202
 203 // class SvxStdParagraphTabPage ------------------------------------------
 204
 205 IMPL_LINK( SvxStdParagraphTabPage, ELRLoseFocusHdl, Edit *, EMPTYARG )
 206 {
 207 //! if ( aLeftIndent.IsRelativeMode() )
 208 //!     return 0; //!!!
 209
 210     SfxItemPool* pPool = GetItemSet().GetPool();
 211     DBG_ASSERT( pPool, "Wo ist der Pool" );
 212     FieldUnit eUnit =
 213         MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
 214
 215     sal_Int64 nL = aLeftIndent.Denormalize( aLeftIndent.GetValue( eUnit ) );
 216     sal_Int64 nR = aRightIndent.Denormalize( aRightIndent.GetValue( eUnit ) );
 217     String aTmp = aFLineIndent.GetText();
 218
 219     // Erstzeilen Einzug
 220     if( aLeftIndent.GetMin() < 0 )
 221         aFLineIndent.SetMin( -99999, FUNIT_MM );
 222     else
 223         aFLineIndent.SetMin( aFLineIndent.Normalize( -nL ), eUnit );
 224
 225     // Check nur fuer konkrete Breite (Shell)
 226     sal_Int64 nTmp = nWidth - nL - nR - MM50;
 227     aFLineIndent.SetMax( aFLineIndent.Normalize( nTmp ), eUnit );
 228
 229     if ( !aTmp.Len() )
 230         aFLineIndent.SetEmptyFieldValue();
 231     // Maximum Links Rechts
 232     aTmp = aLeftIndent.GetText();
 233     nTmp = nWidth - nR - MM50;
 234     aLeftIndent.SetMax( aLeftIndent.Normalize( nTmp ), eUnit );
 235
 236     if ( !aTmp.Len() )
 237         aLeftIndent.SetEmptyFieldValue();
 238     aTmp = aRightIndent.GetText();
 239     nTmp = nWidth - nL - MM50;
 240     aRightIndent.SetMax( aRightIndent.Normalize( nTmp ), eUnit );
 241
 242     if ( !aTmp.Len() )
 243         aRightIndent.SetEmptyFieldValue();
 244     return 0;
 245 }
 246
 247 // -----------------------------------------------------------------------
 248
 249 SfxTabPage* SvxStdParagraphTabPage::Create( Window* pParent,
 250                                             const SfxItemSet& rSet)
 251 {
 252     return new SvxStdParagraphTabPage( pParent, rSet );
 253 }
 254
 255 // -----------------------------------------------------------------------
 256
 257 BOOL SvxStdParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
 258 {
 259     SfxItemState eState = SFX_ITEM_UNKNOWN;
 260     const SfxPoolItem* pOld = 0;
 261     SfxItemPool* pPool = rOutSet.GetPool();
 262     DBG_ASSERT( pPool, "Wo ist der Pool" );
 263
 264     BOOL bModified = FALSE;
 265     USHORT nWhich;
 266     USHORT nPos = aLineDist.GetSelectEntryPos();
 267
 268     if ( LISTBOX_ENTRY_NOTFOUND != nPos &&
 269          ( nPos != aLineDist.GetSavedValue() ||
 270            aLineDistAtPercentBox.IsValueModified() ||
 271            aLineDistAtMetricBox.IsValueModified() ) )
 272     {
 273         nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
 274         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 275         SvxLineSpacingItem aSpacing(
 276             (const SvxLineSpacingItem&)GetItemSet().Get( nWhich ) );
 277
 278         switch ( nPos )
 279         {
 280             case LLINESPACE_1:
 281             case LLINESPACE_15:
 282             case LLINESPACE_2:
 283                 SetLineSpace_Impl( aSpacing, nPos );
 284                 break;
 285
 286             case LLINESPACE_PROP:
 287                 SetLineSpace_Impl( aSpacing, nPos,
 288                                    static_cast<long>(aLineDistAtPercentBox.Denormalize(
 289                                    aLineDistAtPercentBox.GetValue() )) );
 290                 break;
 291
 292             case LLINESPACE_MIN:
 293             case LLINESPACE_DURCH:
 294             case LLINESPACE_FIX:
 295                 SetLineSpace_Impl( aSpacing, nPos,
 296                     GetCoreValue( aLineDistAtMetricBox, eUnit ) );
 297             break;
 298
 299             default:
 300                 DBG_ERROR( "unbekannter Type fuer Zeilenabstand." );
 301                 break;
 302         }
 303         eState = GetItemSet().GetItemState( nWhich );
 304         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_LINESPACE );
 305
 306         if ( !pOld || !( *(const SvxLineSpacingItem*)pOld == aSpacing ) ||
 307              SFX_ITEM_DONTCARE == eState )
 308         {
 309             rOutSet.Put( aSpacing );
 310             bModified |= TRUE;
 311         }
 312     }
 313
 314     if ( aTopDist.IsValueModified() || aBottomDist.IsValueModified() )
 315     {
 316         nWhich = GetWhich( SID_ATTR_ULSPACE );
 317         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 318         pOld = GetOldItem( rOutSet, SID_ATTR_ULSPACE );
 319         SvxULSpaceItem aMargin( nWhich );
 320
 321         if ( bRelativeMode )
 322         {
 323             DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
 324
 325             const SvxULSpaceItem& rOldItem =
 326                 (const SvxULSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
 327
 328             if ( aTopDist.IsRelative() )
 329                 aMargin.SetUpper( rOldItem.GetUpper(),
 330                                   (USHORT)aTopDist.GetValue() );
 331             else
 332                 aMargin.SetUpper( (USHORT)GetCoreValue( aTopDist, eUnit ) );
 333
 334             if ( aBottomDist.IsRelative() )
 335                 aMargin.SetLower( rOldItem.GetLower(),
 336                                   (USHORT)aBottomDist.GetValue() );
 337             else
 338                 aMargin.SetLower( (USHORT)GetCoreValue( aBottomDist, eUnit ) );
 339
 340         }
 341         else
 342         {
 343             aMargin.SetUpper( (USHORT)GetCoreValue( aTopDist, eUnit ) );
 344             aMargin.SetLower( (USHORT)GetCoreValue( aBottomDist, eUnit ) );
 345         }
 346         eState = GetItemSet().GetItemState( nWhich );
 347
 348         if ( !pOld || !( *(const SvxULSpaceItem*)pOld == aMargin ) ||
 349              SFX_ITEM_DONTCARE == eState )
 350         {
 351             rOutSet.Put( aMargin );
 352             bModified |= TRUE;
 353         }
 354     }
 355     FASTBOOL bNullTab = FALSE;
 356
 357     if ( aLeftIndent.IsValueModified() ||
 358          aFLineIndent.IsValueModified() ||
 359          aRightIndent.IsValueModified()
 360          ||      aAutoCB.GetSavedValue() != aAutoCB.IsChecked() )
 361     {
 362         nWhich = GetWhich( SID_ATTR_LRSPACE );
 363         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 364         SvxLRSpaceItem aMargin( nWhich );
 365         pOld = GetOldItem( rOutSet, SID_ATTR_LRSPACE );
 366
 367         if ( bRelativeMode )
 368         {
 369             DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
 370
 371             const SvxLRSpaceItem& rOldItem =
 372                 (const SvxLRSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
 373
 374             if ( aLeftIndent.IsRelative() )
 375                 aMargin.SetTxtLeft( rOldItem.GetTxtLeft(),
 376                                     (USHORT)aLeftIndent.GetValue() );
 377             else
 378                 aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );
 379
 380             if ( aRightIndent.IsRelative() )
 381                 aMargin.SetRight( rOldItem.GetRight(),
 382                                   (USHORT)aRightIndent.GetValue() );
 383             else
 384                 aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );
 385
 386             if ( aFLineIndent.IsRelative() )
 387                 aMargin.SetTxtFirstLineOfst( rOldItem.GetTxtFirstLineOfst(),
 388                                              (USHORT)aFLineIndent.GetValue() );
 389             else
 390                 aMargin.SetTxtFirstLineOfst(
 391                     (USHORT)GetCoreValue( aFLineIndent, eUnit ) );
 392         }
 393         else
 394         {
 395             aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );
 396             aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );
 397             aMargin.SetTxtFirstLineOfst(
 398                 (USHORT)GetCoreValue( aFLineIndent, eUnit ) );
 399         }
 400         aMargin.SetAutoFirst(aAutoCB.IsChecked());
 401         if ( aMargin.GetTxtFirstLineOfst() < 0 )
 402             bNullTab = TRUE;
 403         eState = GetItemSet().GetItemState( nWhich );
 404
 405         if ( !pOld || !( *(const SvxLRSpaceItem*)pOld == aMargin ) ||
 406              SFX_ITEM_DONTCARE == eState )
 407         {
 408             rOutSet.Put( aMargin );
 409             bModified |= TRUE;
 410         }
 411     }
 412
 413     if ( bNullTab )
 414     {
 415         MapUnit eUnit = (MapUnit)pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) );
 416         if ( MAP_100TH_MM != eUnit )
 417         {
 418
 419             // negativer Erstzeileneinzug -> ggf. Null Default-Tabstop setzen
 420             USHORT _nWhich = GetWhich( SID_ATTR_TABSTOP );
 421             const SfxItemSet& rInSet = GetItemSet();
 422
 423             if ( rInSet.GetItemState( _nWhich ) >= SFX_ITEM_AVAILABLE )
 424             {
 425                 const SvxTabStopItem& rTabItem =
 426                     (const SvxTabStopItem&)rInSet.Get( _nWhich );
 427                 SvxTabStopItem aNullTab( rTabItem );
 428                 SvxTabStop aNull( 0, SVX_TAB_ADJUST_DEFAULT );
 429                 aNullTab.Insert( aNull );
 430                 rOutSet.Put( aNullTab );
 431             }
 432         }
 433     }
 434     if( aRegisterCB.IsVisible())
 435     {
 436         const SfxBoolItem* pBoolItem = (SfxBoolItem*)GetOldItem(
 437                             rOutSet, SID_ATTR_PARA_REGISTER);
 438         SfxBoolItem* pRegItem = (SfxBoolItem*)pBoolItem->Clone();
 439         USHORT _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
 440         BOOL bSet = pRegItem->GetValue();
 441
 442         if(aRegisterCB.IsChecked() != bSet )
 443         {
 444             pRegItem->SetValue(!bSet);
 445             rOutSet.Put(*pRegItem);
 446             bModified |= TRUE;
 447         }
 448         else if ( SFX_ITEM_DEFAULT == GetItemSet().GetItemState( _nWhich, FALSE ) )
 449             rOutSet.ClearItem(_nWhich);
 450         delete pRegItem;
 451     }
 452
 453     return bModified;
 454 }
 455
 456 // -----------------------------------------------------------------------
 457
 458 void SvxStdParagraphTabPage::Reset( const SfxItemSet& rSet )
 459 {
 460     SfxItemPool* pPool = rSet.GetPool();
 461     DBG_ASSERT( pPool, "Wo ist der Pool?" );
 462     String aEmpty;
 463
 464     // Metrik einstellen
 465     FieldUnit eFUnit = GetModuleFieldUnit( &rSet );
 466
 467         BOOL bApplyCharUnit = sal_False ;
 468         bApplyCharUnit = GetApplyCharUnit( &rSet );
 469
 470         SvtCJKOptions aCJKOptions;
 471         if(aCJKOptions.IsAsianTypographyEnabled() && bApplyCharUnit )
 472                 eFUnit = FUNIT_CHAR;
 473
 474     SetFieldUnit( aLeftIndent, eFUnit );
 475     SetFieldUnit( aRightIndent, eFUnit );
 476     SetFieldUnit( aFLineIndent, eFUnit );
 477         if ( eFUnit == FUNIT_CHAR )
 478         {
 479                 SetFieldUnit( aTopDist, FUNIT_LINE );
 480                 SetFieldUnit( aBottomDist, FUNIT_LINE );
 481                 SetFieldUnit( aLineDistAtMetricBox, FUNIT_POINT );
 482         }
 483         else
 484         {
 485                 SetFieldUnit( aTopDist, eFUnit );
 486                 SetFieldUnit( aBottomDist, eFUnit );
 487                 SetFieldUnit( aLineDistAtMetricBox, eFUnit );
 488         }
 489
 490     USHORT _nWhich = GetWhich( SID_ATTR_LRSPACE );
 491     SfxItemState eItemState = rSet.GetItemState( _nWhich );
 492
 493     if ( eItemState >= SFX_ITEM_AVAILABLE )
 494     {
 495         SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
 496
 497         if ( bRelativeMode )
 498         {
 499             const SvxLRSpaceItem& rOldItem =
 500                 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
 501
 502             if ( rOldItem.GetPropLeft() != 100 )
 503             {
 504                 aLeftIndent.SetRelative( TRUE );
 505                 aLeftIndent.SetValue( rOldItem.GetPropLeft() );
 506             }
 507             else
 508             {
 509                 aLeftIndent.SetRelative();
 510                 SetFieldUnit( aLeftIndent, eFUnit );
 511                 SetMetricValue( aLeftIndent, rOldItem.GetTxtLeft(), eUnit );
 512             }
 513
 514             if ( rOldItem.GetPropRight() != 100 )
 515             {
 516                 aRightIndent.SetRelative( TRUE );
 517                 aRightIndent.SetValue( rOldItem.GetPropRight() );
 518             }
 519             else
 520             {
 521                 aRightIndent.SetRelative();
 522                 SetFieldUnit( aRightIndent, eFUnit );
 523                 SetMetricValue( aRightIndent, rOldItem.GetRight(), eUnit );
 524             }
 525
 526             if ( rOldItem.GetPropTxtFirstLineOfst() != 100 )
 527             {
 528                 aFLineIndent.SetRelative( TRUE );
 529                 aFLineIndent.SetValue( rOldItem.GetPropTxtFirstLineOfst() );
 530             }
 531             else
 532             {
 533                 aFLineIndent.SetRelative();
 534                 aFLineIndent.SetMin(-9999);
 535                 SetFieldUnit( aFLineIndent, eFUnit );
 536                 SetMetricValue( aFLineIndent, rOldItem.GetTxtFirstLineOfst(),
 537                                 eUnit );
 538             }
 539             aAutoCB.Check(rOldItem.IsAutoFirst());
 540         }
 541         else
 542         {
 543             const SvxLRSpaceItem& rSpace =
 544                 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
 545
 546             SetMetricValue( aLeftIndent, rSpace.GetTxtLeft(), eUnit );
 547             SetMetricValue( aRightIndent, rSpace.GetRight(), eUnit );
 548             SetMetricValue( aFLineIndent, rSpace.GetTxtFirstLineOfst(), eUnit );
 549             aAutoCB.Check(rSpace.IsAutoFirst());
 550         }
 551         AutoHdl_Impl(&aAutoCB);
 552     }
 553     else
 554     {
 555         aLeftIndent.SetEmptyFieldValue();
 556         aRightIndent.SetEmptyFieldValue();
 557         aFLineIndent.SetEmptyFieldValue();
 558     }
 559
 560     _nWhich = GetWhich( SID_ATTR_ULSPACE );
 561     eItemState = rSet.GetItemState( _nWhich );
 562
 563     if ( eItemState >= SFX_ITEM_AVAILABLE )
 564     {
 565         SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
 566
 567         if ( bRelativeMode )
 568         {
 569             const SvxULSpaceItem& rOldItem =
 570                 (const SvxULSpaceItem&)rSet.Get( _nWhich );
 571
 572             if ( rOldItem.GetPropUpper() != 100 )
 573             {
 574                 aTopDist.SetRelative( TRUE );
 575                 aTopDist.SetValue( rOldItem.GetPropUpper() );
 576             }
 577             else
 578             {
 579                 aTopDist.SetRelative();
 580                                 if ( eFUnit == FUNIT_CHAR )
 581                                         SetFieldUnit( aTopDist, FUNIT_LINE );
 582                                 else
 583                                         SetFieldUnit( aTopDist, eFUnit );
 584                 SetMetricValue( aTopDist, rOldItem.GetUpper(), eUnit );
 585             }
 586
 587             if ( rOldItem.GetPropLower() != 100 )
 588             {
 589                 aBottomDist.SetRelative( TRUE );
 590                 aBottomDist.SetValue( rOldItem.GetPropLower() );
 591             }
 592             else
 593             {
 594                 aBottomDist.SetRelative();
 595                                 if ( eFUnit == FUNIT_CHAR )
 596                                         SetFieldUnit( aBottomDist, FUNIT_LINE );
 597                                 else
 598                                         SetFieldUnit( aBottomDist, eFUnit );
 599                 SetMetricValue( aBottomDist, rOldItem.GetLower(), eUnit );
 600             }
 601         }
 602         else
 603         {
 604             const SvxULSpaceItem& rTopMargin =
 605                 (const SvxULSpaceItem&)rSet.Get( _nWhich );
 606             SetMetricValue( aTopDist, rTopMargin.GetUpper(), eUnit );
 607             SetMetricValue( aBottomDist, rTopMargin.GetLower(), eUnit );
 608         }
 609     }
 610     else
 611     {
 612         aTopDist.SetEmptyFieldValue();
 613         aBottomDist.SetEmptyFieldValue();
 614     }
 615
 616     _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
 617     eItemState = rSet.GetItemState( _nWhich );
 618
 619     if ( eItemState >= SFX_ITEM_AVAILABLE )
 620         SetLineSpacing_Impl( (const SvxLineSpacingItem &)rSet.Get( _nWhich ) );
 621     else
 622         aLineDist.SetNoSelection();
 623
 624
 625     _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
 626     eItemState = rSet.GetItemState( _nWhich );
 627
 628     if ( eItemState >= SFX_ITEM_AVAILABLE )
 629         aRegisterCB.Check( ((const SfxBoolItem &)rSet.Get( _nWhich )).GetValue());
 630     aRegisterCB.SaveValue();
 631     USHORT nHtmlMode = GetHtmlMode_Impl(rSet);
 632     if(nHtmlMode & HTMLMODE_ON)
 633     {
 634         aRegisterCB.Hide();
 635         aRegisterFL.Hide();
 636         aAutoCB.Hide();
 637         if(!(nHtmlMode & HTMLMODE_SOME_STYLES)) // IE oder SW
 638         {
 639             aRightLabel.Disable();
 640             aRightIndent.Disable();
 641             aTopDist.Disable();  //HTML3.2 und NS 3.0
 642             aBottomDist.Disable();
 643             if(!(nHtmlMode & HTMLMODE_FIRSTLINE)) //NS 3.0
 644             {
 645                 aFLineIndent.Disable();
 646                 aFLineLabel.Disable();
 647             }
 648         }
 649     }
 650
 651     ELRLoseFocusHdl( NULL );
 652     aAutoCB.SaveValue();
 653     aLineDist.SaveValue();
 654 }
 655
 656 // -----------------------------------------------------------------------
 657
 658 void SvxStdParagraphTabPage::EnableRelativeMode()
 659 {
 660     DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" );
 661
 662     aLeftIndent.EnableRelativeMode( 0, 999 );
 663     aFLineIndent.EnableRelativeMode( 0, 999 );
 664     aRightIndent.EnableRelativeMode( 0, 999 );
 665     aTopDist.EnableRelativeMode( 0, 999 );
 666     aBottomDist.EnableRelativeMode( 0, 999 );
 667     bRelativeMode = TRUE;
 668 }
 669
 670 // -----------------------------------------------------------------------
 671
 672 int SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
 673 {
 674     ELRLoseFocusHdl( NULL );
 675
 676     if ( _pSet )
 677         FillItemSet( *_pSet );
 678     return LEAVE_PAGE;
 679 }
 680
 681 // -----------------------------------------------------------------------
 682
 683 SvxStdParagraphTabPage::SvxStdParagraphTabPage( Window* pParent,
 684                                                 const SfxItemSet& rAttr ) :
 685
 686     SfxTabPage( pParent, SVX_RES( RID_SVXPAGE_STD_PARAGRAPH ), rAttr ),
 687
 688     aLeftLabel              ( this, SVX_RES( FT_LEFTINDENT ) ),
 689     aLeftIndent             ( this, SVX_RES( ED_LEFTINDENT ) ),
 690     aRightLabel             ( this, SVX_RES( FT_RIGHTINDENT ) ),
 691     aRightIndent            ( this, SVX_RES( ED_RIGHTINDENT ) ),
 692
 693     aFLineLabel             ( this, SVX_RES( FT_FLINEINDENT ) ),
 694     aFLineIndent            ( this, SVX_RES( ED_FLINEINDENT ) ),
 695     aAutoCB                 ( this, SVX_RES( CB_AUTO ) ),
 696     aIndentFrm              ( this, SVX_RES( FL_INDENT ) ),
 697     aTopLabel               ( this, SVX_RES( FT_TOPDIST ) ),
 698     aTopDist                ( this, SVX_RES( ED_TOPDIST ) ),
 699     aBottomLabel            ( this, SVX_RES( FT_BOTTOMDIST ) ),
 700     aBottomDist             ( this, SVX_RES( ED_BOTTOMDIST ) ),
 701     aDistFrm                ( this, SVX_RES( FL_DIST ) ),
 702     aLineDist               ( this, SVX_RES( LB_LINEDIST ) ),
 703     aLineDistAtLabel        ( this, SVX_RES( FT_LINEDIST ) ),
 704     aLineDistAtPercentBox   ( this, SVX_RES( ED_LINEDISTPERCENT ) ),
 705     aLineDistAtMetricBox    ( this, SVX_RES( ED_LINEDISTMETRIC ) ),
 706     aLineDistFrm            ( this, SVX_RES( FL_LINEDIST ) ),
 707     sAbsDist                ( SVX_RES(ST_LINEDIST_ABS) ),
 708     aExampleWin             ( this, SVX_RES( WN_EXAMPLE ) ),
 709     aRegisterCB             ( this, SVX_RES( CB_REGISTER ) ),
 710     aRegisterFL             ( this, SVX_RES( FL_REGISTER ) ),
 711     pActLineDistFld ( &aLineDistAtPercentBox ),
 712     nAbst           ( MAX_DURCH ),
 713     nWidth          ( 11905 /*567 * 50*/ ),
 714     nMinFixDist(0L),
 715
 716     bRelativeMode   ( FALSE ),
 717     bNegativeIndents(FALSE)
 718
 719 {
 720     // diese Page braucht ExchangeSupport
 721     SetExchangeSupport();
 722
 723     aLineDistAtMetricBox.Hide();
 724     FreeResource();
 725     Init_Impl();
 726     aFLineIndent.SetMin(-9999);    // wird default auf 0 gesetzt
 727 }
 728
 729
 730 // -----------------------------------------------------------------------
 731
 732 void SvxStdParagraphTabPage::EnableNegativeMode()
 733 {
 734     aLeftIndent.SetMin(-9999);
 735     aRightIndent.SetMin(-9999);
 736     aRightIndent.EnableNegativeMode();
 737     aLeftIndent.EnableNegativeMode();
 738     bNegativeIndents = TRUE;
 739 }
 740
 741 // -----------------------------------------------------------------------
 742
 743 USHORT* SvxStdParagraphTabPage::GetRanges()
 744 {
 745     return pStdRanges;
 746 }
 747
 748 // -----------------------------------------------------------------------
 749
 750 void SvxStdParagraphTabPage::SetLineSpacing_Impl
 751 (
 752     const SvxLineSpacingItem &rAttr
 753 )
 754 {
 755     SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );
 756
 757     switch( rAttr.GetLineSpaceRule() )
 758     {
 759         case SVX_LINE_SPACE_AUTO:
 760         {
 761             SvxInterLineSpace eInter = rAttr.GetInterLineSpaceRule();
 762
 763             switch( eInter )
 764             {
 765                 // Default einzeilig
 766                 case SVX_INTER_LINE_SPACE_OFF:
 767                     aLineDist.SelectEntryPos( LLINESPACE_1 );
 768                     break;
 769
 770                 // Default einzeilig
 771                 case SVX_INTER_LINE_SPACE_PROP:
 772                     if ( 100 == rAttr.GetPropLineSpace() )
 773                     {
 774                         aLineDist.SelectEntryPos( LLINESPACE_1 );
 775                         break;
 776                     }
 777                     // 1.5zeilig
 778                     if ( 150 == rAttr.GetPropLineSpace() )
 779                     {
 780                         aLineDist.SelectEntryPos( LLINESPACE_15 );
 781                         break;
 782                     }
 783                     // 2zeilig
 784                     if ( 200 == rAttr.GetPropLineSpace() )
 785                     {
 786                         aLineDist.SelectEntryPos( LLINESPACE_2 );
 787                         break;
 788                     }
 789                     // eingestellter Prozentwert
 790                     aLineDistAtPercentBox.
 791                         SetValue( aLineDistAtPercentBox.Normalize(
 792                                         rAttr.GetPropLineSpace() ) );
 793                     aLineDist.SelectEntryPos( LLINESPACE_PROP );
 794                     break;
 795
 796                 case SVX_INTER_LINE_SPACE_FIX:
 797                     SetMetricValue( aLineDistAtMetricBox,
 798                                     rAttr.GetInterLineSpace(), eUnit );
 799                     aLineDist.SelectEntryPos( LLINESPACE_DURCH );
 800                     break;
 801                 default: ;//prevent warning
 802             }
 803         }
 804         break;
 805         case SVX_LINE_SPACE_FIX:
 806             SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
 807             aLineDist.SelectEntryPos( LLINESPACE_FIX );
 808         break;
 809
 810         case SVX_LINE_SPACE_MIN:
 811             SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
 812             aLineDist.SelectEntryPos( LLINESPACE_MIN );
 813             break;
 814         default: ;//prevent warning
 815     }
 816     LineDistHdl_Impl( &aLineDist );
 817 }
 818
 819 // -----------------------------------------------------------------------
 820
 821 IMPL_LINK( SvxStdParagraphTabPage, LineDistHdl_Impl, ListBox *, pBox )
 822 {
 823     switch( pBox->GetSelectEntryPos() )
 824     {
 825         case LLINESPACE_1:
 826         case LLINESPACE_15:
 827         case LLINESPACE_2:
 828             aLineDistAtLabel.Enable(FALSE);
 829             pActLineDistFld->Enable(FALSE);
 830             pActLineDistFld->SetText( String() );
 831             break;
 832
 833         case LLINESPACE_DURCH:
 834             // Setzen eines sinnvollen Defaults?
 835             // MS Begrenzen min(10, aPageSize)
 836             aLineDistAtPercentBox.Hide();
 837             pActLineDistFld = &aLineDistAtMetricBox;
 838             aLineDistAtMetricBox.SetMin(0);
 839
 840
 841             if ( !aLineDistAtMetricBox.GetText().Len() )
 842                 aLineDistAtMetricBox.SetValue(
 843                     aLineDistAtMetricBox.Normalize( 1 ) );
 844             aLineDistAtPercentBox.Hide();
 845             pActLineDistFld->Show();
 846             pActLineDistFld->Enable();
 847             aLineDistAtLabel.Enable();
 848             break;
 849
 850         case LLINESPACE_MIN:
 851             aLineDistAtPercentBox.Hide();
 852             pActLineDistFld = &aLineDistAtMetricBox;
 853             aLineDistAtMetricBox.SetMin(0);
 854
 855             if ( !aLineDistAtMetricBox.GetText().Len() )
 856                 aLineDistAtMetricBox.SetValue(
 857                     aLineDistAtMetricBox.Normalize( 10 ), FUNIT_TWIP );
 858             aLineDistAtPercentBox.Hide();
 859             pActLineDistFld->Show();
 860             pActLineDistFld->Enable();
 861             aLineDistAtLabel.Enable();
 862             break;
 863
 864         case LLINESPACE_PROP:
 865             aLineDistAtMetricBox.Hide();
 866             pActLineDistFld = &aLineDistAtPercentBox;
 867
 868             if ( !aLineDistAtPercentBox.GetText().Len() )
 869                 aLineDistAtPercentBox.SetValue(
 870                     aLineDistAtPercentBox.Normalize( 100 ), FUNIT_TWIP );
 871             aLineDistAtMetricBox.Hide();
 872             pActLineDistFld->Show();
 873             pActLineDistFld->Enable();
 874             aLineDistAtLabel.Enable();
 875             break;
 876         case LLINESPACE_FIX:
 877         {
 878             aLineDistAtPercentBox.Hide();
 879             pActLineDistFld = &aLineDistAtMetricBox;
 880             sal_Int64 nTemp = aLineDistAtMetricBox.GetValue();
 881             aLineDistAtMetricBox.SetMin(aLineDistAtMetricBox.Normalize(nMinFixDist), FUNIT_TWIP);
 882
 883             // wurde der Wert beim SetMin veraendert, dann ist es Zeit
 884             // fuer den default
 885             if ( aLineDistAtMetricBox.GetValue() != nTemp )
 886                 SetMetricValue( aLineDistAtMetricBox,
 887                                     FIX_DIST_DEF, SFX_MAPUNIT_TWIP ); // fix gibt's nur im Writer
 888             aLineDistAtPercentBox.Hide();
 889             pActLineDistFld->Show();
 890             pActLineDistFld->Enable();
 891             aLineDistAtLabel.Enable();
 892         }
 893         break;
 894     }
 895     UpdateExample_Impl( TRUE );
 896     return 0;
 897 }
 898
 899 // -----------------------------------------------------------------------
 900
 901 IMPL_LINK_INLINE_START( SvxStdParagraphTabPage, ModifyHdl_Impl, SvxRelativeField *, EMPTYARG )
 902 {
 903     UpdateExample_Impl();
 904     return 0;
 905 }
 906 IMPL_LINK_INLINE_END( SvxStdParagraphTabPage, ModifyHdl_Impl, SvxRelativeField *, EMPTYARG )
 907
 908 // -----------------------------------------------------------------------
 909
 910 void SvxStdParagraphTabPage::Init_Impl()
 911 {
 912     aLineDist.SetSelectHdl(
 913         LINK( this, SvxStdParagraphTabPage, LineDistHdl_Impl ) );
 914
 915     Link aLink = LINK( this, SvxStdParagraphTabPage, ELRLoseFocusHdl );
 916     aFLineIndent.SetLoseFocusHdl( aLink );
 917     aLeftIndent.SetLoseFocusHdl( aLink );
 918     aRightIndent.SetLoseFocusHdl( aLink );
 919
 920     aLink = LINK( this, SvxStdParagraphTabPage, ModifyHdl_Impl );
 921     aFLineIndent.SetModifyHdl( aLink );
 922     aLeftIndent.SetModifyHdl( aLink );
 923     aRightIndent.SetModifyHdl( aLink );
 924     aTopDist.SetModifyHdl( aLink );
 925     aBottomDist.SetModifyHdl( aLink );
 926
 927     aAutoCB.SetClickHdl( LINK( this, SvxStdParagraphTabPage, AutoHdl_Impl ));
 928     SfxItemPool* pPool = GetItemSet().GetPool();
 929     DBG_ASSERT( pPool, "Wo ist der Pool" );
 930     FieldUnit eUnit =
 931         MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
 932
 933     aTopDist.SetMax( aTopDist.Normalize( nAbst ), eUnit );
 934     aBottomDist.SetMax( aBottomDist.Normalize( nAbst ), eUnit );
 935     aLineDistAtMetricBox.SetMax(
 936         aLineDistAtMetricBox.Normalize( nAbst ), eUnit );
 937 }
 938
 939 // -----------------------------------------------------------------------
 940
 941 void SvxStdParagraphTabPage::UpdateExample_Impl( BOOL bAll )
 942 {
 943     aExampleWin.SetFirstLineOfst(
 944         (short)aFLineIndent.Denormalize( aFLineIndent.GetValue( FUNIT_TWIP ) ) );
 945     aExampleWin.SetLeftMargin(
 946         static_cast<long>(aLeftIndent.Denormalize( aLeftIndent.GetValue( FUNIT_TWIP ) ) ) );
 947     aExampleWin.SetRightMargin(
 948         static_cast<long>(aRightIndent.Denormalize( aRightIndent.GetValue( FUNIT_TWIP ) ) ) );
 949     aExampleWin.SetUpper(
 950         (USHORT)aTopDist.Denormalize( aTopDist.GetValue( FUNIT_TWIP ) ) );
 951     aExampleWin.SetLower(
 952         (USHORT)aBottomDist.Denormalize( aBottomDist.GetValue( FUNIT_TWIP ) ) );
 953
 954
 955
 956     USHORT nPos = aLineDist.GetSelectEntryPos();
 957
 958     switch ( nPos )
 959     {
 960         case LLINESPACE_1:
 961         case LLINESPACE_15:
 962         case LLINESPACE_2:
 963             aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos );
 964             break;
 965
 966         case LLINESPACE_PROP:
 967             aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
 968                 (USHORT)aLineDistAtPercentBox.Denormalize(
 969                 aLineDistAtPercentBox.GetValue() ) );
 970             break;
 971
 972         case LLINESPACE_MIN:
 973         case LLINESPACE_DURCH:
 974         case LLINESPACE_FIX:
 975             aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
 976                 (USHORT)GetCoreValue( aLineDistAtMetricBox, SFX_MAPUNIT_TWIP ) );
 977             break;
 978     }
 979     aExampleWin.Draw( bAll );
 980 }
 981
 982 // -----------------------------------------------------------------------
 983
 984 void SvxStdParagraphTabPage::EnableRegisterMode()
 985 {
 986     aRegisterCB.Show();
 987     aRegisterFL.Show();
 988 }
 989
 990 /*-----------------16.01.97 19.54-------------------
 991
 992 --------------------------------------------------*/
 993 IMPL_LINK( SvxStdParagraphTabPage, AutoHdl_Impl, CheckBox*, pBox )
 994 {
 995     BOOL bEnable = !pBox->IsChecked();
 996     aFLineLabel .Enable(bEnable);
 997     aFLineIndent.Enable(bEnable);
 998     return 0;
 999 }
1000
1001 /*-----------------16.01.97 18.00-------------------
1002
1003 --------------------------------------------------*/
1004 void SvxStdParagraphTabPage::SetPageWidth( USHORT nPageWidth )
1005 {
1006     nWidth = nPageWidth;
1007 }
1008 /*-----------------16.01.97 18.01-------------------
1009
1010 --------------------------------------------------*/
1011 void SvxStdParagraphTabPage::SetMaxDistance( USHORT nMaxDist )
1012 {
1013     nAbst = nMaxDist;
1014 }
1015
1016 /*-----------------17.01.97 08.11-------------------
1017
1018 --------------------------------------------------*/
1019 void SvxStdParagraphTabPage::EnableAutoFirstLine()
1020 {
1021     aAutoCB.Show();
1022 }
1023
1024 /*-----------------11.06.97 11.48-------------------
1025     absoluter Zeilenabstand
1026 --------------------------------------------------*/
1027 void    SvxStdParagraphTabPage::EnableAbsLineDist(long nMinTwip)
1028 {
1029     aLineDist.InsertEntry(sAbsDist);
1030     nMinFixDist = nMinTwip;
1031 }
1032
1033 //addd CHINA001 begin
1034 void    SvxStdParagraphTabPage::PageCreated(SfxAllItemSet aSet)
1035 {
1036
1037 /* CHINA001 different bit represent call to different method of SvxStdParagraphTabPage
1038                         0x0001 --->EnableRelativeMode()
1039                         0x0002 --->EnableRegisterMode()
1040                         0x0004 --->EnableAutoFirstLine()
1041                         0x0008 --->EnableNegativeMode()
1042
1043
1044             */
1045     SFX_ITEMSET_ARG     (&aSet,pPageWidthItem,SfxUInt16Item,SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH,sal_False);
1046     SFX_ITEMSET_ARG     (&aSet,pFlagSetItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET,sal_False);
1047     SFX_ITEMSET_ARG     (&aSet,pLineDistItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST,sal_False);
1048
1049     if (pPageWidthItem)
1050         SetPageWidth(pPageWidthItem->GetValue());
1051
1052     if (pFlagSetItem )
1053         if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
1054             EnableRelativeMode();
1055
1056     if (pFlagSetItem)
1057         if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
1058                 EnableRegisterMode();
1059
1060     if (pFlagSetItem)
1061         if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
1062             EnableAutoFirstLine();
1063
1064     if(pLineDistItem)
1065         EnableAbsLineDist(pLineDistItem->GetValue());
1066
1067     if (pFlagSetItem)
1068         if      (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
1069                 EnableNegativeMode();
1070
1071 }
1072 //end of CHINA001
1073
1074 #define LASTLINEPOS_DEFAULT             0
1075 #define LASTLINEPOS_LEFT                1
1076
1077 #define LASTLINECOUNT_OLD               3
1078 #define LASTLINECOUNT_NEW               4
1079
1080 // class SvxParaAlignTabPage ------------------------------------------------
1081
1082 /*-----------------16.01.97 19.34-------------------
1083
1084 --------------------------------------------------*/
1085 SvxParaAlignTabPage::SvxParaAlignTabPage( Window* pParent, const SfxItemSet& rSet )
1086     : SfxTabPage(pParent, SVX_RES( RID_SVXPAGE_ALIGN_PARAGRAPH ),rSet),
1087     aAlignFrm           ( this, SVX_RES( FL_ALIGN ) ),
1088     aLeft               ( this, SVX_RES( BTN_LEFTALIGN ) ),
1089     aRight                              ( this, SVX_RES( BTN_RIGHTALIGN ) ),
1090     aCenter                             ( this, SVX_RES( BTN_CENTERALIGN ) ),
1091     aJustify                    ( this, SVX_RES( BTN_JUSTIFYALIGN ) ),
1092     aLastLineFT         ( this, SVX_RES( FT_LASTLINE ) ),
1093     aLastLineLB                 ( this, SVX_RES( LB_LASTLINE ) ),
1094     aExpandCB                   ( this, SVX_RES( CB_EXPAND ) ),
1095     aSnapToGridCB               ( this, SVX_RES( CB_SNAP ) ),
1096     aExampleWin                 ( this, SVX_RES( WN_EXAMPLE ) ),
1097
1098     aVertAlignFL                ( this, SVX_RES( FL_VERTALIGN ) ),
1099     aVertAlignFT                ( this, SVX_RES( FT_VERTALIGN ) ),
1100     aVertAlignLB                ( this, SVX_RES( LB_VERTALIGN ) ),
1101
1102     aPropertiesFL               ( this, SVX_RES( FL_PROPERTIES    )),
1103     aTextDirectionFT    ( this, SVX_RES( FT_TEXTDIRECTION )),
1104     aTextDirectionLB    ( this, SVX_RES( LB_TEXTDIRECTION ))
1105 {
1106     SvtLanguageOptions aLangOptions;
1107     USHORT nLastLinePos = LASTLINEPOS_DEFAULT;
1108
1109     if ( aLangOptions.IsAsianTypographyEnabled() )
1110     {
1111         String sLeft(SVX_RES(ST_LEFTALIGN_ASIAN));
1112         aLeft.SetText(sLeft);
1113         aRight.SetText(String(SVX_RES(ST_RIGHTALIGN_ASIAN)));
1114         sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );
1115
1116         if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_OLD )
1117         {
1118             aLastLineLB.RemoveEntry( 0 );
1119             aLastLineLB.InsertEntry( sLeft, 0 );
1120         }
1121         else
1122             nLastLinePos = LASTLINEPOS_LEFT;
1123     }
1124     // remove "Default" or "Left" entry, depends on CJKOptions
1125     if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_NEW )
1126         aLastLineLB.RemoveEntry( nLastLinePos );
1127
1128     FreeResource();
1129     Link aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
1130     aLeft.SetClickHdl( aLink );
1131     aRight.SetClickHdl( aLink );
1132     aCenter.SetClickHdl( aLink );
1133     aJustify.SetClickHdl( aLink );
1134     aLastLineLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, LastLineHdl_Impl ) );
1135     aTextDirectionLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, TextDirectionHdl_Impl ) );
1136
1137     USHORT nHtmlMode = GetHtmlMode_Impl(rSet);
1138     if(!(nHtmlMode & HTMLMODE_ON) || (0 != (nHtmlMode & HTMLMODE_SOME_STYLES)) )
1139     {
1140         if( aLangOptions.IsCTLFontEnabled() )
1141         {
1142             aTextDirectionLB.InsertEntryValue( SVX_RESSTR( RID_SVXSTR_FRAMEDIR_LTR ), FRMDIR_HORI_LEFT_TOP );
1143             aTextDirectionLB.InsertEntryValue( SVX_RESSTR( RID_SVXSTR_FRAMEDIR_RTL ), FRMDIR_HORI_RIGHT_TOP );
1144             aTextDirectionLB.InsertEntryValue( SVX_RESSTR( RID_SVXSTR_FRAMEDIR_SUPER ), FRMDIR_ENVIRONMENT );
1145
1146             aPropertiesFL.Show();
1147             aTextDirectionFT.Show();
1148             aTextDirectionLB.Show();
1149         }
1150     }
1151 }
1152
1153 /*-----------------16.01.97 19.33-------------------
1154
1155 --------------------------------------------------*/
1156 SvxParaAlignTabPage::~SvxParaAlignTabPage()
1157 {
1158 }
1159
1160 /*-----------------16.01.97 19.33-------------------
1161
1162 --------------------------------------------------*/
1163 int SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
1164 {
1165     if ( _pSet )
1166         FillItemSet( *_pSet );
1167     return LEAVE_PAGE;
1168 }
1169
1170 /*-----------------16.01.97 19.33-------------------
1171
1172 --------------------------------------------------*/
1173 SfxTabPage*     SvxParaAlignTabPage::Create( Window* pParent, const SfxItemSet& rSet )
1174 {
1175     return new SvxParaAlignTabPage(pParent, rSet);
1176 }
1177
1178 /*-----------------16.01.97 19.33-------------------
1179
1180 --------------------------------------------------*/
1181 USHORT* SvxParaAlignTabPage::GetRanges()
1182 {
1183     return pAlignRanges;
1184
1185 }
1186
1187 /*-----------------16.01.97 19.33-------------------
1188
1189 --------------------------------------------------*/
1190 BOOL SvxParaAlignTabPage::FillItemSet( SfxItemSet& rOutSet )
1191 {
1192     BOOL bModified = FALSE;
1193
1194     FASTBOOL bAdj = FALSE, bChecked = FALSE;
1195     SvxAdjust eAdjust = SVX_ADJUST_LEFT;
1196
1197     if ( aLeft.IsChecked() )
1198     {
1199         eAdjust = SVX_ADJUST_LEFT;
1200         bAdj = !aLeft.GetSavedValue();
1201         bChecked = TRUE;
1202     }
1203     else if ( aRight.IsChecked() )
1204     {
1205         eAdjust = SVX_ADJUST_RIGHT;
1206         bAdj = !aRight.GetSavedValue();
1207         bChecked = TRUE;
1208     }
1209     else if ( aCenter.IsChecked() )
1210     {
1211         eAdjust = SVX_ADJUST_CENTER;
1212         bAdj = !aCenter.GetSavedValue();
1213         bChecked = TRUE;
1214     }
1215     else if ( aJustify.IsChecked() )
1216     {
1217         eAdjust = SVX_ADJUST_BLOCK;
1218         bAdj = !aJustify.GetSavedValue() ||
1219             aExpandCB.IsChecked() != aExpandCB.GetSavedValue() ||
1220             aLastLineLB.GetSelectEntryPos() != aLastLineLB.GetSavedValue();
1221         bChecked = TRUE;
1222     }
1223     USHORT _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1224
1225     if ( bAdj )
1226     {
1227         const SvxAdjustItem* pOld =
1228             (const SvxAdjustItem*)GetOldItem( rOutSet, SID_ATTR_PARA_ADJUST );
1229         SvxAdjust eOneWord = aExpandCB.IsChecked() ? SVX_ADJUST_BLOCK
1230                                                    : SVX_ADJUST_LEFT;
1231         USHORT nLBPos = aLastLineLB.GetSelectEntryPos();
1232         SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1233
1234         if ( 1 == nLBPos )
1235             eLastBlock = SVX_ADJUST_CENTER;
1236         else if ( 2 == nLBPos )
1237             eLastBlock = SVX_ADJUST_BLOCK;
1238
1239         FASTBOOL bNothingWasChecked =
1240             !aLeft.GetSavedValue() && !aRight.GetSavedValue() &&
1241             !aCenter.GetSavedValue() && !aJustify.GetSavedValue();
1242
1243         if ( !pOld || pOld->GetAdjust() != eAdjust ||
1244              pOld->GetOneWord() != eOneWord ||
1245              pOld->GetLastBlock() != eLastBlock ||
1246              ( bChecked && bNothingWasChecked ) )
1247         {
1248             bModified |= TRUE;
1249             SvxAdjustItem aAdj(
1250                 (const SvxAdjustItem&)GetItemSet().Get( _nWhich ) );
1251             aAdj.SetAdjust( eAdjust );
1252             aAdj.SetOneWord( eOneWord );
1253             aAdj.SetLastBlock( eLastBlock );
1254             rOutSet.Put( aAdj );
1255         }
1256     }
1257     if(aSnapToGridCB.IsChecked() != aSnapToGridCB.GetSavedValue())
1258     {
1259         rOutSet.Put(SvxParaGridItem(aSnapToGridCB.IsChecked(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
1260         bModified = TRUE;
1261     }
1262     if(aVertAlignLB.GetSavedValue() != aVertAlignLB.GetSelectEntryPos())
1263     {
1264         rOutSet.Put(SvxParaVertAlignItem(aVertAlignLB.GetSelectEntryPos(), GetWhich( SID_PARA_VERTALIGN )));
1265         bModified = TRUE;
1266     }
1267
1268     if( aTextDirectionLB.IsVisible() )
1269     {
1270         SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
1271         if( eDir != aTextDirectionLB.GetSavedValue() )
1272         {
1273             rOutSet.Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
1274             bModified = TRUE;
1275         }
1276     }
1277
1278     return bModified;
1279 }
1280
1281 /*-----------------16.01.97 19.33-------------------
1282
1283 --------------------------------------------------*/
1284 void SvxParaAlignTabPage::Reset( const SfxItemSet& rSet )
1285 {
1286     USHORT _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1287     SfxItemState eItemState = rSet.GetItemState( _nWhich );
1288
1289     USHORT nLBSelect = 0;
1290     if ( eItemState >= SFX_ITEM_AVAILABLE )
1291     {
1292         const SvxAdjustItem& rAdj = (const SvxAdjustItem&)rSet.Get( _nWhich );
1293
1294         switch ( rAdj.GetAdjust() /*!!! VB fragen rAdj.GetLastBlock()*/ )
1295         {
1296             case SVX_ADJUST_LEFT: aLeft.Check(); break;
1297
1298             case SVX_ADJUST_RIGHT: aRight.Check(); break;
1299
1300             case SVX_ADJUST_CENTER: aCenter.Check(); break;
1301
1302             case SVX_ADJUST_BLOCK: aJustify.Check(); break;
1303             default: ; //prevent warning
1304         }
1305         BOOL bEnable = aJustify.IsChecked();
1306         aLastLineFT.Enable(bEnable);
1307         aLastLineLB.Enable(bEnable);
1308         aExpandCB  .Enable(bEnable);
1309
1310         aExpandCB.Check(SVX_ADJUST_BLOCK == rAdj.GetOneWord());
1311         switch(rAdj.GetLastBlock())
1312         {
1313             case SVX_ADJUST_LEFT:  nLBSelect = 0; break;
1314
1315             case SVX_ADJUST_CENTER: nLBSelect = 1;  break;
1316
1317             case SVX_ADJUST_BLOCK: nLBSelect = 2;  break;
1318             default: ; //prevent warning
1319         }
1320     }
1321     else
1322     {
1323         aLeft.Check( FALSE );
1324         aRight.Check( FALSE );
1325         aCenter.Check( FALSE );
1326         aJustify.Check( FALSE );
1327     }
1328     aLastLineLB.SelectEntryPos(nLBSelect);
1329
1330     USHORT nHtmlMode = GetHtmlMode_Impl(rSet);
1331     if(nHtmlMode & HTMLMODE_ON)
1332     {
1333         aLastLineLB.Hide();
1334         aLastLineFT.Hide();
1335         aExpandCB.Hide();
1336         if(!(nHtmlMode & HTMLMODE_FULL_STYLES|HTMLMODE_FIRSTLINE) )
1337             aJustify.Disable();
1338         aSnapToGridCB.Show(FALSE);
1339     }
1340     _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
1341     eItemState = rSet.GetItemState( _nWhich );
1342     if ( eItemState >= SFX_ITEM_AVAILABLE )
1343     {
1344         const SvxParaGridItem& rSnap = (const SvxParaGridItem&)rSet.Get( _nWhich );
1345         aSnapToGridCB.Check(rSnap.GetValue());
1346     }
1347
1348     _nWhich = GetWhich( SID_PARA_VERTALIGN );
1349     eItemState = rSet.GetItemState( _nWhich );
1350
1351     if ( eItemState >= SFX_ITEM_AVAILABLE )
1352     {
1353         aVertAlignLB.Show();
1354         aVertAlignFL.Show();
1355         aVertAlignFT.Show();
1356
1357         const SvxParaVertAlignItem& rAlign = (const SvxParaVertAlignItem&)rSet.Get( _nWhich );
1358         aVertAlignLB.SelectEntryPos(rAlign.GetValue());
1359     }
1360
1361     _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
1362     //text direction
1363     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( _nWhich ) )
1364     {
1365         const SvxFrameDirectionItem& rFrameDirItem = ( const SvxFrameDirectionItem& ) rSet.Get( _nWhich );
1366         aTextDirectionLB.SelectEntryValue( (SvxFrameDirection)rFrameDirItem.GetValue() );
1367         aTextDirectionLB.SaveValue();
1368     }
1369
1370     aSnapToGridCB.SaveValue();
1371     aVertAlignLB.SaveValue();
1372     aLeft.SaveValue();
1373     aRight.SaveValue();
1374     aCenter.SaveValue();
1375     aJustify.SaveValue();
1376     aLastLineLB.SaveValue();
1377     aExpandCB.SaveValue();
1378
1379     UpdateExample_Impl(TRUE);
1380 }
1381
1382 /*-----------------17.01.97 08.06-------------------
1383
1384 --------------------------------------------------*/
1385 IMPL_LINK( SvxParaAlignTabPage, AlignHdl_Impl, RadioButton*, EMPTYARG )
1386 {
1387     BOOL bJustify = aJustify.IsChecked();
1388     aLastLineFT.Enable(bJustify);
1389     aLastLineLB.Enable(bJustify);
1390     aExpandCB.Enable(bJustify);
1391     UpdateExample_Impl(FALSE);
1392     return 0;
1393 }
1394
1395 IMPL_LINK( SvxParaAlignTabPage, LastLineHdl_Impl, ListBox*, EMPTYARG )
1396 {
1397     UpdateExample_Impl(FALSE);
1398     return 0;
1399 }
1400
1401 IMPL_LINK( SvxParaAlignTabPage, TextDirectionHdl_Impl, ListBox*, EMPTYARG )
1402 {
1403     SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
1404     switch ( eDir )
1405     {
1406         // check the default alignment for this text direction
1407         case FRMDIR_HORI_LEFT_TOP :             aLeft.Check( TRUE ); break;
1408         case FRMDIR_HORI_RIGHT_TOP :    aRight.Check( TRUE ); break;
1409         case FRMDIR_ENVIRONMENT :               /* do nothing */ break;
1410         default:
1411         {
1412             DBG_ERRORFILE( "SvxParaAlignTabPage::TextDirectionHdl_Impl(): other directions not supported" );
1413         }
1414     }
1415
1416     return 0;
1417 }
1418
1419 /*-----------------16.01.97 19.34-------------------
1420
1421 --------------------------------------------------*/
1422 void    SvxParaAlignTabPage::UpdateExample_Impl( BOOL bAll )
1423 {
1424     if ( aLeft.IsChecked() )
1425         aExampleWin.SetAdjust( SVX_ADJUST_LEFT );
1426     else if ( aRight.IsChecked() )
1427         aExampleWin.SetAdjust( SVX_ADJUST_RIGHT );
1428     else if ( aCenter.IsChecked() )
1429         aExampleWin.SetAdjust( SVX_ADJUST_CENTER );
1430     else if ( aJustify.IsChecked() )
1431     {
1432         aExampleWin.SetAdjust( SVX_ADJUST_BLOCK );
1433         SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1434         USHORT nLBPos = aLastLineLB.GetSelectEntryPos();
1435         if(nLBPos == 1)
1436             eLastBlock = SVX_ADJUST_CENTER;
1437         else if(nLBPos == 2)
1438             eLastBlock = SVX_ADJUST_BLOCK;
1439         aExampleWin.SetLastLine( eLastBlock );
1440     }
1441
1442     aExampleWin.Draw( bAll );
1443 }
1444 /*-----------------17.01.97 08.04-------------------
1445     Erweiterungen fuer den Blocksatz einschalten
1446 --------------------------------------------------*/
1447 void SvxParaAlignTabPage::EnableJustifyExt()
1448 {
1449     aLastLineFT.Show();
1450     aLastLineLB.Show();
1451     aExpandCB  .Show();
1452     SvtLanguageOptions aCJKOptions;
1453     if(aCJKOptions.IsAsianTypographyEnabled())
1454         aSnapToGridCB.Show();
1455
1456 }
1457 //add CHINA001 begin
1458 void SvxParaAlignTabPage::PageCreated (SfxAllItemSet aSet)
1459 {
1460     SFX_ITEMSET_ARG     (&aSet,pBoolItem,SfxBoolItem,SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT,sal_False);
1461     if (pBoolItem)
1462         if(pBoolItem->GetValue())
1463             EnableJustifyExt();
1464 }
1465 //end of CHINA001
1466 // class SvxExtParagraphTabPage ------------------------------------------
1467
1468 SfxTabPage* SvxExtParagraphTabPage::Create( Window* pParent,
1469                                             const SfxItemSet& rSet )
1470 {
1471     return new SvxExtParagraphTabPage( pParent, rSet );
1472 }
1473
1474 // -----------------------------------------------------------------------
1475
1476 BOOL SvxExtParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
1477 {
1478     BOOL bModified = FALSE;
1479     USHORT _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1480     const TriState eHyphenState = aHyphenBox.GetState();
1481     const SfxPoolItem* pOld = GetOldItem( rOutSet, SID_ATTR_PARA_HYPHENZONE );
1482
1483     if ( eHyphenState != aHyphenBox.GetSavedValue()     ||
1484          aExtHyphenBeforeBox.IsValueModified()                  ||
1485          aExtHyphenAfterBox.IsValueModified()                   ||
1486          aMaxHyphenEdit.IsValueModified() )
1487     {
1488         SvxHyphenZoneItem aHyphen(
1489             (const SvxHyphenZoneItem&)GetItemSet().Get( _nWhich ) );
1490         aHyphen.SetHyphen( eHyphenState == STATE_CHECK );
1491
1492         if ( eHyphenState == STATE_CHECK )
1493         {
1494             aHyphen.GetMinLead() = (BYTE)aExtHyphenBeforeBox.GetValue();
1495             aHyphen.GetMinTrail() = (BYTE)aExtHyphenAfterBox.GetValue();
1496         }
1497         aHyphen.GetMaxHyphens() = (BYTE)aMaxHyphenEdit.GetValue();
1498
1499         if ( !pOld ||
1500             !( *(SvxHyphenZoneItem*)pOld == aHyphen ) ||
1501                 eHyphenState != aHyphenBox.GetSavedValue())
1502         {
1503             rOutSet.Put( aHyphen );
1504             bModified |= TRUE;
1505         }
1506     }
1507
1508     if (aPagenumEdit.IsEnabled() && aPagenumEdit.IsValueModified())
1509     {
1510         SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM,
1511                                 (USHORT)aPagenumEdit.GetValue() );
1512
1513         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGENUM );
1514
1515         if ( !pOld || ( (const SfxUInt16Item*)pOld )->GetValue() != aPageNum.GetValue() )
1516         {
1517             rOutSet.Put( aPageNum );
1518             bModified |= TRUE;
1519         }
1520     }
1521
1522     // Seitenumbruch
1523
1524     TriState eState = aApplyCollBtn.GetState();
1525     FASTBOOL bIsPageModel = FALSE;
1526
1527     _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1528     String sPage;
1529     if ( eState != aApplyCollBtn.GetSavedValue() ||
1530          ( STATE_CHECK == eState &&
1531            aApplyCollBox.GetSelectEntryPos() != aApplyCollBox.GetSavedValue() ) )
1532     {
1533         if ( eState == STATE_CHECK )
1534         {
1535             sPage = aApplyCollBox.GetSelectEntry();
1536             bIsPageModel = 0 != sPage.Len();
1537         }
1538         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_MODEL );
1539
1540         if ( !pOld || ( (const SvxPageModelItem*)pOld )->GetValue() != sPage )
1541         {
1542             rOutSet.Put( SvxPageModelItem( sPage, FALSE, _nWhich ) );
1543             bModified |= TRUE;
1544         }
1545         else
1546             bIsPageModel = FALSE;
1547     }
1548     else if(STATE_CHECK == eState && aApplyCollBtn.IsEnabled())
1549         bIsPageModel = TRUE;
1550     else
1551         rOutSet.Put( SvxPageModelItem( sPage, FALSE, _nWhich ) );
1552
1553     _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1554
1555     if ( bIsPageModel )
1556         // wird PageModel eingeschaltet, dann immer PageBreak ausschalten
1557         rOutSet.Put( SvxFmtBreakItem( SVX_BREAK_NONE, _nWhich ) );
1558     else
1559     {
1560         eState = aPageBreakBox.GetState();
1561         SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, FALSE);
1562
1563         if ( (eModelState == SFX_ITEM_SET && STATE_CHECK == aPageBreakBox.GetState()) ||
1564              eState != aPageBreakBox.GetSavedValue()                            ||
1565              aBreakTypeLB.GetSelectEntryPos() != aBreakTypeLB.GetSavedValue()   ||
1566              aBreakPositionLB.GetSelectEntryPos() != aBreakPositionLB.GetSavedValue() )
1567         {
1568             const SvxFmtBreakItem rOldBreak(
1569                     (const SvxFmtBreakItem&)GetItemSet().Get( _nWhich ));
1570             SvxFmtBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());
1571
1572             switch ( eState )
1573             {
1574                 case STATE_CHECK:
1575                 {
1576                     BOOL bBefore = aBreakPositionLB.GetSelectEntryPos() == 0;
1577
1578                     if ( aBreakTypeLB.GetSelectEntryPos() == 0 )
1579                     {
1580                         if ( bBefore )
1581                             aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
1582                         else
1583                             aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
1584                     }
1585                     else
1586                     {
1587                         if ( bBefore )
1588                             aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
1589                         else
1590                             aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
1591                     }
1592                     break;
1593                 }
1594
1595                 case STATE_NOCHECK:
1596                     aBreak.SetValue( SVX_BREAK_NONE );
1597                     break;
1598                 default: ; //prevent warning
1599             }
1600             pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGEBREAK );
1601
1602             if ( eState != aPageBreakBox.GetSavedValue()                                ||
1603                     !pOld || !( *(const SvxFmtBreakItem*)pOld == aBreak ) )
1604             {
1605                 bModified |= TRUE;
1606                 rOutSet.Put( aBreak );
1607             }
1608         }
1609     }
1610
1611
1612     // Absatztrennung
1613     _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1614     eState = aKeepTogetherBox.GetState();
1615
1616     if ( eState != aKeepTogetherBox.GetSavedValue() )
1617     {
1618         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_SPLIT );
1619
1620         if ( !pOld || ( (const SvxFmtSplitItem*)pOld )->GetValue() !=
1621                       ( eState == STATE_NOCHECK ) )
1622         {
1623             rOutSet.Put( SvxFmtSplitItem( eState == STATE_NOCHECK, _nWhich ) );
1624             bModified |= TRUE;
1625         }
1626     }
1627
1628     // Absaetze zusammenhalten
1629     _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1630     eState = aKeepParaBox.GetState();
1631
1632     if ( eState != aKeepParaBox.GetSavedValue() )
1633     {
1634         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_KEEP );
1635
1636         // hat sich der Status geaendert, muss immer geputtet werden
1637         rOutSet.Put( SvxFmtKeepItem( eState == STATE_CHECK, _nWhich ) );
1638         bModified |= TRUE;
1639     }
1640
1641     // Witwen und Waisen
1642     _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1643     eState = aWidowBox.GetState();
1644
1645     if ( eState != aWidowBox.GetSavedValue() ||
1646          aWidowRowNo.IsValueModified() )
1647     {
1648         SvxWidowsItem rItem( eState == STATE_CHECK ?
1649                              (BYTE)aWidowRowNo.GetValue() : 0, _nWhich );
1650         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_WIDOWS );
1651
1652         if ( eState != aWidowBox.GetSavedValue() || !pOld || !( *(const SvxWidowsItem*)pOld == rItem ) )
1653         {
1654             rOutSet.Put( rItem );
1655             bModified |= TRUE;
1656         }
1657     }
1658
1659     _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1660     eState = aOrphanBox.GetState();
1661
1662     if ( eState != aOrphanBox.GetSavedValue() ||
1663          aOrphanRowNo.IsValueModified() )
1664     {
1665         SvxOrphansItem rItem( eState == STATE_CHECK ?
1666                              (BYTE)aOrphanRowNo.GetValue() : 0, _nWhich );
1667         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_ORPHANS );
1668
1669         if ( eState != aOrphanBox.GetSavedValue() ||
1670                 !pOld ||
1671                     !( *(const SvxOrphansItem*)pOld == rItem ) )
1672         {
1673             rOutSet.Put( rItem );
1674             bModified |= TRUE;
1675         }
1676     }
1677
1678     return bModified;
1679 }
1680
1681 // -----------------------------------------------------------------------
1682
1683 void SvxExtParagraphTabPage::Reset( const SfxItemSet& rSet )
1684 {
1685     USHORT _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1686     SfxItemState eItemState = rSet.GetItemState( _nWhich );
1687
1688     BOOL bItemAvailable = eItemState >= SFX_ITEM_AVAILABLE;
1689     BOOL bIsHyphen = FALSE;
1690     if( !bHtmlMode && bItemAvailable )
1691     {
1692         const SvxHyphenZoneItem& rHyphen =
1693             (const SvxHyphenZoneItem&)rSet.Get( _nWhich );
1694         aHyphenBox.EnableTriState( FALSE );
1695
1696         bIsHyphen = rHyphen.IsHyphen();
1697         aHyphenBox.SetState( bIsHyphen ? STATE_CHECK : STATE_NOCHECK );
1698
1699         aExtHyphenBeforeBox.SetValue( rHyphen.GetMinLead() );
1700         aExtHyphenAfterBox.SetValue( rHyphen.GetMinTrail() );
1701         aMaxHyphenEdit.SetValue( rHyphen.GetMaxHyphens() );
1702     }
1703     else
1704     {
1705         aHyphenBox.SetState( STATE_DONTKNOW );
1706     }
1707     BOOL bEnable = bItemAvailable && bIsHyphen;
1708     aExtHyphenBeforeBox.Enable(bEnable);
1709     aExtHyphenAfterBox.Enable(bEnable);
1710     aBeforeText.Enable(bEnable);
1711     aAfterText.Enable(bEnable);
1712     aMaxHyphenLabel.Enable(bEnable);
1713     aMaxHyphenEdit.Enable(bEnable);
1714
1715     _nWhich = GetWhich( SID_ATTR_PARA_PAGENUM );
1716
1717     if ( rSet.GetItemState(_nWhich) >= SFX_ITEM_AVAILABLE )
1718     {
1719         const USHORT nPageNum =
1720             ( (const SfxUInt16Item&)rSet.Get( _nWhich ) ).GetValue();
1721         aPagenumEdit.SetValue( nPageNum );
1722     }
1723
1724     if ( bPageBreak )
1725     {
1726         // zuerst PageModel behandeln
1727         _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1728         BOOL bIsPageModel = FALSE;
1729         eItemState = rSet.GetItemState( _nWhich );
1730
1731         if ( eItemState >= SFX_ITEM_SET )
1732         {
1733             aApplyCollBtn.EnableTriState( FALSE );
1734
1735             const SvxPageModelItem& rModel =
1736                 (const SvxPageModelItem&)rSet.Get( _nWhich );
1737             String aStr( rModel.GetValue() );
1738
1739             if ( aStr.Len() &&
1740                  aApplyCollBox.GetEntryPos( aStr ) != LISTBOX_ENTRY_NOTFOUND )
1741             {
1742                 aApplyCollBox.SelectEntry( aStr );
1743                 aApplyCollBtn.SetState( STATE_CHECK );
1744                 bIsPageModel = TRUE;
1745
1746                 aPageBreakBox.Enable();
1747                 aPageBreakBox.EnableTriState( FALSE );
1748                 aBreakTypeFT.Enable();
1749                 aBreakTypeLB.Enable();
1750                 aBreakPositionFT.Enable();
1751                 aBreakPositionLB.Enable();
1752                 aApplyCollBtn.Enable();
1753                 aPageBreakBox.SetState( STATE_CHECK );
1754
1755                 //select page break
1756                 aBreakTypeLB.SelectEntryPos(0);
1757                 //select break before
1758                 aBreakPositionLB.SelectEntryPos(0);
1759             }
1760             else
1761             {
1762                 aApplyCollBox.SetNoSelection();
1763                 aApplyCollBtn.SetState( STATE_NOCHECK );
1764             }
1765         }
1766         else if ( SFX_ITEM_DONTCARE == eItemState )
1767         {
1768             aApplyCollBtn.EnableTriState( TRUE );
1769             aApplyCollBtn.SetState( STATE_DONTKNOW );
1770             aApplyCollBox.SetNoSelection();
1771         }
1772         else
1773         {
1774             aApplyCollBtn.Enable(FALSE);
1775             aApplyCollBox.Enable(FALSE);
1776             aPagenumEdit.Enable(FALSE);
1777             aPagenumText.Enable(FALSE);
1778         }
1779 //!!!   ApplyCollClickHdl_Impl( &aApplyCollBtn );
1780
1781         if ( !bIsPageModel )
1782         {
1783             _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1784             eItemState = rSet.GetItemState( _nWhich );
1785
1786             if ( eItemState >= SFX_ITEM_AVAILABLE )
1787             {
1788                 const SvxFmtBreakItem& rPageBreak =
1789                     (const SvxFmtBreakItem&)rSet.Get( _nWhich );
1790
1791                 SvxBreak eBreak = (SvxBreak)rPageBreak.GetValue();
1792
1793                 // PageBreak nicht ueber CTRL-RETURN,
1794                 // dann kann CheckBox frei gegeben werden
1795                 aPageBreakBox.Enable();
1796                 aPageBreakBox.EnableTriState( FALSE );
1797                 aBreakTypeFT.Enable();
1798                 aBreakTypeLB.Enable();
1799                 aBreakPositionFT.Enable();
1800                 aBreakPositionLB.Enable();
1801
1802                 aPageBreakBox.SetState( STATE_CHECK );
1803
1804                 BOOL _bEnable =     eBreak != SVX_BREAK_NONE &&
1805                                 eBreak != SVX_BREAK_COLUMN_BEFORE &&
1806                                 eBreak != SVX_BREAK_COLUMN_AFTER;
1807                 aApplyCollBtn.Enable(_bEnable);
1808                 if(!_bEnable)
1809                 {
1810                     aApplyCollBox.Enable(_bEnable);
1811                     aPagenumEdit.Enable(_bEnable);
1812                 }
1813
1814                 if ( eBreak == SVX_BREAK_NONE )
1815                     aPageBreakBox.SetState( STATE_NOCHECK );
1816
1817                 USHORT nType = 0; // selection position in break type ListBox : Page
1818                 USHORT nPosition = 0; //  selection position in break position ListBox : Before
1819                 switch ( eBreak )
1820                 {
1821                     case SVX_BREAK_PAGE_BEFORE:
1822                         break;
1823                     case SVX_BREAK_PAGE_AFTER:
1824                         nPosition = 1;
1825                         break;
1826                     case SVX_BREAK_COLUMN_BEFORE:
1827                         nType = 1;
1828                         break;
1829                     case SVX_BREAK_COLUMN_AFTER:
1830                         nType = 1;
1831                         nPosition = 1;
1832                         break;
1833                     default: ;//prevent warning
1834                 }
1835                 aBreakTypeLB.SelectEntryPos(nType);
1836                 aBreakPositionLB.SelectEntryPos(nPosition);
1837             }
1838             else if ( SFX_ITEM_DONTCARE == eItemState )
1839                 aPageBreakBox.SetState( STATE_DONTKNOW );
1840             else
1841             {
1842                 aPageBreakBox.Enable(FALSE);
1843                 aBreakTypeFT.Enable(FALSE);
1844                 aBreakTypeLB.Enable(FALSE);
1845                 aBreakPositionFT.Enable(FALSE);
1846                 aBreakPositionLB.Enable(FALSE);
1847             }
1848         }
1849
1850         PageBreakPosHdl_Impl( &aBreakPositionLB );
1851         PageBreakHdl_Impl( &aPageBreakBox );
1852     }
1853
1854     _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1855     eItemState = rSet.GetItemState( _nWhich );
1856
1857     if ( eItemState >= SFX_ITEM_AVAILABLE )
1858     {
1859         aKeepParaBox.EnableTriState( FALSE );
1860         const SvxFmtKeepItem& rKeep =
1861             (const SvxFmtKeepItem&)rSet.Get( _nWhich );
1862
1863         if ( rKeep.GetValue() )
1864             aKeepParaBox.SetState( STATE_CHECK );
1865         else
1866             aKeepParaBox.SetState( STATE_NOCHECK );
1867     }
1868     else if ( SFX_ITEM_DONTCARE == eItemState )
1869         aKeepParaBox.SetState( STATE_DONTKNOW );
1870     else
1871         aKeepParaBox.Enable(FALSE);
1872
1873     _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1874     eItemState = rSet.GetItemState( _nWhich );
1875
1876     if ( eItemState >= SFX_ITEM_AVAILABLE )
1877     {
1878         const SvxFmtSplitItem& rSplit =
1879             (const SvxFmtSplitItem&)rSet.Get( _nWhich );
1880         aKeepTogetherBox.EnableTriState( FALSE );
1881
1882         if ( !rSplit.GetValue() )
1883             aKeepTogetherBox.SetState( STATE_CHECK );
1884         else
1885         {
1886             aKeepTogetherBox.SetState( STATE_NOCHECK );
1887
1888             // Witwen und Waisen
1889             aWidowBox.Enable();
1890             _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1891             SfxItemState eTmpState = rSet.GetItemState( _nWhich );
1892
1893             if ( eTmpState >= SFX_ITEM_AVAILABLE )
1894             {
1895                 const SvxWidowsItem& rWidow =
1896                     (const SvxWidowsItem&)rSet.Get( _nWhich );
1897                 aWidowBox.EnableTriState( FALSE );
1898                 const USHORT nLines = rWidow.GetValue();
1899
1900                 BOOL _bEnable = nLines > 0;
1901                 aWidowRowNo.SetValue( aWidowRowNo.Normalize( nLines ) );
1902                 aWidowBox.SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
1903                 aWidowRowNo.Enable(_bEnable);
1904                 aWidowRowLabel.Enable(_bEnable);
1905
1906             }
1907             else if ( SFX_ITEM_DONTCARE == eTmpState )
1908                 aWidowBox.SetState( STATE_DONTKNOW );
1909             else
1910                 aWidowBox.Enable(FALSE);
1911
1912             aOrphanBox.Enable();
1913             _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1914             eTmpState = rSet.GetItemState( _nWhich );
1915
1916             if ( eTmpState >= SFX_ITEM_AVAILABLE )
1917             {
1918                 const SvxOrphansItem& rOrphan =
1919                     (const SvxOrphansItem&)rSet.Get( _nWhich );
1920                 const USHORT nLines = rOrphan.GetValue();
1921                 aOrphanBox.EnableTriState( FALSE );
1922
1923                 BOOL _bEnable = nLines > 0;
1924                 aOrphanBox.SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
1925                 aOrphanRowNo.SetValue( aOrphanRowNo.Normalize( nLines ) );
1926                 aOrphanRowNo.Enable(_bEnable);
1927                 aOrphanRowLabel.Enable(_bEnable);
1928
1929             }
1930             else if ( SFX_ITEM_DONTCARE == eTmpState )
1931                 aOrphanBox.SetState( STATE_DONTKNOW );
1932             else
1933                 aOrphanBox.Enable(FALSE);
1934         }
1935     }
1936     else if ( SFX_ITEM_DONTCARE == eItemState )
1937         aKeepTogetherBox.SetState( STATE_DONTKNOW );
1938     else
1939         aKeepTogetherBox.Enable(FALSE);
1940
1941     // damit alles richt enabled wird
1942     KeepTogetherHdl_Impl( 0 );
1943     WidowHdl_Impl( 0 );
1944     OrphanHdl_Impl( 0 );
1945
1946     aHyphenBox.SaveValue();
1947     aExtHyphenBeforeBox.SaveValue();
1948     aExtHyphenAfterBox.SaveValue();
1949     aMaxHyphenEdit.SaveValue();
1950     aPageBreakBox.SaveValue();
1951     aBreakPositionLB.SaveValue();
1952     aBreakTypeLB.SaveValue();
1953     aApplyCollBtn.SaveValue();
1954     aApplyCollBox.SaveValue();
1955     aPagenumEdit.SaveValue();
1956     aKeepTogetherBox.SaveValue();
1957     aKeepParaBox.SaveValue();
1958     aWidowBox.SaveValue();
1959     aOrphanBox.SaveValue();
1960 }
1961
1962 // -----------------------------------------------------------------------
1963
1964 int SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
1965 {
1966     if ( _pSet )
1967         FillItemSet( *_pSet );
1968     return LEAVE_PAGE;
1969 }
1970
1971 // -----------------------------------------------------------------------
1972
1973 void SvxExtParagraphTabPage::DisablePageBreak()
1974 {
1975     bPageBreak = FALSE;
1976     aPageBreakBox.Enable(FALSE);
1977     aBreakTypeLB.RemoveEntry(0);
1978     aBreakPositionFT.Enable(FALSE);
1979     aBreakPositionLB.Enable(FALSE);
1980     aApplyCollBtn.Enable(FALSE);
1981     aApplyCollBox.Enable(FALSE);
1982     aPagenumEdit.Enable(FALSE);
1983 }
1984
1985 // -----------------------------------------------------------------------
1986
1987 SvxExtParagraphTabPage::SvxExtParagraphTabPage( Window* pParent, const SfxItemSet& rAttr ) :
1988
1989     SfxTabPage( pParent, SVX_RES( RID_SVXPAGE_EXT_PARAGRAPH ), rAttr ),
1990
1991     aHyphenBox                  ( this, SVX_RES( BTN_HYPHEN ) ),
1992     aBeforeText                 ( this, SVX_RES( FT_HYPHENBEFORE ) ),
1993     aExtHyphenBeforeBox ( this, SVX_RES( ED_HYPHENBEFORE ) ),
1994     aAfterText                  ( this, SVX_RES( FT_HYPHENAFTER ) ),
1995     aExtHyphenAfterBox  ( this, SVX_RES( ED_HYPHENAFTER ) ),
1996     aMaxHyphenLabel     ( this, SVX_RES( FT_MAXHYPH ) ),
1997     aMaxHyphenEdit              ( this, SVX_RES( ED_MAXHYPH ) ),
1998     aExtFL              ( this, SVX_RES( FL_HYPHEN ) ),
1999     aBreaksFL           ( this, SVX_RES( FL_BREAKS ) ),
2000     aPageBreakBox       ( this, SVX_RES( BTN_PAGEBREAK ) ),
2001     aBreakTypeFT        ( this, SVX_RES( FT_BREAKTYPE     )),
2002     aBreakTypeLB        ( this, SVX_RES( LB_BREAKTYPE     )),
2003     aBreakPositionFT    ( this, SVX_RES( FT_BREAKPOSITION )),
2004     aBreakPositionLB    ( this, SVX_RES( LB_BREAKPOSITION )),
2005 //    aPageBox            ( this, SVX_RES( BTN_BREAKPAGE ) ),
2006 //    aColumnBox          ( this, SVX_RES( BTN_BREAKCOLUMN ) ),
2007 //    aBeforeBox          ( this, SVX_RES( BTN_PAGEBREAKBEFORE ) ),
2008 //    aAfterBox           ( this, SVX_RES( BTN_PAGEBREAKAFTER ) ),
2009     aApplyCollBtn       ( this, SVX_RES( BTN_PAGECOLL ) ),
2010     aApplyCollBox       ( this, SVX_RES( LB_PAGECOLL ) ),
2011     aPagenumText                ( this, SVX_RES( FT_PAGENUM ) ),
2012     aPagenumEdit                ( this, SVX_RES( ED_PAGENUM ) ),
2013     aExtendFL           ( this, SVX_RES( FL_OPTIONS ) ),
2014     aKeepTogetherBox    ( this, SVX_RES( BTN_KEEPTOGETHER ) ),
2015     aKeepParaBox                ( this, SVX_RES( CB_KEEPTOGETHER ) ),
2016     aOrphanBox          ( this, SVX_RES( BTN_ORPHANS ) ),
2017     aOrphanRowNo        ( this, SVX_RES( ED_ORPHANS ) ),
2018     aOrphanRowLabel     ( this, SVX_RES( FT_ORPHANS ) ),
2019     aWidowBox           ( this, SVX_RES( BTN_WIDOWS ) ),
2020     aWidowRowNo         ( this, SVX_RES( ED_WIDOWS ) ),
2021     aWidowRowLabel      ( this, SVX_RES( FT_WIDOWS ) ),
2022     bPageBreak  ( TRUE ),
2023     bHtmlMode   ( FALSE ),
2024     nStdPos     ( 0 )
2025 {
2026     FreeResource();
2027
2028     // diese Page braucht ExchangeSupport
2029     SetExchangeSupport();
2030
2031     aHyphenBox.SetClickHdl(             LINK( this, SvxExtParagraphTabPage, HyphenClickHdl_Impl ) );
2032     aPageBreakBox.SetClickHdl(          LINK( this, SvxExtParagraphTabPage, PageBreakHdl_Impl ) );
2033     aKeepTogetherBox.SetClickHdl(       LINK( this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl ) );
2034     aWidowBox.SetClickHdl(                      LINK( this, SvxExtParagraphTabPage, WidowHdl_Impl ) );
2035     aOrphanBox.SetClickHdl(             LINK( this, SvxExtParagraphTabPage, OrphanHdl_Impl ) );
2036     aApplyCollBtn.SetClickHdl(          LINK( this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl ) );
2037     aBreakTypeLB.SetSelectHdl(      LINK( this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl ) );
2038     aBreakPositionLB.SetSelectHdl(  LINK( this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl ) );
2039
2040     SfxObjectShell* pSh = SfxObjectShell::Current();
2041     if ( pSh )
2042     {
2043         SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
2044         pPool->SetSearchMask( SFX_STYLE_FAMILY_PAGE );
2045         SfxStyleSheetBase* pStyle = pPool->First();
2046         String aStdName;
2047
2048         while( pStyle )
2049         {
2050             if ( aStdName.Len() == 0 )
2051                 // first style == standard style
2052                 aStdName = pStyle->GetName();
2053             aApplyCollBox.InsertEntry( pStyle->GetName() );
2054             pStyle = pPool->Next();
2055         }
2056         nStdPos = aApplyCollBox.GetEntryPos( aStdName );
2057     }
2058
2059     USHORT nHtmlMode = GetHtmlMode_Impl( rAttr );
2060     if ( nHtmlMode & HTMLMODE_ON )
2061     {
2062         bHtmlMode = TRUE;
2063         aHyphenBox               .Enable(FALSE);
2064         aBeforeText                      .Enable(FALSE);
2065         aExtHyphenBeforeBox  .Enable(FALSE);
2066         aAfterText                       .Enable(FALSE);
2067         aExtHyphenAfterBox   .Enable(FALSE);
2068         aMaxHyphenLabel      .Enable(FALSE);
2069         aMaxHyphenEdit           .Enable(FALSE);
2070         aExtFL               .Enable(FALSE);
2071         aPagenumText         .Enable(FALSE);
2072         aPagenumEdit         .Enable(FALSE);
2073         // no column break in HTML
2074         aBreakTypeLB.RemoveEntry(1);
2075     }
2076 }
2077
2078 // -----------------------------------------------------------------------
2079
2080 __EXPORT SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
2081 {
2082 }
2083
2084 // -----------------------------------------------------------------------
2085
2086 USHORT* SvxExtParagraphTabPage::GetRanges()
2087 {
2088     return pExtRanges;
2089 }
2090
2091 // -----------------------------------------------------------------------
2092
2093 IMPL_LINK( SvxExtParagraphTabPage, PageBreakHdl_Impl, TriStateBox *, EMPTYARG )
2094 {
2095     switch ( aPageBreakBox.GetState() )
2096     {
2097         case STATE_CHECK:
2098             aBreakTypeFT.Enable();
2099             aBreakTypeLB.Enable();
2100             aBreakPositionFT.Enable();
2101             aBreakPositionLB.Enable();
2102
2103             if ( 0 == aBreakTypeLB.GetSelectEntryPos()&&
2104                 0 == aBreakPositionLB.GetSelectEntryPos() )
2105             {
2106                 aApplyCollBtn.Enable();
2107
2108                 BOOL bEnable = STATE_CHECK == aApplyCollBtn.GetState() &&
2109                                             aApplyCollBox.GetEntryCount();
2110                 aApplyCollBox.Enable(bEnable);
2111                 if(!bHtmlMode)
2112                 {
2113                     aPagenumText.Enable(bEnable);
2114                     aPagenumEdit.Enable(bEnable);
2115                 }
2116             }
2117             break;
2118
2119         case STATE_NOCHECK:
2120         case STATE_DONTKNOW:
2121             aApplyCollBtn.SetState( STATE_NOCHECK );
2122             aApplyCollBtn.Enable(FALSE);
2123             aApplyCollBox.Enable(FALSE);
2124             aPagenumText.Enable(FALSE);
2125             aPagenumEdit.Enable(FALSE);
2126             aBreakTypeFT.Enable(FALSE);
2127             aBreakTypeLB.Enable(FALSE);
2128             aBreakPositionFT.Enable(FALSE);
2129             aBreakPositionLB.Enable(FALSE);
2130             break;
2131     }
2132     return 0;
2133 }
2134
2135 // -----------------------------------------------------------------------
2136
2137 IMPL_LINK( SvxExtParagraphTabPage, KeepTogetherHdl_Impl, TriStateBox *, EMPTYARG )
2138 {
2139     BOOL bEnable = aKeepTogetherBox.GetState() == STATE_NOCHECK;
2140     aWidowBox.Enable(bEnable);
2141     aOrphanBox.Enable(bEnable);
2142
2143     return 0;
2144 }
2145
2146 // -----------------------------------------------------------------------
2147
2148 IMPL_LINK( SvxExtParagraphTabPage, WidowHdl_Impl, TriStateBox *, EMPTYARG )
2149 {
2150     switch ( aWidowBox.GetState() )
2151     {
2152         case STATE_CHECK:
2153             aWidowRowNo.Enable();
2154             aWidowRowLabel.Enable();
2155             aKeepTogetherBox.Enable(FALSE);
2156             break;
2157
2158         case STATE_NOCHECK:
2159             if ( aOrphanBox.GetState() == STATE_NOCHECK )
2160                 aKeepTogetherBox.Enable();
2161
2162         // kein break
2163         case STATE_DONTKNOW:
2164             aWidowRowNo.Enable(FALSE);
2165             aWidowRowLabel.Enable(FALSE);
2166             break;
2167     }
2168     return 0;
2169 }
2170
2171 // -----------------------------------------------------------------------
2172
2173 IMPL_LINK( SvxExtParagraphTabPage, OrphanHdl_Impl, TriStateBox *, EMPTYARG )
2174 {
2175     switch( aOrphanBox.GetState() )
2176     {
2177         case STATE_CHECK:
2178             aOrphanRowNo.Enable();
2179             aOrphanRowLabel.Enable();
2180             aKeepTogetherBox.Enable(FALSE);
2181             break;
2182
2183         case STATE_NOCHECK:
2184             if ( aWidowBox.GetState() == STATE_NOCHECK )
2185                 aKeepTogetherBox.Enable();
2186
2187         // kein break
2188         case STATE_DONTKNOW:
2189             aOrphanRowNo.Enable(FALSE);
2190             aOrphanRowLabel.Enable(FALSE);
2191             break;
2192     }
2193     return 0;
2194 }
2195
2196 // -----------------------------------------------------------------------
2197
2198 IMPL_LINK( SvxExtParagraphTabPage, HyphenClickHdl_Impl, TriStateBox *, EMPTYARG )
2199 {
2200
2201     BOOL bEnable = aHyphenBox.GetState() == STATE_CHECK;
2202     aBeforeText.Enable(bEnable);
2203     aExtHyphenBeforeBox.Enable(bEnable);
2204     aAfterText.Enable(bEnable);
2205     aExtHyphenAfterBox.Enable(bEnable);
2206     aMaxHyphenLabel.Enable(bEnable);
2207     aMaxHyphenEdit.Enable(bEnable);
2208     aHyphenBox.SetState( bEnable ? STATE_CHECK : STATE_NOCHECK);
2209
2210     return 0;
2211 }
2212
2213 // -----------------------------------------------------------------------
2214
2215 IMPL_LINK( SvxExtParagraphTabPage, ApplyCollClickHdl_Impl, TriStateBox *, EMPTYARG )
2216 {
2217     BOOL bEnable = FALSE;
2218     if ( aApplyCollBtn.GetState() == STATE_CHECK &&
2219          aApplyCollBox.GetEntryCount() )
2220     {
2221         bEnable = TRUE;
2222         aApplyCollBox.SelectEntryPos( nStdPos );
2223     }
2224     else
2225     {
2226         aApplyCollBox.SetNoSelection();
2227     }
2228     aApplyCollBox.Enable(bEnable);
2229     if(!bHtmlMode)
2230     {
2231         aPagenumText.Enable(bEnable);
2232         aPagenumEdit.Enable(bEnable);
2233     }
2234     return 0;
2235 }
2236
2237 // -----------------------------------------------------------------------
2238
2239 IMPL_LINK( SvxExtParagraphTabPage, PageBreakPosHdl_Impl, ListBox *, pListBox )
2240 {
2241     if ( 0 == pListBox->GetSelectEntryPos() )
2242     {
2243         aApplyCollBtn.Enable();
2244
2245         BOOL bEnable = aApplyCollBtn.GetState() == STATE_CHECK &&
2246                                     aApplyCollBox.GetEntryCount();
2247
2248         aApplyCollBox.Enable(bEnable);
2249         if(!bHtmlMode)
2250         {
2251             aPagenumText.Enable(bEnable);
2252             aPagenumEdit.Enable(bEnable);
2253         }
2254     }
2255     else if ( 1 == pListBox->GetSelectEntryPos() )
2256     {
2257         aApplyCollBtn.SetState( STATE_NOCHECK );
2258         aApplyCollBtn.Enable(FALSE);
2259         aApplyCollBox.Enable(FALSE);
2260         aPagenumText.Enable(FALSE);
2261         aPagenumEdit.Enable(FALSE);
2262     }
2263     return 0;
2264 }
2265
2266 // -----------------------------------------------------------------------
2267
2268 IMPL_LINK( SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, ListBox *, pListBox )
2269 {
2270     //column break or break break after
2271     USHORT nBreakPos = aBreakPositionLB.GetSelectEntryPos();
2272     if ( pListBox->GetSelectEntryPos() == 1 || 1 == nBreakPos)
2273     {
2274         aApplyCollBtn.SetState( STATE_NOCHECK );
2275         aApplyCollBtn.Enable(FALSE);
2276         aApplyCollBox.Enable(FALSE);
2277         aPagenumText.Enable(FALSE);
2278         aPagenumEdit.Enable(FALSE);
2279     }
2280     else
2281         PageBreakPosHdl_Impl( &aBreakPositionLB );
2282     return 0;
2283 }
2284 //Add CHINA001 begin
2285 void SvxExtParagraphTabPage::PageCreated(SfxAllItemSet aSet)
2286 {
2287
2288
2289     SFX_ITEMSET_ARG     (&aSet,pDisablePageBreakItem,SfxBoolItem,SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK,sal_False);
2290
2291     if (pDisablePageBreakItem)
2292         if ( pDisablePageBreakItem->GetValue())
2293                     DisablePageBreak();
2294
2295
2296 }
2297 //end of Add CHINA001
2298 /*-- 29.11.00 11:36:24---------------------------------------------------
2299
2300   -----------------------------------------------------------------------*/
2301 SvxAsianTabPage::SvxAsianTabPage( Window* pParent, const SfxItemSet& rSet ) :
2302     SfxTabPage(pParent, SVX_RES( RID_SVXPAGE_PARA_ASIAN ), rSet),
2303     aOptionsFL(         this, SVX_RES(FL_AS_OPTIONS       )),
2304     aForbiddenRulesCB(  this, SVX_RES(CB_AS_FORBIDDEN     )),
2305     aHangingPunctCB(    this, SVX_RES(CB_AS_HANG_PUNC     )),
2306     aScriptSpaceCB(     this, SVX_RES(CB_AS_SCRIPT_SPACE        ))//,
2307
2308 {
2309     FreeResource();
2310
2311     Link aLink = LINK( this, SvxAsianTabPage, ClickHdl_Impl );
2312     aHangingPunctCB.SetClickHdl( aLink );
2313     aScriptSpaceCB.SetClickHdl( aLink );
2314     aForbiddenRulesCB.SetClickHdl( aLink );
2315
2316 }
2317 /*-- 29.11.00 11:36:24---------------------------------------------------
2318
2319   -----------------------------------------------------------------------*/
2320 SvxAsianTabPage::~SvxAsianTabPage()
2321 {
2322 }
2323 /*-- 29.11.00 11:36:24---------------------------------------------------
2324
2325   -----------------------------------------------------------------------*/
2326 SfxTabPage*     SvxAsianTabPage::Create(        Window* pParent, const SfxItemSet& rSet )
2327 {
2328     return new SvxAsianTabPage(pParent, rSet);
2329 }
2330 /*-- 29.11.00 11:36:24---------------------------------------------------
2331
2332   -----------------------------------------------------------------------*/
2333 USHORT*         SvxAsianTabPage::GetRanges()
2334 {
2335     static USHORT pRanges[] =
2336     {
2337         SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES,
2338         0
2339     };
2340     return pRanges;
2341 }
2342 /*-- 29.11.00 11:36:24---------------------------------------------------
2343
2344   -----------------------------------------------------------------------*/
2345 BOOL            SvxAsianTabPage::FillItemSet( SfxItemSet& rSet )
2346 {
2347     BOOL bRet = FALSE;
2348     SfxItemPool* pPool = rSet.GetPool();
2349     if(aScriptSpaceCB.IsChecked() != aScriptSpaceCB.GetSavedValue())
2350     {
2351         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2352             pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone();
2353         pNewItem->SetValue(aScriptSpaceCB.IsChecked());
2354         rSet.Put(*pNewItem);
2355         delete pNewItem;
2356         bRet = TRUE;
2357     }
2358     if(aHangingPunctCB.IsChecked() != aHangingPunctCB.GetSavedValue())
2359     {
2360         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2361             pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone();
2362         pNewItem->SetValue(aHangingPunctCB.IsChecked());
2363         rSet.Put(*pNewItem);
2364         delete pNewItem;
2365         bRet = TRUE;
2366     }
2367     if(aForbiddenRulesCB.IsChecked() != aForbiddenRulesCB.GetSavedValue())
2368     {
2369         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2370             pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone();
2371         pNewItem->SetValue(aForbiddenRulesCB.IsChecked());
2372         rSet.Put(*pNewItem);
2373         delete pNewItem;
2374         bRet = TRUE;
2375     }
2376     return bRet;
2377 }
2378 /*-- 29.11.00 11:36:25---------------------------------------------------
2379
2380   -----------------------------------------------------------------------*/
2381 void lcl_SetBox(const SfxItemSet& rSet, USHORT nSlotId, TriStateBox& rBox)
2382 {
2383     USHORT _nWhich = rSet.GetPool()->GetWhich(nSlotId);
2384     SfxItemState eState = rSet.GetItemState(_nWhich, TRUE);
2385     if(!eState || eState == SFX_ITEM_DISABLED )
2386         rBox.Enable(FALSE);
2387     else if(eState >= SFX_ITEM_AVAILABLE)
2388     {
2389         rBox.EnableTriState( FALSE );
2390         rBox.Check(((const SfxBoolItem&)rSet.Get(_nWhich)).GetValue());
2391     }
2392     else
2393         rBox.SetState( STATE_DONTKNOW );
2394     rBox.SaveValue();
2395 }
2396
2397
2398 void SvxAsianTabPage::Reset( const SfxItemSet& rSet )
2399 {
2400     lcl_SetBox(rSet, SID_ATTR_PARA_FORBIDDEN_RULES, aForbiddenRulesCB );
2401 //      lcl_SetBox(rSet, , aAllowWordBreakCB );
2402     lcl_SetBox(rSet, SID_ATTR_PARA_HANGPUNCTUATION, aHangingPunctCB );
2403
2404
2405     //character distance not yet available
2406 //      lcl_SetBox(rSet, , aPuntuationCB    );
2407     lcl_SetBox(rSet, SID_ATTR_PARA_SCRIPTSPACE, aScriptSpaceCB );
2408 //      lcl_SetBox(rSet, , aAdjustNumbersCB );
2409 //      aAllowWordBreakCB       .Enable(FALSE);
2410 //      aPuntuationCB           .Enable(FALSE);
2411 //      aAdjustNumbersCB        .Enable(FALSE);
2412 }
2413 /* -----------------------------19.12.00 12:59--------------------------------
2414
2415  ---------------------------------------------------------------------------*/
2416 IMPL_LINK( SvxAsianTabPage, ClickHdl_Impl, TriStateBox*, pBox )
2417 {
2418     pBox->EnableTriState( FALSE );
2419     return 0;
2420 }