cui/source/tabpages/paragrph.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svl/style.hxx>
  21 #include <sfx2/app.hxx>
  22 #include <sfx2/dialoghelper.hxx>
  23 #include <sfx2/objsh.hxx>
  24 #include <sfx2/module.hxx>
  25 #include <vcl/mnemonic.hxx>
  26 #include <svx/dialogs.hrc>
  27
  28 #include <svl/languageoptions.hxx>
  29 #include <svl/cjkoptions.hxx>
  30 #include <editeng/pgrditem.hxx>
  31 #include <cuires.hrc>
  32 #include "paragrph.hrc"
  33 #include "paragrph.hxx"
  34 #include <editeng/frmdiritem.hxx>
  35 #include <editeng/lspcitem.hxx>
  36 #include <editeng/adjustitem.hxx>
  37 #include <editeng/orphitem.hxx>
  38 #include <editeng/widwitem.hxx>
  39 #include <editeng/tstpitem.hxx>
  40 #include <editeng/pmdlitem.hxx>
  41 #include <editeng/spltitem.hxx>
  42 #include <editeng/hyphenzoneitem.hxx>
  43 #include <editeng/ulspitem.hxx>
  44 #include <editeng/lrspitem.hxx>
  45 #include <editeng/formatbreakitem.hxx>
  46 #include <editeng/keepitem.hxx>
  47 #include "svx/dlgutil.hxx"
  48 #include <dialmgr.hxx>
  49 #include <sfx2/htmlmode.hxx>
  50 #include <editeng/paravertalignitem.hxx>
  51 #include <svl/eitem.hxx>
  52 #include <sfx2/request.hxx>
  53 #include <svl/intitem.hxx>
  54
  55 static const sal_uInt16 pStdRanges[] =
  56 {
  57     SID_ATTR_PARA_LINESPACE,        // 10033
  58     SID_ATTR_PARA_LINESPACE,
  59     SID_ATTR_LRSPACE,               // 10048 -
  60     SID_ATTR_ULSPACE,               // 10049
  61     SID_ATTR_PARA_REGISTER,         // 10413
  62     SID_ATTR_PARA_REGISTER,
  63     0
  64 };
  65
  66 static const sal_uInt16 pAlignRanges[] =
  67 {
  68     SID_ATTR_PARA_ADJUST,           // 10027
  69     SID_ATTR_PARA_ADJUST,
  70     0
  71 };
  72
  73 static const sal_uInt16 pExtRanges[] =
  74 {
  75     SID_ATTR_PARA_PAGEBREAK,        // 10037 -
  76     SID_ATTR_PARA_WIDOWS,           // 10041
  77     SID_ATTR_PARA_MODEL,            // 10065 -
  78     SID_ATTR_PARA_KEEP,             // 10066
  79     0
  80 };
  81
  82 #define MAX_DURCH 5670      // 10 cm makes sense as maximum interline lead
  83                             // according to BP
  84 #define FIX_DIST_DEF 283    // standard fix distance 0,5 cm
  85
  86 enum LineSpaceList
  87 {
  88     LLINESPACE_1    = 0,
  89     LLINESPACE_15   = 1,
  90     LLINESPACE_2    = 2,
  91     LLINESPACE_PROP = 3,
  92     LLINESPACE_MIN  = 4,
  93     LLINESPACE_DURCH= 5,
  94     LLINESPACE_FIX  = 6,
  95     LLINESPACE_END
  96 };
  97
  98 void SetLineSpace_Impl( SvxLineSpacingItem&, int, long lValue = 0 );
  99
 100 void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace,
 101                         int eSpace, long lValue )
 102 {
 103     switch ( eSpace )
 104     {
 105         case LLINESPACE_1:
 106             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 107             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 108             break;
 109
 110         case LLINESPACE_15:
 111             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 112             rLineSpace.SetPropLineSpace( 150 );
 113             break;
 114
 115         case LLINESPACE_2:
 116             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 117             rLineSpace.SetPropLineSpace( 200 );
 118             break;
 119
 120         case LLINESPACE_PROP:
 121             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 122             rLineSpace.SetPropLineSpace( (sal_uInt8)lValue );
 123             break;
 124
 125         case LLINESPACE_MIN:
 126             rLineSpace.SetLineHeight( (sal_uInt16)lValue );
 127             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 128             break;
 129
 130         case LLINESPACE_DURCH:
 131             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
 132             rLineSpace.SetInterLineSpace( (sal_uInt16)lValue );
 133             break;
 134
 135         case LLINESPACE_FIX:
 136             rLineSpace.SetLineHeight((sal_uInt16)lValue);
 137             rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_FIX;
 138             rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
 139         break;
 140     }
 141 }
 142
 143 sal_uInt16 GetHtmlMode_Impl(const SfxItemSet& rSet)
 144 {
 145     sal_uInt16 nHtmlMode = 0;
 146     const SfxPoolItem* pItem = 0;
 147     SfxObjectShell* pShell;
 148     if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, false, &pItem) ||
 149         ( 0 != (pShell = SfxObjectShell::Current()) &&
 150                     0 != (pItem = pShell->GetItem(SID_HTML_MODE))))
 151     {
 152         nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
 153     }
 154     return nHtmlMode;
 155
 156 }
 157
 158 IMPL_LINK_NOARG(SvxStdParagraphTabPage, ELRLoseFocusHdl)
 159 {
 160     SfxItemPool* pPool = GetItemSet().GetPool();
 161     DBG_ASSERT( pPool, "Wo ist der Pool" );
 162     FieldUnit eUnit =
 163         MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
 164
 165     sal_Int64 nL = m_pLeftIndent->Denormalize( m_pLeftIndent->GetValue( eUnit ) );
 166     sal_Int64 nR = m_pRightIndent->Denormalize( m_pRightIndent->GetValue( eUnit ) );
 167     OUString aTmp = m_pFLineIndent->GetText();
 168
 169     if( m_pLeftIndent->GetMin() < 0 )
 170         m_pFLineIndent->SetMin( -99999, FUNIT_MM );
 171     else
 172         m_pFLineIndent->SetMin( m_pFLineIndent->Normalize( -nL ), eUnit );
 173
 174     // Check only for concrete width (Shell)
 175     sal_Int64 nTmp = nWidth - nL - nR - MM50;
 176     m_pFLineIndent->SetMax( m_pFLineIndent->Normalize( nTmp ), eUnit );
 177
 178     if ( aTmp.isEmpty() )
 179         m_pFLineIndent->SetEmptyFieldValue();
 180     // maximum left right
 181     aTmp = m_pLeftIndent->GetText();
 182     nTmp = nWidth - nR - MM50;
 183     m_pLeftIndent->SetMax( m_pLeftIndent->Normalize( nTmp ), eUnit );
 184
 185     if ( aTmp.isEmpty() )
 186         m_pLeftIndent->SetEmptyFieldValue();
 187     aTmp = m_pRightIndent->GetText();
 188     nTmp = nWidth - nL - MM50;
 189     m_pRightIndent->SetMax( m_pRightIndent->Normalize( nTmp ), eUnit );
 190
 191     if ( aTmp.isEmpty() )
 192         m_pRightIndent->SetEmptyFieldValue();
 193     return 0;
 194 }
 195
 196 SfxTabPage* SvxStdParagraphTabPage::Create( Window* pParent, const SfxItemSet& rSet)
 197 {
 198     return new SvxStdParagraphTabPage( pParent, rSet );
 199 }
 200
 201 bool SvxStdParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
 202 {
 203     SfxItemState eState = SFX_ITEM_UNKNOWN;
 204     const SfxPoolItem* pOld = 0;
 205     SfxItemPool* pPool = rOutSet.GetPool();
 206     DBG_ASSERT( pPool, "Wo ist der Pool" );
 207
 208     bool bModified = false;
 209     sal_uInt16 nWhich;
 210     sal_Int32 nPos = m_pLineDist->GetSelectEntryPos();
 211
 212     if ( LISTBOX_ENTRY_NOTFOUND != nPos &&
 213          ( m_pLineDist->IsValueChangedFromSaved() ||
 214            m_pLineDistAtPercentBox->IsValueModified() ||
 215            m_pLineDistAtMetricBox->IsValueModified() ) )
 216     {
 217         nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
 218         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 219         SvxLineSpacingItem aSpacing(
 220             (const SvxLineSpacingItem&)GetItemSet().Get( nWhich ) );
 221
 222         switch ( nPos )
 223         {
 224             case LLINESPACE_1:
 225             case LLINESPACE_15:
 226             case LLINESPACE_2:
 227                 SetLineSpace_Impl( aSpacing, nPos );
 228                 break;
 229
 230             case LLINESPACE_PROP:
 231                 SetLineSpace_Impl( aSpacing, nPos,
 232                                    static_cast<long>(m_pLineDistAtPercentBox->Denormalize(
 233                                    m_pLineDistAtPercentBox->GetValue() )) );
 234                 break;
 235
 236             case LLINESPACE_MIN:
 237             case LLINESPACE_DURCH:
 238             case LLINESPACE_FIX:
 239                 SetLineSpace_Impl( aSpacing, nPos,
 240                     GetCoreValue( *m_pLineDistAtMetricBox, eUnit ) );
 241             break;
 242
 243             default:
 244                 OSL_FAIL( "unbekannter Type fuer Zeilenabstand." );
 245                 break;
 246         }
 247         eState = GetItemSet().GetItemState( nWhich );
 248         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_LINESPACE );
 249
 250         if ( !pOld || !( *(const SvxLineSpacingItem*)pOld == aSpacing ) ||
 251              SFX_ITEM_DONTCARE == eState )
 252         {
 253             rOutSet.Put( aSpacing );
 254             bModified = true;
 255         }
 256     }
 257
 258     if ( m_pTopDist->IsValueModified() || m_pBottomDist->IsValueModified()
 259          || m_pContextualCB->IsValueChangedFromSaved())
 260     {
 261         nWhich = GetWhich( SID_ATTR_ULSPACE );
 262         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 263         pOld = GetOldItem( rOutSet, SID_ATTR_ULSPACE );
 264         SvxULSpaceItem aMargin( nWhich );
 265
 266         if ( bRelativeMode )
 267         {
 268             DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
 269
 270             const SvxULSpaceItem& rOldItem =
 271                 (const SvxULSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
 272
 273             if ( m_pTopDist->IsRelative() )
 274                 aMargin.SetUpper( rOldItem.GetUpper(),
 275                                   (sal_uInt16)m_pTopDist->GetValue() );
 276             else
 277                 aMargin.SetUpper( (sal_uInt16)GetCoreValue( *m_pTopDist, eUnit ) );
 278
 279             if ( m_pBottomDist->IsRelative() )
 280                 aMargin.SetLower( rOldItem.GetLower(),
 281                                   (sal_uInt16)m_pBottomDist->GetValue() );
 282             else
 283                 aMargin.SetLower( (sal_uInt16)GetCoreValue( *m_pBottomDist, eUnit ) );
 284
 285         }
 286         else
 287         {
 288             aMargin.SetUpper( (sal_uInt16)GetCoreValue( *m_pTopDist, eUnit ) );
 289             aMargin.SetLower( (sal_uInt16)GetCoreValue( *m_pBottomDist, eUnit ) );
 290         }
 291         aMargin.SetContextValue(m_pContextualCB->IsChecked());
 292         eState = GetItemSet().GetItemState( nWhich );
 293
 294         if ( !pOld || !( *(const SvxULSpaceItem*)pOld == aMargin ) ||
 295              SFX_ITEM_DONTCARE == eState )
 296         {
 297             rOutSet.Put( aMargin );
 298             bModified = true;
 299         }
 300     }
 301     bool bNullTab = false;
 302
 303     if ( m_pLeftIndent->IsValueModified() ||
 304          m_pFLineIndent->IsValueModified() ||
 305          m_pRightIndent->IsValueModified() ||
 306          m_pAutoCB->IsValueChangedFromSaved() )
 307     {
 308         nWhich = GetWhich( SID_ATTR_LRSPACE );
 309         SfxMapUnit eUnit = pPool->GetMetric( nWhich );
 310         SvxLRSpaceItem aMargin( nWhich );
 311         pOld = GetOldItem( rOutSet, SID_ATTR_LRSPACE );
 312
 313         if ( bRelativeMode )
 314         {
 315             DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
 316
 317             const SvxLRSpaceItem& rOldItem =
 318                 (const SvxLRSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
 319
 320             if ( m_pLeftIndent->IsRelative() )
 321                 aMargin.SetTxtLeft( rOldItem.GetTxtLeft(),
 322                                     (sal_uInt16)m_pLeftIndent->GetValue() );
 323             else
 324                 aMargin.SetTxtLeft( GetCoreValue( *m_pLeftIndent, eUnit ) );
 325
 326             if ( m_pRightIndent->IsRelative() )
 327                 aMargin.SetRight( rOldItem.GetRight(),
 328                                   (sal_uInt16)m_pRightIndent->GetValue() );
 329             else
 330                 aMargin.SetRight( GetCoreValue( *m_pRightIndent, eUnit ) );
 331
 332             if ( m_pFLineIndent->IsRelative() )
 333                 aMargin.SetTxtFirstLineOfst( rOldItem.GetTxtFirstLineOfst(),
 334                                              (sal_uInt16)m_pFLineIndent->GetValue() );
 335             else
 336                 aMargin.SetTxtFirstLineOfst(
 337                     (sal_uInt16)GetCoreValue( *m_pFLineIndent, eUnit ) );
 338         }
 339         else
 340         {
 341             aMargin.SetTxtLeft( GetCoreValue( *m_pLeftIndent, eUnit ) );
 342             aMargin.SetRight( GetCoreValue( *m_pRightIndent, eUnit ) );
 343             aMargin.SetTxtFirstLineOfst(
 344                 (sal_uInt16)GetCoreValue( *m_pFLineIndent, eUnit ) );
 345         }
 346         aMargin.SetAutoFirst(m_pAutoCB->IsChecked());
 347         if ( aMargin.GetTxtFirstLineOfst() < 0 )
 348             bNullTab = true;
 349         eState = GetItemSet().GetItemState( nWhich );
 350
 351         if ( !pOld || !( *(const SvxLRSpaceItem*)pOld == aMargin ) ||
 352              SFX_ITEM_DONTCARE == eState )
 353         {
 354             rOutSet.Put( aMargin );
 355             bModified = true;
 356         }
 357     }
 358
 359     if ( bNullTab )
 360     {
 361         MapUnit eUnit = (MapUnit)pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) );
 362         if ( MAP_100TH_MM != eUnit )
 363         {
 364
 365             // negative first line indent -> set null default tabstob if applicable
 366             sal_uInt16 _nWhich = GetWhich( SID_ATTR_TABSTOP );
 367             const SfxItemSet& rInSet = GetItemSet();
 368
 369             if ( rInSet.GetItemState( _nWhich ) >= SFX_ITEM_AVAILABLE )
 370             {
 371                 const SvxTabStopItem& rTabItem =
 372                     (const SvxTabStopItem&)rInSet.Get( _nWhich );
 373                 SvxTabStopItem aNullTab( rTabItem );
 374                 SvxTabStop aNull( 0, SVX_TAB_ADJUST_DEFAULT );
 375                 aNullTab.Insert( aNull );
 376                 rOutSet.Put( aNullTab );
 377             }
 378         }
 379     }
 380     if( m_pRegisterCB->IsVisible())
 381     {
 382         const SfxBoolItem* pBoolItem = (SfxBoolItem*)GetOldItem(
 383                             rOutSet, SID_ATTR_PARA_REGISTER);
 384         if (!pBoolItem)
 385             return bModified;
 386         SfxBoolItem* pRegItem = (SfxBoolItem*)pBoolItem->Clone();
 387         sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
 388         bool bSet = pRegItem->GetValue();
 389
 390         if(m_pRegisterCB->IsChecked() != bSet )
 391         {
 392             pRegItem->SetValue(!bSet);
 393             rOutSet.Put(*pRegItem);
 394             bModified = true;
 395         }
 396         else if ( SFX_ITEM_DEFAULT == GetItemSet().GetItemState( _nWhich, false ) )
 397             rOutSet.ClearItem(_nWhich);
 398         delete pRegItem;
 399     }
 400
 401     return bModified;
 402 }
 403
 404 void SvxStdParagraphTabPage::Reset( const SfxItemSet& rSet )
 405 {
 406     SfxItemPool* pPool = rSet.GetPool();
 407     DBG_ASSERT( pPool, "Wo ist der Pool?" );
 408
 409     // adjust metric
 410     FieldUnit eFUnit = GetModuleFieldUnit( rSet );
 411
 412     bool bApplyCharUnit = GetApplyCharUnit( rSet );
 413
 414     SvtCJKOptions aCJKOptions;
 415     if(aCJKOptions.IsAsianTypographyEnabled() && bApplyCharUnit )
 416         eFUnit = FUNIT_CHAR;
 417
 418     SetFieldUnit( *m_pLeftIndent, eFUnit );
 419     SetFieldUnit( *m_pRightIndent, eFUnit );
 420     SetFieldUnit( *m_pFLineIndent, eFUnit );
 421     if ( eFUnit == FUNIT_CHAR )
 422     {
 423         SetFieldUnit( *m_pTopDist, FUNIT_LINE );
 424         SetFieldUnit( *m_pBottomDist, FUNIT_LINE );
 425         SetFieldUnit( *m_pLineDistAtMetricBox, FUNIT_POINT );
 426     }
 427     else
 428     {
 429         SetFieldUnit( *m_pTopDist, eFUnit );
 430         SetFieldUnit( *m_pBottomDist, eFUnit );
 431         SetFieldUnit( *m_pLineDistAtMetricBox, eFUnit );
 432     }
 433
 434     sal_uInt16 _nWhich = GetWhich( SID_ATTR_LRSPACE );
 435     SfxItemState eItemState = rSet.GetItemState( _nWhich );
 436
 437     if ( eItemState >= SFX_ITEM_AVAILABLE )
 438     {
 439         SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
 440
 441         if ( bRelativeMode )
 442         {
 443             const SvxLRSpaceItem& rOldItem =
 444                 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
 445
 446             if ( rOldItem.GetPropLeft() != 100 )
 447             {
 448                 m_pLeftIndent->SetRelative( true );
 449                 m_pLeftIndent->SetValue( rOldItem.GetPropLeft() );
 450             }
 451             else
 452             {
 453                 m_pLeftIndent->SetRelative();
 454                 SetFieldUnit( *m_pLeftIndent, eFUnit );
 455                 SetMetricValue( *m_pLeftIndent, rOldItem.GetTxtLeft(), eUnit );
 456             }
 457
 458             if ( rOldItem.GetPropRight() != 100 )
 459             {
 460                 m_pRightIndent->SetRelative( true );
 461                 m_pRightIndent->SetValue( rOldItem.GetPropRight() );
 462             }
 463             else
 464             {
 465                 m_pRightIndent->SetRelative();
 466                 SetFieldUnit( *m_pRightIndent, eFUnit );
 467                 SetMetricValue( *m_pRightIndent, rOldItem.GetRight(), eUnit );
 468             }
 469
 470             if ( rOldItem.GetPropTxtFirstLineOfst() != 100 )
 471             {
 472                 m_pFLineIndent->SetRelative( true );
 473                 m_pFLineIndent->SetValue( rOldItem.GetPropTxtFirstLineOfst() );
 474             }
 475             else
 476             {
 477                 m_pFLineIndent->SetRelative();
 478                 m_pFLineIndent->SetMin(-9999);
 479                 SetFieldUnit( *m_pFLineIndent, eFUnit );
 480                 SetMetricValue( *m_pFLineIndent, rOldItem.GetTxtFirstLineOfst(),
 481                                 eUnit );
 482             }
 483             m_pAutoCB->Check(rOldItem.IsAutoFirst());
 484         }
 485         else
 486         {
 487             const SvxLRSpaceItem& rSpace =
 488                 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
 489
 490             SetMetricValue( *m_pLeftIndent, rSpace.GetTxtLeft(), eUnit );
 491             SetMetricValue( *m_pRightIndent, rSpace.GetRight(), eUnit );
 492             SetMetricValue( *m_pFLineIndent, rSpace.GetTxtFirstLineOfst(), eUnit );
 493             m_pAutoCB->Check(rSpace.IsAutoFirst());
 494         }
 495         AutoHdl_Impl(m_pAutoCB);
 496     }
 497     else
 498     {
 499         m_pLeftIndent->SetEmptyFieldValue();
 500         m_pRightIndent->SetEmptyFieldValue();
 501         m_pFLineIndent->SetEmptyFieldValue();
 502     }
 503
 504     _nWhich = GetWhich( SID_ATTR_ULSPACE );
 505     eItemState = rSet.GetItemState( _nWhich );
 506
 507     if ( eItemState >= SFX_ITEM_AVAILABLE )
 508     {
 509         SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
 510
 511         const SvxULSpaceItem& rOldItem =
 512             (const SvxULSpaceItem&)rSet.Get( _nWhich );
 513         if ( bRelativeMode )
 514         {
 515
 516             if ( rOldItem.GetPropUpper() != 100 )
 517             {
 518                 m_pTopDist->SetRelative( true );
 519                 m_pTopDist->SetValue( rOldItem.GetPropUpper() );
 520             }
 521             else
 522             {
 523                 m_pTopDist->SetRelative();
 524                 if ( eFUnit == FUNIT_CHAR )
 525                     SetFieldUnit( *m_pTopDist, FUNIT_LINE );
 526                 else
 527                     SetFieldUnit( *m_pTopDist, eFUnit );
 528                 SetMetricValue( *m_pTopDist, rOldItem.GetUpper(), eUnit );
 529             }
 530
 531             if ( rOldItem.GetPropLower() != 100 )
 532             {
 533                 m_pBottomDist->SetRelative( true );
 534                 m_pBottomDist->SetValue( rOldItem.GetPropLower() );
 535             }
 536             else
 537             {
 538                 m_pBottomDist->SetRelative();
 539                 if ( eFUnit == FUNIT_CHAR )
 540                     SetFieldUnit( *m_pBottomDist, FUNIT_LINE );
 541                 else
 542                     SetFieldUnit( *m_pBottomDist, eFUnit );
 543                 SetMetricValue( *m_pBottomDist, rOldItem.GetLower(), eUnit );
 544             }
 545         }
 546         else
 547         {
 548             SetMetricValue( *m_pTopDist, rOldItem.GetUpper(), eUnit );
 549             SetMetricValue( *m_pBottomDist, rOldItem.GetLower(), eUnit );
 550         }
 551         m_pContextualCB->Check(rOldItem.GetContext());
 552     }
 553     else
 554     {
 555         m_pTopDist->SetEmptyFieldValue();
 556         m_pBottomDist->SetEmptyFieldValue();
 557     }
 558
 559     _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
 560     eItemState = rSet.GetItemState( _nWhich );
 561
 562     if ( eItemState >= SFX_ITEM_AVAILABLE )
 563         SetLineSpacing_Impl( (const SvxLineSpacingItem &)rSet.Get( _nWhich ) );
 564     else
 565         m_pLineDist->SetNoSelection();
 566
 567     _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
 568     eItemState = rSet.GetItemState( _nWhich );
 569
 570     if ( eItemState >= SFX_ITEM_AVAILABLE )
 571         m_pRegisterCB->Check( ((const SfxBoolItem &)rSet.Get( _nWhich )).GetValue());
 572     m_pRegisterCB->SaveValue();
 573     sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
 574     if(nHtmlMode & HTMLMODE_ON)
 575     {
 576         m_pRegisterFL->Hide();
 577         m_pRegisterCB->Hide();
 578         m_pAutoCB->Hide();
 579
 580         if(!(nHtmlMode & HTMLMODE_SOME_STYLES)) // IE or SW
 581         {
 582             m_pRightLabel->Disable();
 583             m_pRightIndent->Disable();
 584             m_pTopDist->Disable();  //HTML3.2 and NS 3.0
 585             m_pBottomDist->Disable();
 586             m_pFLineIndent->Disable();
 587             m_pFLineLabel->Disable();
 588         }
 589     }
 590
 591     // this sets the min/max limits; do this _after_ setting the values,
 592     // because for Impress the min of first-line indent depends on value of
 593     // left-indent!
 594     ELRLoseFocusHdl( NULL );
 595     m_pAutoCB->SaveValue();
 596     m_pContextualCB->SaveValue();
 597     m_pLineDist->SaveValue();
 598 }
 599
 600 void SvxStdParagraphTabPage::EnableRelativeMode()
 601 {
 602     DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" );
 603
 604     m_pLeftIndent->EnableRelativeMode( 0, 999 );
 605     m_pFLineIndent->EnableRelativeMode( 0, 999 );
 606     m_pRightIndent->EnableRelativeMode( 0, 999 );
 607     m_pTopDist->EnableRelativeMode( 0, 999 );
 608     m_pBottomDist->EnableRelativeMode( 0, 999 );
 609     bRelativeMode = true;
 610 }
 611
 612 int SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
 613 {
 614     ELRLoseFocusHdl( NULL );
 615
 616     if ( _pSet )
 617         FillItemSet( *_pSet );
 618     return LEAVE_PAGE;
 619 }
 620
 621 SvxStdParagraphTabPage::SvxStdParagraphTabPage( Window* pParent,  const SfxItemSet& rAttr ) :
 622     SfxTabPage( pParent, "ParaIndentSpacing","cui/ui/paraindentspacing.ui", rAttr ),
 623
 624     nAbst           ( MAX_DURCH ),
 625     nWidth          ( 11905 /*567 * 50*/ ),
 626     nMinFixDist(0L),
 627
 628     bRelativeMode   ( false ),
 629     bNegativeIndents(false)
 630
 631 {
 632     get(m_pLeftIndent,"spinED_LEFTINDENT");
 633     get(m_pRightIndent,"spinED_RIGHTINDENT");
 634     get(m_pRightLabel,"labelFT_RIGHTINDENT");
 635     get(m_pFLineLabel,"labelFT_FLINEINDENT");
 636     get(m_pFLineIndent,"spinED_FLINEINDENT");
 637     get(m_pAutoCB,"checkCB_AUTO");
 638
 639     get(m_pTopDist,"spinED_TOPDIST");
 640     get(m_pBottomDist,"spinED_BOTTOMDIST");
 641     get(m_pContextualCB,"checkCB_CONTEXTUALSPACING");
 642
 643     get(m_pLineDist,"comboLB_LINEDIST");
 644     get(m_pLineDistAtPercentBox,"spinED_LINEDISTPERCENT");
 645     get(m_pLineDistAtMetricBox,"spinED_LINEDISTMETRIC");
 646     get(m_pLineDistAtLabel,"labelFT_LINEDIST");
 647
 648     get(m_pAbsDist,"labelST_LINEDIST_ABS");
 649     sAbsDist = m_pAbsDist->GetText();
 650
 651     get(m_pRegisterFL,"frameFL_REGISTER");
 652     get(m_pRegisterCB,"checkCB_REGISTER");
 653
 654     get(m_pExampleWin,"drawingareaWN_EXAMPLE");
 655
 656     // this page needs ExchangeSupport
 657     SetExchangeSupport();
 658
 659     m_pLineDistAtMetricBox->Hide();
 660
 661     Init_Impl();
 662     m_pFLineIndent->SetMin(-9999);    // is set to 0 on default
 663
 664     setPreviewsToSamePlace(pParent, this);
 665 }
 666
 667 SvxStdParagraphTabPage::~SvxStdParagraphTabPage()
 668 {
 669 }
 670
 671 void SvxStdParagraphTabPage::EnableNegativeMode()
 672 {
 673     m_pLeftIndent->SetMin(-9999);
 674     m_pRightIndent->SetMin(-9999);
 675     m_pRightIndent->EnableNegativeMode();
 676     m_pLeftIndent->EnableNegativeMode();
 677     bNegativeIndents = true;
 678 }
 679
 680 const sal_uInt16* SvxStdParagraphTabPage::GetRanges()
 681 {
 682     return pStdRanges;
 683 }
 684
 685 void SvxStdParagraphTabPage::SetLineSpacing_Impl
 686 (
 687     const SvxLineSpacingItem &rAttr
 688 )
 689 {
 690     SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );
 691
 692     switch( rAttr.GetLineSpaceRule() )
 693     {
 694         case SVX_LINE_SPACE_AUTO:
 695         {
 696             SvxInterLineSpace eInter = rAttr.GetInterLineSpaceRule();
 697
 698             switch( eInter )
 699             {
 700                 // Default single line spacing
 701                 case SVX_INTER_LINE_SPACE_OFF:
 702                     m_pLineDist->SelectEntryPos( LLINESPACE_1 );
 703                     break;
 704
 705                 // Default single line spacing
 706                 case SVX_INTER_LINE_SPACE_PROP:
 707                     if ( 100 == rAttr.GetPropLineSpace() )
 708                     {
 709                         m_pLineDist->SelectEntryPos( LLINESPACE_1 );
 710                         break;
 711                     }
 712                     // 1.5 line spacing
 713                     if ( 150 == rAttr.GetPropLineSpace() )
 714                     {
 715                         m_pLineDist->SelectEntryPos( LLINESPACE_15 );
 716                         break;
 717                     }
 718                     // double line spacing
 719                     if ( 200 == rAttr.GetPropLineSpace() )
 720                     {
 721                         m_pLineDist->SelectEntryPos( LLINESPACE_2 );
 722                         break;
 723                     }
 724                     // the set per cent value
 725                     m_pLineDistAtPercentBox->SetValue( m_pLineDistAtPercentBox->Normalize(rAttr.GetPropLineSpace() ) );
 726                     m_pLineDist->SelectEntryPos( LLINESPACE_PROP );
 727                     break;
 728
 729                 case SVX_INTER_LINE_SPACE_FIX:
 730                     SetMetricValue( *m_pLineDistAtMetricBox, rAttr.GetInterLineSpace(), eUnit );
 731                     m_pLineDist->SelectEntryPos( LLINESPACE_DURCH );
 732                     break;
 733                 default: ;//prevent warning
 734             }
 735         }
 736         break;
 737         case SVX_LINE_SPACE_FIX:
 738             SetMetricValue(*m_pLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
 739             m_pLineDist->SelectEntryPos( LLINESPACE_FIX );
 740         break;
 741
 742         case SVX_LINE_SPACE_MIN:
 743             SetMetricValue(*m_pLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
 744             m_pLineDist->SelectEntryPos( LLINESPACE_MIN );
 745             break;
 746         default: ;//prevent warning
 747     }
 748     LineDistHdl_Impl( m_pLineDist );
 749 }
 750
 751 IMPL_LINK( SvxStdParagraphTabPage, LineDistHdl_Impl, ListBox *, pBox )
 752 {
 753     switch( pBox->GetSelectEntryPos() )
 754     {
 755         case LLINESPACE_1:
 756         case LLINESPACE_15:
 757         case LLINESPACE_2:
 758             m_pLineDistAtLabel->Enable(false);
 759             m_pLineDistAtPercentBox->Enable(false);
 760             m_pLineDistAtPercentBox->SetText( OUString() );
 761             m_pLineDistAtMetricBox->Enable(false);
 762             m_pLineDistAtMetricBox->SetText( OUString() );
 763             break;
 764
 765         case LLINESPACE_DURCH:
 766             // setting a sensible default?
 767             // limit MS min(10, aPageSize)
 768             m_pLineDistAtMetricBox->SetMin(0);
 769
 770             if ( m_pLineDistAtMetricBox->GetText().isEmpty() )
 771                 m_pLineDistAtMetricBox->SetValue( m_pLineDistAtMetricBox->Normalize( 1 ) );
 772             m_pLineDistAtPercentBox->Hide();
 773             m_pLineDistAtMetricBox->Show();
 774             m_pLineDistAtMetricBox->Enable();
 775             m_pLineDistAtLabel->Enable();
 776             break;
 777
 778         case LLINESPACE_MIN:
 779             m_pLineDistAtMetricBox->SetMin(0);
 780
 781             if ( m_pLineDistAtMetricBox->GetText().isEmpty() )
 782                 m_pLineDistAtMetricBox->SetValue( m_pLineDistAtMetricBox->Normalize( 10 ), FUNIT_TWIP );
 783             m_pLineDistAtPercentBox->Hide();
 784             m_pLineDistAtMetricBox->Show();
 785             m_pLineDistAtMetricBox->Enable();
 786             m_pLineDistAtLabel->Enable();
 787             break;
 788
 789         case LLINESPACE_PROP:
 790
 791             if ( m_pLineDistAtPercentBox->GetText().isEmpty() )
 792                 m_pLineDistAtPercentBox->SetValue( m_pLineDistAtPercentBox->Normalize( 100 ), FUNIT_TWIP );
 793             m_pLineDistAtMetricBox->Hide();
 794             m_pLineDistAtPercentBox->Show();
 795             m_pLineDistAtPercentBox->Enable();
 796             m_pLineDistAtLabel->Enable();
 797             break;
 798         case LLINESPACE_FIX:
 799         {
 800             sal_Int64 nTemp = m_pLineDistAtMetricBox->GetValue();
 801             m_pLineDistAtMetricBox->SetMin(m_pLineDistAtMetricBox->Normalize(nMinFixDist), FUNIT_TWIP);
 802
 803             // if the value has been changed at SetMin,
 804             // it is time for the default
 805             if ( m_pLineDistAtMetricBox->GetValue() != nTemp )
 806                 SetMetricValue( *m_pLineDistAtMetricBox, FIX_DIST_DEF, SFX_MAPUNIT_TWIP ); // fix is only in Writer
 807             m_pLineDistAtPercentBox->Hide();
 808             m_pLineDistAtMetricBox->Show();
 809             m_pLineDistAtMetricBox->Enable();
 810             m_pLineDistAtLabel->Enable();
 811         }
 812         break;
 813     }
 814     UpdateExample_Impl( true );
 815     return 0;
 816 }
 817
 818 IMPL_LINK_NOARG_INLINE_START(SvxStdParagraphTabPage, ModifyHdl_Impl)
 819 {
 820     UpdateExample_Impl();
 821     return 0;
 822 }
 823 IMPL_LINK_NOARG_INLINE_END(SvxStdParagraphTabPage, ModifyHdl_Impl)
 824
 825 void SvxStdParagraphTabPage::Init_Impl()
 826 {
 827     m_pLineDist->SetSelectHdl(
 828         LINK( this, SvxStdParagraphTabPage, LineDistHdl_Impl ) );
 829
 830     Link aLink = LINK( this, SvxStdParagraphTabPage, ELRLoseFocusHdl );
 831     m_pFLineIndent->SetLoseFocusHdl( aLink );
 832     m_pLeftIndent->SetLoseFocusHdl( aLink );
 833     m_pRightIndent->SetLoseFocusHdl( aLink );
 834
 835     aLink = LINK( this, SvxStdParagraphTabPage, ModifyHdl_Impl );
 836     m_pFLineIndent->SetModifyHdl( aLink );
 837     m_pLeftIndent->SetModifyHdl( aLink );
 838     m_pRightIndent->SetModifyHdl( aLink );
 839     m_pTopDist->SetModifyHdl( aLink );
 840     m_pBottomDist->SetModifyHdl( aLink );
 841
 842     m_pAutoCB->SetClickHdl( LINK( this, SvxStdParagraphTabPage, AutoHdl_Impl ));
 843     SfxItemPool* pPool = GetItemSet().GetPool();
 844     DBG_ASSERT( pPool, "Wo ist der Pool" );
 845     FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
 846
 847     m_pTopDist->SetMax( m_pTopDist->Normalize( nAbst ), eUnit );
 848     m_pBottomDist->SetMax( m_pBottomDist->Normalize( nAbst ), eUnit );
 849     m_pLineDistAtMetricBox->SetMax( m_pLineDistAtMetricBox->Normalize( nAbst ), eUnit );
 850 }
 851
 852 void SvxStdParagraphTabPage::UpdateExample_Impl( bool bAll )
 853 {
 854     m_pExampleWin->SetFirstLineOfst( (short)m_pFLineIndent->Denormalize( m_pFLineIndent->GetValue( FUNIT_TWIP ) ) );
 855     m_pExampleWin->SetLeftMargin( static_cast<long>(m_pLeftIndent->Denormalize( m_pLeftIndent->GetValue( FUNIT_TWIP ) ) ) );
 856     m_pExampleWin->SetRightMargin( static_cast<long>(m_pRightIndent->Denormalize( m_pRightIndent->GetValue( FUNIT_TWIP ) ) ) );
 857     m_pExampleWin->SetUpper( (sal_uInt16)m_pTopDist->Denormalize( m_pTopDist->GetValue( FUNIT_TWIP ) ) );
 858     m_pExampleWin->SetLower( (sal_uInt16)m_pBottomDist->Denormalize( m_pBottomDist->GetValue( FUNIT_TWIP ) ) );
 859
 860     sal_Int32 nPos = m_pLineDist->GetSelectEntryPos();
 861
 862     switch ( nPos )
 863     {
 864         case LLINESPACE_1:
 865         case LLINESPACE_15:
 866         case LLINESPACE_2:
 867             m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos );
 868             break;
 869
 870         case LLINESPACE_PROP:
 871             m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos,
 872                 (sal_uInt16)m_pLineDistAtPercentBox->Denormalize( m_pLineDistAtPercentBox->GetValue() ) );
 873             break;
 874
 875         case LLINESPACE_MIN:
 876         case LLINESPACE_DURCH:
 877         case LLINESPACE_FIX:
 878             m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos,
 879                 (sal_uInt16)GetCoreValue( *m_pLineDistAtMetricBox, SFX_MAPUNIT_TWIP ) );
 880             break;
 881     }
 882     m_pExampleWin->Draw( bAll );
 883 }
 884
 885 void SvxStdParagraphTabPage::EnableRegisterMode()
 886 {
 887     m_pRegisterCB->Show();
 888     m_pRegisterFL->Show();
 889 }
 890
 891 void SvxStdParagraphTabPage::EnableContextualMode()
 892 {
 893     m_pContextualCB->Show();
 894 }
 895
 896 IMPL_LINK( SvxStdParagraphTabPage, AutoHdl_Impl, CheckBox*, pBox )
 897 {
 898     bool bEnable = !pBox->IsChecked();
 899     m_pFLineLabel->Enable(bEnable);
 900     m_pFLineIndent->Enable(bEnable);
 901     return 0;
 902 }
 903
 904 void SvxStdParagraphTabPage::SetPageWidth( sal_uInt16 nPageWidth )
 905 {
 906     nWidth = nPageWidth;
 907 }
 908
 909 void SvxStdParagraphTabPage::EnableAutoFirstLine()
 910 {
 911     m_pAutoCB->Show();
 912 }
 913
 914 void    SvxStdParagraphTabPage::EnableAbsLineDist(long nMinTwip)
 915 {
 916     m_pLineDist->InsertEntry(sAbsDist);
 917     nMinFixDist = nMinTwip;
 918 }
 919
 920 void    SvxStdParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
 921 {
 922
 923 /* different bit represent call to different method of SvxStdParagraphTabPage
 924                         0x0001 --->EnableRelativeMode()
 925                         0x0002 --->EnableRegisterMode()
 926                         0x0004 --->EnableAutoFirstLine()
 927                         0x0008 --->EnableNegativeMode()
 928                         0x0010 --->EnableContextualMode()
 929             */
 930     SFX_ITEMSET_ARG (&aSet,pPageWidthItem,SfxUInt16Item,SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH,false);
 931     SFX_ITEMSET_ARG (&aSet,pFlagSetItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET,false);
 932     SFX_ITEMSET_ARG (&aSet,pLineDistItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST,false);
 933
 934     if (pPageWidthItem)
 935         SetPageWidth(pPageWidthItem->GetValue());
 936
 937     if (pFlagSetItem )
 938         if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
 939             EnableRelativeMode();
 940
 941     if (pFlagSetItem)
 942         if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
 943                 EnableRegisterMode();
 944
 945     if (pFlagSetItem)
 946         if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
 947             EnableAutoFirstLine();
 948
 949     if(pLineDistItem)
 950         EnableAbsLineDist(pLineDistItem->GetValue());
 951
 952     if (pFlagSetItem)
 953         if  (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
 954                 EnableNegativeMode();
 955
 956     if (pFlagSetItem)
 957         if  (( 0x0010 & pFlagSetItem->GetValue()) == 0x0010 )
 958                 EnableContextualMode();
 959 }
 960
 961 #define LASTLINEPOS_DEFAULT     0
 962 #define LASTLINEPOS_LEFT        1
 963
 964 #define LASTLINECOUNT_OLD       3
 965 #define LASTLINECOUNT_NEW       4
 966
 967 SvxParaAlignTabPage::SvxParaAlignTabPage( Window* pParent, const SfxItemSet& rSet )
 968
 969     : SfxTabPage(pParent, "ParaAlignPage", "cui/ui/paragalignpage.ui",rSet)
 970 {
 971     get(m_pLeft,"radioBTN_LEFTALIGN");
 972     get(m_pRight,"radioBTN_RIGHTALIGN");
 973     get(m_pCenter,"radioBTN_CENTERALIGN");
 974     get(m_pJustify,"radioBTN_JUSTIFYALIGN");
 975     get(m_pLeftBottom,"labelST_LEFTALIGN_ASIAN");
 976     get(m_pRightTop,"labelST_RIGHTALIGN_ASIAN");
 977
 978     get(m_pLastLineFT,"labelLB_LASTLINE");
 979     get(m_pLastLineLB,"comboLB_LASTLINE");
 980     get(m_pExpandCB,"checkCB_EXPAND");
 981     get(m_pSnapToGridCB,"checkCB_SNAP");
 982     get(m_pExampleWin,"drawingareaWN_EXAMPLE");
 983
 984     get(m_pVertAlignLB,"comboLB_VERTALIGN");
 985     get(m_pVertAlignFL,"frameFL_VERTALIGN");
 986
 987     get(m_pPropertiesFL,"framePROPERTIES");
 988     get(m_pTextDirectionLB,"comboLB_TEXTDIRECTION");
 989
 990     SvtLanguageOptions aLangOptions;
 991     sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT;
 992
 993     if ( aLangOptions.IsAsianTypographyEnabled() )
 994     {
 995         m_pLeft->SetText(m_pLeftBottom->GetText());
 996         m_pRight->SetText(m_pRightTop->GetText());
 997
 998         OUString sLeft(m_pLeft->GetText());
 999         sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );
1000
1001         if ( m_pLastLineLB->GetEntryCount() == LASTLINECOUNT_OLD )
1002         {
1003             m_pLastLineLB->RemoveEntry( 0 );
1004             m_pLastLineLB->InsertEntry( sLeft, 0 );
1005         }
1006         else
1007             nLastLinePos = LASTLINEPOS_LEFT;
1008     }
1009
1010     // remove "Default" or "Left" entry, depends on CJKOptions
1011     if ( m_pLastLineLB->GetEntryCount() == LASTLINECOUNT_NEW )
1012         m_pLastLineLB->RemoveEntry( nLastLinePos );
1013
1014     Link aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
1015     m_pLeft->SetClickHdl( aLink );
1016     m_pRight->SetClickHdl( aLink );
1017     m_pCenter->SetClickHdl( aLink );
1018     m_pJustify->SetClickHdl( aLink );
1019     m_pLastLineLB->SetSelectHdl( LINK( this, SvxParaAlignTabPage, LastLineHdl_Impl ) );
1020     m_pTextDirectionLB->SetSelectHdl( LINK( this, SvxParaAlignTabPage, TextDirectionHdl_Impl ) );
1021
1022     sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
1023     if(!(nHtmlMode & HTMLMODE_ON) || (0 != (nHtmlMode & HTMLMODE_SOME_STYLES)) )
1024     {
1025         if( aLangOptions.IsCTLFontEnabled() )
1026         {
1027             m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_LTR ), FRMDIR_HORI_LEFT_TOP );
1028             m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_RTL ), FRMDIR_HORI_RIGHT_TOP );
1029             m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_SUPER ), FRMDIR_ENVIRONMENT );
1030
1031             m_pPropertiesFL->Show();
1032         }
1033     }
1034
1035     setPreviewsToSamePlace(pParent, this);
1036 }
1037
1038 SvxParaAlignTabPage::~SvxParaAlignTabPage()
1039 {
1040 }
1041
1042 int SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
1043 {
1044     if ( _pSet )
1045         FillItemSet( *_pSet );
1046     return LEAVE_PAGE;
1047 }
1048
1049 SfxTabPage* SvxParaAlignTabPage::Create( Window* pParent, const SfxItemSet& rSet )
1050 {
1051     return new SvxParaAlignTabPage(pParent, rSet);
1052 }
1053
1054 const sal_uInt16* SvxParaAlignTabPage::GetRanges()
1055 {
1056     return pAlignRanges;
1057 }
1058
1059 bool SvxParaAlignTabPage::FillItemSet( SfxItemSet& rOutSet )
1060 {
1061     bool bModified = false;
1062
1063     bool bAdj = false, bChecked = false;
1064     SvxAdjust eAdjust = SVX_ADJUST_LEFT;
1065
1066     if ( m_pLeft->IsChecked() )
1067     {
1068         eAdjust = SVX_ADJUST_LEFT;
1069         bAdj = !m_pLeft->GetSavedValue();
1070         bChecked = true;
1071     }
1072     else if ( m_pRight->IsChecked() )
1073     {
1074         eAdjust = SVX_ADJUST_RIGHT;
1075         bAdj = !m_pRight->GetSavedValue();
1076         bChecked = true;
1077     }
1078     else if ( m_pCenter->IsChecked() )
1079     {
1080         eAdjust = SVX_ADJUST_CENTER;
1081         bAdj = !m_pCenter->GetSavedValue();
1082         bChecked = true;
1083     }
1084     else if ( m_pJustify->IsChecked() )
1085     {
1086         eAdjust = SVX_ADJUST_BLOCK;
1087         bAdj = !m_pJustify->GetSavedValue() ||
1088             m_pExpandCB->IsValueChangedFromSaved() ||
1089             m_pLastLineLB->IsValueChangedFromSaved();
1090         bChecked = true;
1091     }
1092     sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1093
1094     if ( bAdj )
1095     {
1096         const SvxAdjustItem* pOld = (const SvxAdjustItem*)GetOldItem( rOutSet, SID_ATTR_PARA_ADJUST );
1097
1098         SvxAdjust eOneWord = m_pExpandCB->IsChecked() ? SVX_ADJUST_BLOCK : SVX_ADJUST_LEFT;
1099
1100         sal_Int32 nLBPos = m_pLastLineLB->GetSelectEntryPos();
1101         SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1102
1103         if ( 1 == nLBPos )
1104             eLastBlock = SVX_ADJUST_CENTER;
1105         else if ( 2 == nLBPos )
1106             eLastBlock = SVX_ADJUST_BLOCK;
1107
1108         bool bNothingWasChecked =
1109             !m_pLeft->GetSavedValue() && !m_pRight->GetSavedValue() &&
1110             !m_pCenter->GetSavedValue() && !m_pJustify->GetSavedValue();
1111
1112         if ( !pOld || pOld->GetAdjust() != eAdjust ||
1113              pOld->GetOneWord() != eOneWord ||
1114              pOld->GetLastBlock() != eLastBlock ||
1115              ( bChecked && bNothingWasChecked ) )
1116         {
1117             bModified = true;
1118             SvxAdjustItem aAdj(
1119                 (const SvxAdjustItem&)GetItemSet().Get( _nWhich ) );
1120             aAdj.SetAdjust( eAdjust );
1121             aAdj.SetOneWord( eOneWord );
1122             aAdj.SetLastBlock( eLastBlock );
1123             rOutSet.Put( aAdj );
1124         }
1125     }
1126     if(m_pSnapToGridCB->IsValueChangedFromSaved())
1127     {
1128         rOutSet.Put(SvxParaGridItem(m_pSnapToGridCB->IsChecked(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
1129         bModified = true;
1130     }
1131     if(m_pVertAlignLB->IsValueChangedFromSaved())
1132     {
1133         rOutSet.Put(SvxParaVertAlignItem(m_pVertAlignLB->GetSelectEntryPos(), GetWhich( SID_PARA_VERTALIGN )));
1134         bModified = true;
1135     }
1136
1137     if( m_pTextDirectionLB->IsVisible() )
1138     {
1139         SvxFrameDirection eDir = m_pTextDirectionLB->GetSelectEntryValue();
1140         if( m_pTextDirectionLB->IsValueChangedFromSaved() )
1141         {
1142             rOutSet.Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
1143             bModified = true;
1144         }
1145     }
1146
1147     return bModified;
1148 }
1149
1150 void SvxParaAlignTabPage::Reset( const SfxItemSet& rSet )
1151 {
1152     sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1153     SfxItemState eItemState = rSet.GetItemState( _nWhich );
1154
1155     sal_Int32 nLBSelect = 0;
1156     if ( eItemState >= SFX_ITEM_AVAILABLE )
1157     {
1158         const SvxAdjustItem& rAdj = (const SvxAdjustItem&)rSet.Get( _nWhich );
1159
1160         switch ( rAdj.GetAdjust() /*!!! ask VB rAdj.GetLastBlock()*/ )
1161         {
1162             case SVX_ADJUST_LEFT: m_pLeft->Check(); break;
1163
1164             case SVX_ADJUST_RIGHT: m_pRight->Check(); break;
1165
1166             case SVX_ADJUST_CENTER: m_pCenter->Check(); break;
1167
1168             case SVX_ADJUST_BLOCK: m_pJustify->Check(); break;
1169             default: ; //prevent warning
1170         }
1171         bool bEnable = m_pJustify->IsChecked();
1172         m_pLastLineFT->Enable(bEnable);
1173         m_pLastLineLB->Enable(bEnable);
1174         m_pExpandCB->Enable(bEnable);
1175
1176         m_pExpandCB->Check(SVX_ADJUST_BLOCK == rAdj.GetOneWord());
1177         switch(rAdj.GetLastBlock())
1178         {
1179             case SVX_ADJUST_LEFT:  nLBSelect = 0; break;
1180
1181             case SVX_ADJUST_CENTER: nLBSelect = 1;  break;
1182
1183             case SVX_ADJUST_BLOCK: nLBSelect = 2;  break;
1184             default: ; //prevent warning
1185         }
1186     }
1187     else
1188     {
1189         m_pLeft->Check( false );
1190         m_pRight->Check( false );
1191         m_pCenter->Check( false );
1192         m_pJustify->Check( false );
1193     }
1194     m_pLastLineLB->SelectEntryPos(nLBSelect);
1195
1196     sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
1197     if(nHtmlMode & HTMLMODE_ON)
1198     {
1199         m_pLastLineLB->Hide();
1200         m_pLastLineFT->Hide();
1201         m_pExpandCB->Hide();
1202         if(!(nHtmlMode & HTMLMODE_FULL_STYLES) )
1203             m_pJustify->Disable();
1204         m_pSnapToGridCB->Show(false);
1205     }
1206     _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
1207     eItemState = rSet.GetItemState( _nWhich );
1208     if ( eItemState >= SFX_ITEM_AVAILABLE )
1209     {
1210         const SvxParaGridItem& rSnap = (const SvxParaGridItem&)rSet.Get( _nWhich );
1211         m_pSnapToGridCB->Check(rSnap.GetValue());
1212     }
1213
1214     _nWhich = GetWhich( SID_PARA_VERTALIGN );
1215     eItemState = rSet.GetItemState( _nWhich );
1216
1217     if ( eItemState >= SFX_ITEM_AVAILABLE )
1218     {
1219         m_pVertAlignFL->Show();
1220
1221         const SvxParaVertAlignItem& rAlign = (const SvxParaVertAlignItem&)rSet.Get( _nWhich );
1222
1223         m_pVertAlignLB->SelectEntryPos(rAlign.GetValue());
1224     }
1225
1226     _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
1227     //text direction
1228     if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( _nWhich ) )
1229     {
1230         const SvxFrameDirectionItem& rFrameDirItem = ( const SvxFrameDirectionItem& ) rSet.Get( _nWhich );
1231         m_pTextDirectionLB->SelectEntryValue( (SvxFrameDirection)rFrameDirItem.GetValue() );
1232         m_pTextDirectionLB->SaveValue();
1233     }
1234
1235     m_pSnapToGridCB->SaveValue();
1236     m_pVertAlignLB->SaveValue();
1237     m_pLeft->SaveValue();
1238     m_pRight->SaveValue();
1239     m_pCenter->SaveValue();
1240     m_pJustify->SaveValue();
1241     m_pLastLineLB->SaveValue();
1242     m_pExpandCB->SaveValue();
1243
1244     UpdateExample_Impl(true);
1245 }
1246
1247 IMPL_LINK_NOARG(SvxParaAlignTabPage, AlignHdl_Impl)
1248 {
1249     bool bJustify = m_pJustify->IsChecked();
1250     m_pLastLineFT->Enable(bJustify);
1251     m_pLastLineLB->Enable(bJustify);
1252     m_pExpandCB->Enable(bJustify);
1253     UpdateExample_Impl(false);
1254     return 0;
1255 }
1256
1257 IMPL_LINK_NOARG(SvxParaAlignTabPage, LastLineHdl_Impl)
1258 {
1259     UpdateExample_Impl(false);
1260     return 0;
1261 }
1262
1263 IMPL_LINK_NOARG(SvxParaAlignTabPage, TextDirectionHdl_Impl)
1264 {
1265     SvxFrameDirection eDir = m_pTextDirectionLB->GetSelectEntryValue();
1266     switch ( eDir )
1267     {
1268         // check the default alignment for this text direction
1269         case FRMDIR_HORI_LEFT_TOP :     m_pLeft->Check( true ); break;
1270         case FRMDIR_HORI_RIGHT_TOP :    m_pRight->Check( true ); break;
1271         case FRMDIR_ENVIRONMENT :       /* do nothing */ break;
1272         default:
1273         {
1274             SAL_WARN( "cui.tabpages", "SvxParaAlignTabPage::TextDirectionHdl_Impl(): other directions not supported" );
1275         }
1276     }
1277
1278     return 0;
1279 }
1280
1281 void SvxParaAlignTabPage::UpdateExample_Impl( bool bAll )
1282 {
1283     if ( m_pLeft->IsChecked() )
1284         m_pExampleWin->SetAdjust( SVX_ADJUST_LEFT );
1285     else if ( m_pRight->IsChecked() )
1286         m_pExampleWin->SetAdjust( SVX_ADJUST_RIGHT );
1287     else if ( m_pCenter->IsChecked() )
1288         m_pExampleWin->SetAdjust( SVX_ADJUST_CENTER );
1289     else if ( m_pJustify->IsChecked() )
1290     {
1291         m_pExampleWin->SetAdjust( SVX_ADJUST_BLOCK );
1292         SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1293         sal_Int32 nLBPos = m_pLastLineLB->GetSelectEntryPos();
1294         if(nLBPos == 1)
1295             eLastBlock = SVX_ADJUST_CENTER;
1296         else if(nLBPos == 2)
1297             eLastBlock = SVX_ADJUST_BLOCK;
1298         m_pExampleWin->SetLastLine( eLastBlock );
1299     }
1300
1301     m_pExampleWin->Draw( bAll );
1302 }
1303
1304 void SvxParaAlignTabPage::EnableJustifyExt()
1305 {
1306     m_pLastLineFT->Show();
1307     m_pLastLineLB->Show();
1308     m_pExpandCB->Show();
1309     SvtLanguageOptions aCJKOptions;
1310     if(aCJKOptions.IsAsianTypographyEnabled())
1311         m_pSnapToGridCB->Show();
1312
1313 }
1314
1315 void SvxParaAlignTabPage::PageCreated (const SfxAllItemSet& aSet)
1316 {
1317     SFX_ITEMSET_ARG (&aSet,pBoolItem,SfxBoolItem,SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT,false);
1318     if (pBoolItem)
1319         if(pBoolItem->GetValue())
1320             EnableJustifyExt();
1321 }
1322
1323 SfxTabPage* SvxExtParagraphTabPage::Create( Window* pParent,
1324                                             const SfxItemSet& rSet )
1325 {
1326     return new SvxExtParagraphTabPage( pParent, rSet );
1327 }
1328
1329 bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
1330 {
1331     bool bModified = false;
1332     sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1333     const TriState eHyphenState = m_pHyphenBox->GetState();
1334     const SfxPoolItem* pOld = GetOldItem( rOutSet, SID_ATTR_PARA_HYPHENZONE );
1335
1336     if ( m_pHyphenBox->IsValueChangedFromSaved()     ||
1337          m_pExtHyphenBeforeBox->IsValueModified()          ||
1338          m_pExtHyphenAfterBox->IsValueModified()           ||
1339          m_pMaxHyphenEdit->IsValueModified() )
1340     {
1341         SvxHyphenZoneItem aHyphen(
1342             (const SvxHyphenZoneItem&)GetItemSet().Get( _nWhich ) );
1343         aHyphen.SetHyphen( eHyphenState == TRISTATE_TRUE );
1344
1345         if ( eHyphenState == TRISTATE_TRUE )
1346         {
1347             aHyphen.GetMinLead() = (sal_uInt8)m_pExtHyphenBeforeBox->GetValue();
1348             aHyphen.GetMinTrail() = (sal_uInt8)m_pExtHyphenAfterBox->GetValue();
1349         }
1350         aHyphen.GetMaxHyphens() = (sal_uInt8)m_pMaxHyphenEdit->GetValue();
1351
1352         if ( !pOld ||
1353             !( *(SvxHyphenZoneItem*)pOld == aHyphen ) ||
1354                 m_pHyphenBox->IsValueChangedFromSaved())
1355         {
1356             rOutSet.Put( aHyphen );
1357             bModified = true;
1358         }
1359     }
1360
1361     if (m_pPagenumEdit->IsEnabled() && m_pPagenumEdit->IsValueModified())
1362     {
1363         SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM,
1364                                 (sal_uInt16)m_pPagenumEdit->GetValue() );
1365
1366         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGENUM );
1367
1368         if ( !pOld || ( (const SfxUInt16Item*)pOld )->GetValue() != aPageNum.GetValue() )
1369         {
1370             rOutSet.Put( aPageNum );
1371             bModified = true;
1372         }
1373     }
1374
1375     // pagebreak
1376
1377     TriState eState = m_pApplyCollBtn->GetState();
1378     bool bIsPageModel = false;
1379
1380     _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1381     OUString sPage;
1382     if ( m_pApplyCollBtn->IsValueChangedFromSaved() ||
1383          ( TRISTATE_TRUE == eState &&
1384            m_pApplyCollBox->IsValueChangedFromSaved() ) )
1385     {
1386         if ( eState == TRISTATE_TRUE )
1387         {
1388             sPage = m_pApplyCollBox->GetSelectEntry();
1389             bIsPageModel = !sPage.isEmpty();
1390         }
1391         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_MODEL );
1392
1393         if ( !pOld || ( (const SvxPageModelItem*)pOld )->GetValue() != sPage )
1394         {
1395             rOutSet.Put( SvxPageModelItem( sPage, false, _nWhich ) );
1396             bModified = true;
1397         }
1398         else
1399             bIsPageModel = false;
1400     }
1401     else if(TRISTATE_TRUE == eState && m_pApplyCollBtn->IsEnabled())
1402         bIsPageModel = true;
1403     else
1404         rOutSet.Put( SvxPageModelItem( sPage, false, _nWhich ) );
1405
1406     _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1407
1408     if ( bIsPageModel )
1409         // if PageModel is turned on, always turn off PageBreak
1410         rOutSet.Put( SvxFmtBreakItem( SVX_BREAK_NONE, _nWhich ) );
1411     else
1412     {
1413         eState = m_pPageBreakBox->GetState();
1414         SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, false);
1415
1416         if ( (eModelState == SFX_ITEM_SET && TRISTATE_TRUE == m_pPageBreakBox->GetState()) ||
1417              m_pPageBreakBox->IsValueChangedFromSaved()                ||
1418              m_pBreakTypeLB->IsValueChangedFromSaved()   ||
1419              m_pBreakPositionLB->IsValueChangedFromSaved() )
1420         {
1421             const SvxFmtBreakItem rOldBreak(
1422                     (const SvxFmtBreakItem&)GetItemSet().Get( _nWhich ));
1423             SvxFmtBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());
1424
1425             switch ( eState )
1426             {
1427                 case TRISTATE_TRUE:
1428                 {
1429                     bool bBefore = m_pBreakPositionLB->GetSelectEntryPos() == 0;
1430
1431                     if ( m_pBreakTypeLB->GetSelectEntryPos() == 0 )
1432                     {
1433                         if ( bBefore )
1434                             aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
1435                         else
1436                             aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
1437                     }
1438                     else
1439                     {
1440                         if ( bBefore )
1441                             aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
1442                         else
1443                             aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
1444                     }
1445                     break;
1446                 }
1447
1448                 case TRISTATE_FALSE:
1449                     aBreak.SetValue( SVX_BREAK_NONE );
1450                     break;
1451                 default: ; //prevent warning
1452             }
1453             pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGEBREAK );
1454
1455             if ( eState != m_pPageBreakBox->GetSavedValue()                ||
1456                     !pOld || !( *(const SvxFmtBreakItem*)pOld == aBreak ) )
1457             {
1458                 bModified = true;
1459                 rOutSet.Put( aBreak );
1460             }
1461         }
1462     }
1463
1464     // paragraph split
1465     _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1466     eState = m_pKeepTogetherBox->GetState();
1467
1468     if ( m_pKeepTogetherBox->IsValueChangedFromSaved() )
1469     {
1470         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_SPLIT );
1471
1472         if ( !pOld || ( (const SvxFmtSplitItem*)pOld )->GetValue() !=
1473                       ( eState == TRISTATE_FALSE ) )
1474         {
1475             rOutSet.Put( SvxFmtSplitItem( eState == TRISTATE_FALSE, _nWhich ) );
1476             bModified = true;
1477         }
1478     }
1479
1480     // keep paragraphs
1481     _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1482     eState = m_pKeepParaBox->GetState();
1483
1484     if ( m_pKeepParaBox->IsValueChangedFromSaved() )
1485     {
1486         // if the status has changed, putting is necessary
1487         rOutSet.Put( SvxFmtKeepItem( eState == TRISTATE_TRUE, _nWhich ) );
1488         bModified = true;
1489     }
1490
1491     // widows and orphans
1492     _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1493     eState = m_pWidowBox->GetState();
1494
1495     if ( m_pWidowBox->IsValueChangedFromSaved() ||
1496          m_pWidowRowNo->IsValueModified() )
1497     {
1498         SvxWidowsItem rItem( eState == TRISTATE_TRUE ?
1499                              (sal_uInt8)m_pWidowRowNo->GetValue() : 0, _nWhich );
1500         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_WIDOWS );
1501
1502         if ( m_pWidowBox->IsValueChangedFromSaved() || !pOld || !( *(const SvxWidowsItem*)pOld == rItem ) )
1503         {
1504             rOutSet.Put( rItem );
1505             bModified = true;
1506         }
1507     }
1508
1509     _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1510     eState = m_pOrphanBox->GetState();
1511
1512     if ( m_pOrphanBox->IsValueChangedFromSaved() ||
1513          m_pOrphanRowNo->IsValueModified() )
1514     {
1515         SvxOrphansItem rItem( eState == TRISTATE_TRUE ?
1516                              (sal_uInt8)m_pOrphanRowNo->GetValue() : 0, _nWhich );
1517         pOld = GetOldItem( rOutSet, SID_ATTR_PARA_ORPHANS );
1518
1519         if ( m_pOrphanBox->IsValueChangedFromSaved() ||
1520                 !pOld ||
1521                     !( *(const SvxOrphansItem*)pOld == rItem ) )
1522         {
1523             rOutSet.Put( rItem );
1524             bModified = true;
1525         }
1526     }
1527
1528     return bModified;
1529 }
1530
1531 void SvxExtParagraphTabPage::Reset( const SfxItemSet& rSet )
1532 {
1533     sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1534     SfxItemState eItemState = rSet.GetItemState( _nWhich );
1535
1536     bool bItemAvailable = eItemState >= SFX_ITEM_AVAILABLE;
1537     bool bIsHyphen = false;
1538     if( !bHtmlMode && bItemAvailable )
1539     {
1540         const SvxHyphenZoneItem& rHyphen =
1541             (const SvxHyphenZoneItem&)rSet.Get( _nWhich );
1542         m_pHyphenBox->EnableTriState( false );
1543
1544         bIsHyphen = rHyphen.IsHyphen();
1545         m_pHyphenBox->SetState( bIsHyphen ? TRISTATE_TRUE : TRISTATE_FALSE );
1546
1547         m_pExtHyphenBeforeBox->SetValue( rHyphen.GetMinLead() );
1548         m_pExtHyphenAfterBox->SetValue( rHyphen.GetMinTrail() );
1549         m_pMaxHyphenEdit->SetValue( rHyphen.GetMaxHyphens() );
1550     }
1551     else
1552     {
1553         m_pHyphenBox->SetState( TRISTATE_INDET );
1554     }
1555     bool bEnable = bItemAvailable && bIsHyphen;
1556     m_pExtHyphenBeforeBox->Enable(bEnable);
1557     m_pExtHyphenAfterBox->Enable(bEnable);
1558     m_pBeforeText->Enable(bEnable);
1559     m_pAfterText->Enable(bEnable);
1560     m_pMaxHyphenLabel->Enable(bEnable);
1561     m_pMaxHyphenEdit->Enable(bEnable);
1562
1563     _nWhich = GetWhich( SID_ATTR_PARA_PAGENUM );
1564
1565     if ( rSet.GetItemState(_nWhich) >= SFX_ITEM_SET )
1566     {
1567         const sal_uInt16 nPageNum =
1568             ( (const SfxUInt16Item&)rSet.Get( _nWhich ) ).GetValue();
1569         m_pPagenumEdit->SetValue( nPageNum );
1570     }
1571
1572     if ( bPageBreak )
1573     {
1574         // first handle PageModel
1575         _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1576         bool bIsPageModel = false;
1577         eItemState = rSet.GetItemState( _nWhich );
1578
1579         if ( eItemState >= SFX_ITEM_SET )
1580         {
1581             m_pApplyCollBtn->EnableTriState( false );
1582
1583             const SvxPageModelItem& rModel =
1584                 (const SvxPageModelItem&)rSet.Get( _nWhich );
1585             OUString aStr( rModel.GetValue() );
1586
1587             if ( !aStr.isEmpty() &&
1588                  m_pApplyCollBox->GetEntryPos( aStr ) != LISTBOX_ENTRY_NOTFOUND )
1589             {
1590                 m_pApplyCollBox->SelectEntry( aStr );
1591                 m_pApplyCollBtn->SetState( TRISTATE_TRUE );
1592                 bIsPageModel = true;
1593
1594                 m_pPageBreakBox->Enable();
1595                 m_pPageBreakBox->EnableTriState( false );
1596                 m_pBreakTypeFT->Enable();
1597                 m_pBreakTypeLB->Enable();
1598                 m_pBreakPositionFT->Enable();
1599                 m_pBreakPositionLB->Enable();
1600                 m_pApplyCollBtn->Enable();
1601                 m_pPageBreakBox->SetState( TRISTATE_TRUE );
1602
1603                 //select page break
1604                 m_pBreakTypeLB->SelectEntryPos(0);
1605                 //select break before
1606                 m_pBreakPositionLB->SelectEntryPos(0);
1607             }
1608             else
1609             {
1610                 m_pApplyCollBox->SetNoSelection();
1611                 m_pApplyCollBtn->SetState( TRISTATE_FALSE );
1612             }
1613         }
1614         else if ( SFX_ITEM_DONTCARE == eItemState )
1615         {
1616             m_pApplyCollBtn->EnableTriState( true );
1617             m_pApplyCollBtn->SetState( TRISTATE_INDET );
1618             m_pApplyCollBox->SetNoSelection();
1619         }
1620         else
1621         {
1622             m_pApplyCollBtn->Enable(false);
1623             m_pApplyCollBox->Enable(false);
1624             m_pPagenumEdit->Enable(false);
1625             m_pPagenumText->Enable(false);
1626         }
1627
1628         if ( !bIsPageModel )
1629         {
1630             _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1631             eItemState = rSet.GetItemState( _nWhich );
1632
1633             if ( eItemState >= SFX_ITEM_AVAILABLE )
1634             {
1635                 const SvxFmtBreakItem& rPageBreak =
1636                     (const SvxFmtBreakItem&)rSet.Get( _nWhich );
1637
1638                 SvxBreak eBreak = (SvxBreak)rPageBreak.GetValue();
1639
1640                 // PageBreak not via CTRL-RETURN,
1641                 // then CheckBox can be freed
1642                 m_pPageBreakBox->Enable();
1643                 m_pPageBreakBox->EnableTriState( false );
1644                 m_pBreakTypeFT->Enable();
1645                 m_pBreakTypeLB->Enable();
1646                 m_pBreakPositionFT->Enable();
1647                 m_pBreakPositionLB->Enable();
1648
1649                 m_pPageBreakBox->SetState( TRISTATE_TRUE );
1650
1651                 bool _bEnable =     eBreak != SVX_BREAK_NONE &&
1652                                 eBreak != SVX_BREAK_COLUMN_BEFORE &&
1653                                 eBreak != SVX_BREAK_COLUMN_AFTER;
1654                 m_pApplyCollBtn->Enable(_bEnable);
1655                 if(!_bEnable)
1656                 {
1657                     m_pApplyCollBox->Enable(_bEnable);
1658                     m_pPagenumEdit->Enable(_bEnable);
1659                 }
1660
1661                 if ( eBreak == SVX_BREAK_NONE )
1662                     m_pPageBreakBox->SetState( TRISTATE_FALSE );
1663
1664                 sal_Int32 nType = 0; // selection position in break type ListBox : Page
1665                 sal_Int32 nPosition = 0; //  selection position in break position ListBox : Before
1666                 switch ( eBreak )
1667                 {
1668                     case SVX_BREAK_PAGE_BEFORE:
1669                         break;
1670                     case SVX_BREAK_PAGE_AFTER:
1671                         nPosition = 1;
1672                         break;
1673                     case SVX_BREAK_COLUMN_BEFORE:
1674                         nType = 1;
1675                         break;
1676                     case SVX_BREAK_COLUMN_AFTER:
1677                         nType = 1;
1678                         nPosition = 1;
1679                         break;
1680                     default: ;//prevent warning
1681                 }
1682                 m_pBreakTypeLB->SelectEntryPos(nType);
1683                 m_pBreakPositionLB->SelectEntryPos(nPosition);
1684             }
1685             else if ( SFX_ITEM_DONTCARE == eItemState )
1686                 m_pPageBreakBox->SetState( TRISTATE_INDET );
1687             else
1688             {
1689                 m_pPageBreakBox->Enable(false);
1690                 m_pBreakTypeFT->Enable(false);
1691                 m_pBreakTypeLB->Enable(false);
1692                 m_pBreakPositionFT->Enable(false);
1693                 m_pBreakPositionLB->Enable(false);
1694             }
1695         }
1696
1697         PageBreakPosHdl_Impl( m_pBreakPositionLB );
1698         PageBreakHdl_Impl( m_pPageBreakBox );
1699     }
1700
1701     _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1702     eItemState = rSet.GetItemState( _nWhich );
1703
1704     if ( eItemState >= SFX_ITEM_AVAILABLE )
1705     {
1706         m_pKeepParaBox->EnableTriState( false );
1707         const SvxFmtKeepItem& rKeep =
1708             (const SvxFmtKeepItem&)rSet.Get( _nWhich );
1709
1710         if ( rKeep.GetValue() )
1711             m_pKeepParaBox->SetState( TRISTATE_TRUE );
1712         else
1713             m_pKeepParaBox->SetState( TRISTATE_FALSE );
1714     }
1715     else if ( SFX_ITEM_DONTCARE == eItemState )
1716         m_pKeepParaBox->SetState( TRISTATE_INDET );
1717     else
1718         m_pKeepParaBox->Enable(false);
1719
1720     _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1721     eItemState = rSet.GetItemState( _nWhich );
1722
1723     if ( eItemState >= SFX_ITEM_AVAILABLE )
1724     {
1725         const SvxFmtSplitItem& rSplit =
1726             (const SvxFmtSplitItem&)rSet.Get( _nWhich );
1727         m_pKeepTogetherBox->EnableTriState( false );
1728
1729         if ( !rSplit.GetValue() )
1730             m_pKeepTogetherBox->SetState( TRISTATE_TRUE );
1731         else
1732         {
1733             m_pKeepTogetherBox->SetState( TRISTATE_FALSE );
1734
1735             // widows and orphans
1736             m_pWidowBox->Enable();
1737             _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1738             SfxItemState eTmpState = rSet.GetItemState( _nWhich );
1739
1740             if ( eTmpState >= SFX_ITEM_AVAILABLE )
1741             {
1742                 const SvxWidowsItem& rWidow =
1743                     (const SvxWidowsItem&)rSet.Get( _nWhich );
1744                 m_pWidowBox->EnableTriState( false );
1745                 const sal_uInt16 nLines = rWidow.GetValue();
1746
1747                 bool _bEnable = nLines > 0;
1748                 m_pWidowRowNo->SetValue( m_pWidowRowNo->Normalize( nLines ) );
1749                 m_pWidowBox->SetState( _bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
1750                 m_pWidowRowNo->Enable(_bEnable);
1751                 //m_pWidowRowLabel->Enable(_bEnable);
1752
1753             }
1754             else if ( SFX_ITEM_DONTCARE == eTmpState )
1755                 m_pWidowBox->SetState( TRISTATE_INDET );
1756             else
1757                 m_pWidowBox->Enable(false);
1758
1759             m_pOrphanBox->Enable();
1760             _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1761             eTmpState = rSet.GetItemState( _nWhich );
1762
1763             if ( eTmpState >= SFX_ITEM_AVAILABLE )
1764             {
1765                 const SvxOrphansItem& rOrphan =
1766                     (const SvxOrphansItem&)rSet.Get( _nWhich );
1767                 const sal_uInt16 nLines = rOrphan.GetValue();
1768                 m_pOrphanBox->EnableTriState( false );
1769
1770                 bool _bEnable = nLines > 0;
1771                 m_pOrphanBox->SetState( _bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
1772                 m_pOrphanRowNo->SetValue( m_pOrphanRowNo->Normalize( nLines ) );
1773                 m_pOrphanRowNo->Enable(_bEnable);
1774                 m_pOrphanRowLabel->Enable(_bEnable);
1775
1776             }
1777             else if ( SFX_ITEM_DONTCARE == eTmpState )
1778                 m_pOrphanBox->SetState( TRISTATE_INDET );
1779             else
1780                 m_pOrphanBox->Enable(false);
1781         }
1782     }
1783     else if ( SFX_ITEM_DONTCARE == eItemState )
1784         m_pKeepTogetherBox->SetState( TRISTATE_INDET );
1785     else
1786         m_pKeepTogetherBox->Enable(false);
1787
1788     // so that everything is enabled correctly
1789     KeepTogetherHdl_Impl( 0 );
1790     WidowHdl_Impl( 0 );
1791     OrphanHdl_Impl( 0 );
1792
1793     m_pHyphenBox->SaveValue();
1794     m_pExtHyphenBeforeBox->SaveValue();
1795     m_pExtHyphenAfterBox->SaveValue();
1796     m_pMaxHyphenEdit->SaveValue();
1797     m_pPageBreakBox->SaveValue();
1798     m_pBreakPositionLB->SaveValue();
1799     m_pBreakTypeLB->SaveValue();
1800     m_pApplyCollBtn->SaveValue();
1801     m_pApplyCollBox->SaveValue();
1802     m_pPagenumEdit->SaveValue();
1803     m_pKeepTogetherBox->SaveValue();
1804     m_pKeepParaBox->SaveValue();
1805     m_pWidowBox->SaveValue();
1806     m_pOrphanBox->SaveValue();
1807 }
1808
1809 int SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
1810 {
1811     if ( _pSet )
1812         FillItemSet( *_pSet );
1813     return LEAVE_PAGE;
1814 }
1815
1816 void SvxExtParagraphTabPage::DisablePageBreak()
1817 {
1818     bPageBreak = false;
1819     m_pPageBreakBox->Enable(false);
1820     m_pBreakTypeLB->RemoveEntry(0);
1821     m_pBreakPositionFT->Enable(false);
1822     m_pBreakPositionLB->Enable(false);
1823     m_pApplyCollBtn->Enable(false);
1824     m_pApplyCollBox->Enable(false);
1825     m_pPagenumEdit->Enable(false);
1826 }
1827
1828 SvxExtParagraphTabPage::SvxExtParagraphTabPage( Window* pParent, const SfxItemSet& rAttr ) :
1829     SfxTabPage( pParent, "TextFlowPage","cui/ui/textflowpage.ui", rAttr ),
1830
1831     bPageBreak  ( true ),
1832     bHtmlMode   ( false ),
1833     nStdPos     ( 0 )
1834 {
1835     // Hyphenation
1836     get(m_pHyphenBox,"checkAuto");
1837     get(m_pExtHyphenBeforeBox,"spinLineEnd");
1838     get(m_pExtHyphenAfterBox,"spinLineBegin");
1839     get(m_pMaxHyphenEdit,"spinMaxNum");
1840     get(m_pBeforeText,"labelLineBegin");
1841     get(m_pAfterText,"labelLineEnd");
1842     get(m_pMaxHyphenLabel,"labelMaxNum");
1843
1844     //Page break
1845     get(m_pPageBreakBox,"checkInsert");
1846     get(m_pBreakTypeLB,"comboBreakType");
1847     get(m_pBreakPositionLB,"comboBreakPosition");
1848     get(m_pApplyCollBtn,"checkPageStyle");
1849     get(m_pApplyCollBox,"comboPageStyle");
1850     get(m_pPagenumEdit,"spinPageNumber");
1851     get(m_pBreakTypeFT,"labelType");
1852     get(m_pBreakPositionFT,"labelPosition");
1853     get(m_pPagenumText,"labelPageNum");
1854
1855     // Options
1856     get(m_pKeepTogetherBox,"checkSplitPara");
1857     get(m_pKeepParaBox,"checkKeepPara");
1858
1859     get(m_pOrphanBox,"checkOrphan");
1860     get(m_pOrphanRowNo,"spinOrphan");
1861     get(m_pOrphanRowLabel,"labelOrphan");
1862
1863     get(m_pWidowBox,"checkWidow");
1864     get(m_pWidowRowNo,"spinWidow");
1865     get(m_pWidowRowLabel,"labelWidow");
1866
1867     m_pApplyCollBox->SetAccessibleRelationLabeledBy(m_pApplyCollBtn);
1868     m_pApplyCollBox->SetAccessibleName(CUI_RES(STR_PAGE_STYLE));
1869
1870     m_pOrphanRowNo->SetAccessibleRelationLabeledBy(m_pOrphanBox);
1871     m_pWidowRowNo->SetAccessibleRelationLabeledBy(m_pWidowBox);
1872
1873     // this page needs ExchangeSupport
1874     SetExchangeSupport();
1875
1876     m_pHyphenBox->SetClickHdl(         LINK( this, SvxExtParagraphTabPage, HyphenClickHdl_Impl ) );
1877     m_pPageBreakBox->SetClickHdl(      LINK( this, SvxExtParagraphTabPage, PageBreakHdl_Impl ) );
1878     m_pKeepTogetherBox->SetClickHdl(   LINK( this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl ) );
1879     m_pWidowBox->SetClickHdl(          LINK( this, SvxExtParagraphTabPage, WidowHdl_Impl ) );
1880     m_pOrphanBox->SetClickHdl(         LINK( this, SvxExtParagraphTabPage, OrphanHdl_Impl ) );
1881     m_pApplyCollBtn->SetClickHdl(      LINK( this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl ) );
1882     m_pBreakTypeLB->SetSelectHdl(      LINK( this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl ) );
1883     m_pBreakPositionLB->SetSelectHdl(  LINK( this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl ) );
1884
1885     SfxObjectShell* pSh = SfxObjectShell::Current();
1886     if ( pSh )
1887     {
1888         SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
1889         pPool->SetSearchMask( SFX_STYLE_FAMILY_PAGE );
1890         SfxStyleSheetBase* pStyle = pPool->First();
1891         OUString aStdName;
1892
1893         while( pStyle )
1894         {
1895             if ( aStdName.isEmpty() )
1896                 // first style == standard style
1897                 aStdName = pStyle->GetName();
1898             m_pApplyCollBox->InsertEntry( pStyle->GetName() );
1899             pStyle = pPool->Next();
1900         }
1901         nStdPos = m_pApplyCollBox->GetEntryPos( aStdName );
1902     }
1903
1904     sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr );
1905     if ( nHtmlMode & HTMLMODE_ON )
1906     {
1907         bHtmlMode = true;
1908         m_pHyphenBox           ->Enable(false);
1909         m_pBeforeText          ->Enable(false);
1910         m_pExtHyphenBeforeBox  ->Enable(false);
1911         m_pAfterText           ->Enable(false);
1912         m_pExtHyphenAfterBox   ->Enable(false);
1913         m_pMaxHyphenLabel      ->Enable(false);
1914         m_pMaxHyphenEdit       ->Enable(false);
1915         m_pPagenumText         ->Enable(false);
1916         m_pPagenumEdit         ->Enable(false);
1917         // no column break in HTML
1918         m_pBreakTypeLB->RemoveEntry(1);
1919     }
1920 }
1921
1922 SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
1923 {
1924 }
1925
1926 const sal_uInt16* SvxExtParagraphTabPage::GetRanges()
1927 {
1928     return pExtRanges;
1929 }
1930
1931 IMPL_LINK_NOARG(SvxExtParagraphTabPage, PageBreakHdl_Impl)
1932 {
1933     switch ( m_pPageBreakBox->GetState() )
1934     {
1935         case TRISTATE_TRUE:
1936             m_pBreakTypeFT->Enable();
1937             m_pBreakTypeLB->Enable();
1938             m_pBreakPositionFT->Enable();
1939             m_pBreakPositionLB->Enable();
1940
1941             if ( 0 == m_pBreakTypeLB->GetSelectEntryPos()&&
1942                 0 == m_pBreakPositionLB->GetSelectEntryPos() )
1943             {
1944                 m_pApplyCollBtn->Enable();
1945
1946                 bool bEnable = TRISTATE_TRUE == m_pApplyCollBtn->GetState() &&
1947                                             m_pApplyCollBox->GetEntryCount();
1948                 m_pApplyCollBox->Enable(bEnable);
1949                 if(!bHtmlMode)
1950                 {
1951                     m_pPagenumText->Enable(bEnable);
1952                     m_pPagenumEdit->Enable(bEnable);
1953                 }
1954             }
1955             break;
1956
1957         case TRISTATE_FALSE:
1958         case TRISTATE_INDET:
1959             m_pApplyCollBtn->SetState( TRISTATE_FALSE );
1960             m_pApplyCollBtn->Enable(false);
1961             m_pApplyCollBox->Enable(false);
1962             m_pPagenumText->Enable(false);
1963             m_pPagenumEdit->Enable(false);
1964             m_pBreakTypeFT->Enable(false);
1965             m_pBreakTypeLB->Enable(false);
1966             m_pBreakPositionFT->Enable(false);
1967             m_pBreakPositionLB->Enable(false);
1968             break;
1969     }
1970     return 0;
1971 }
1972
1973 IMPL_LINK_NOARG(SvxExtParagraphTabPage, KeepTogetherHdl_Impl)
1974 {
1975     bool bEnable = m_pKeepTogetherBox->GetState() == TRISTATE_FALSE;
1976     m_pWidowBox->Enable(bEnable);
1977     m_pOrphanBox->Enable(bEnable);
1978
1979     return 0;
1980 }
1981
1982 IMPL_LINK_NOARG(SvxExtParagraphTabPage, WidowHdl_Impl)
1983 {
1984     switch ( m_pWidowBox->GetState() )
1985     {
1986         case TRISTATE_TRUE:
1987             m_pWidowRowNo->Enable();
1988             m_pWidowRowLabel->Enable();
1989             m_pKeepTogetherBox->Enable(false);
1990             break;
1991
1992         case TRISTATE_FALSE:
1993             if ( m_pOrphanBox->GetState() == TRISTATE_FALSE )
1994                 m_pKeepTogetherBox->Enable();
1995
1996         // no break
1997         case TRISTATE_INDET:
1998             m_pWidowRowNo->Enable(false);
1999             m_pWidowRowLabel->Enable(false);
2000             break;
2001     }
2002     return 0;
2003 }
2004
2005 IMPL_LINK_NOARG(SvxExtParagraphTabPage, OrphanHdl_Impl)
2006 {
2007     switch( m_pOrphanBox->GetState() )
2008     {
2009         case TRISTATE_TRUE:
2010             m_pOrphanRowNo->Enable();
2011             m_pOrphanRowLabel->Enable();
2012             m_pKeepTogetherBox->Enable(false);
2013             break;
2014
2015         case TRISTATE_FALSE:
2016             if ( m_pWidowBox->GetState() == TRISTATE_FALSE )
2017                 m_pKeepTogetherBox->Enable();
2018
2019         // no break
2020         case TRISTATE_INDET:
2021             m_pOrphanRowNo->Enable(false);
2022             m_pOrphanRowLabel->Enable(false);
2023             break;
2024     }
2025     return 0;
2026 }
2027
2028 IMPL_LINK_NOARG(SvxExtParagraphTabPage, HyphenClickHdl_Impl)
2029 {
2030
2031     bool bEnable = m_pHyphenBox->GetState() == TRISTATE_TRUE;
2032     m_pBeforeText->Enable(bEnable);
2033     m_pExtHyphenBeforeBox->Enable(bEnable);
2034     m_pAfterText->Enable(bEnable);
2035     m_pExtHyphenAfterBox->Enable(bEnable);
2036     m_pMaxHyphenLabel->Enable(bEnable);
2037     m_pMaxHyphenEdit->Enable(bEnable);
2038     m_pHyphenBox->SetState( bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
2039
2040     return 0;
2041 }
2042
2043 IMPL_LINK_NOARG(SvxExtParagraphTabPage, ApplyCollClickHdl_Impl)
2044 {
2045     bool bEnable = false;
2046     if ( m_pApplyCollBtn->GetState() == TRISTATE_TRUE &&
2047          m_pApplyCollBox->GetEntryCount() )
2048     {
2049         bEnable = true;
2050         m_pApplyCollBox->SelectEntryPos( nStdPos );
2051     }
2052     else
2053     {
2054         m_pApplyCollBox->SetNoSelection();
2055     }
2056     m_pApplyCollBox->Enable(bEnable);
2057     if(!bHtmlMode)
2058     {
2059         m_pPagenumText->Enable(bEnable);
2060         m_pPagenumEdit->Enable(bEnable);
2061     }
2062     return 0;
2063 }
2064
2065 IMPL_LINK( SvxExtParagraphTabPage, PageBreakPosHdl_Impl, ListBox *, pListBox )
2066 {
2067     if ( 0 == pListBox->GetSelectEntryPos() )
2068     {
2069         m_pApplyCollBtn->Enable();
2070
2071         bool bEnable = m_pApplyCollBtn->GetState() == TRISTATE_TRUE &&
2072                                     m_pApplyCollBox->GetEntryCount();
2073
2074         m_pApplyCollBox->Enable(bEnable);
2075         if(!bHtmlMode)
2076         {
2077             m_pPagenumText->Enable(bEnable);
2078             m_pPagenumEdit->Enable(bEnable);
2079         }
2080     }
2081     else if ( 1 == pListBox->GetSelectEntryPos() )
2082     {
2083         m_pApplyCollBtn->SetState( TRISTATE_FALSE );
2084         m_pApplyCollBtn->Enable(false);
2085         m_pApplyCollBox->Enable(false);
2086         m_pPagenumText->Enable(false);
2087         m_pPagenumEdit->Enable(false);
2088     }
2089     return 0;
2090 }
2091
2092 IMPL_LINK( SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, ListBox *, pListBox )
2093 {
2094     //column break or break break after
2095     sal_Int32 nBreakPos = m_pBreakPositionLB->GetSelectEntryPos();
2096     if ( pListBox->GetSelectEntryPos() == 1 || 1 == nBreakPos)
2097     {
2098         m_pApplyCollBtn->SetState( TRISTATE_FALSE );
2099         m_pApplyCollBtn->Enable(false);
2100         m_pApplyCollBox->Enable(false);
2101         m_pPagenumText->Enable(false);
2102         m_pPagenumEdit->Enable(false);
2103     }
2104     else
2105         PageBreakPosHdl_Impl( m_pBreakPositionLB );
2106     return 0;
2107 }
2108
2109 void SvxExtParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
2110 {
2111     SFX_ITEMSET_ARG (&aSet,pDisablePageBreakItem,SfxBoolItem,SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK,false);
2112
2113     if (pDisablePageBreakItem)
2114         if ( pDisablePageBreakItem->GetValue())
2115                     DisablePageBreak();
2116 }
2117
2118 SvxAsianTabPage::SvxAsianTabPage( Window* pParent, const SfxItemSet& rSet ) :
2119     SfxTabPage(pParent, "AsianTypography","cui/ui/asiantypography.ui", rSet)
2120
2121 {
2122     get(m_pForbiddenRulesCB,"checkForbidList");
2123     get(m_pHangingPunctCB,"checkHangPunct");
2124     get(m_pScriptSpaceCB,"checkApplySpacing");
2125
2126     Link aLink = LINK( this, SvxAsianTabPage, ClickHdl_Impl );
2127     m_pHangingPunctCB->SetClickHdl( aLink );
2128     m_pScriptSpaceCB->SetClickHdl( aLink );
2129     m_pForbiddenRulesCB->SetClickHdl( aLink );
2130
2131 }
2132
2133 SvxAsianTabPage::~SvxAsianTabPage()
2134 {
2135 }
2136
2137 SfxTabPage* SvxAsianTabPage::Create(    Window* pParent, const SfxItemSet& rSet )
2138 {
2139     return new SvxAsianTabPage(pParent, rSet);
2140 }
2141
2142 const sal_uInt16*     SvxAsianTabPage::GetRanges()
2143 {
2144     static const sal_uInt16 pRanges[] =
2145     {
2146         SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES,
2147         0
2148     };
2149     return pRanges;
2150 }
2151
2152 bool SvxAsianTabPage::FillItemSet( SfxItemSet& rSet )
2153 {
2154     bool bRet = false;
2155     SfxItemPool* pPool = rSet.GetPool();
2156     if (m_pScriptSpaceCB->IsEnabled() && m_pScriptSpaceCB->IsValueChangedFromSaved())
2157     {
2158         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2159             pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone();
2160         pNewItem->SetValue(m_pScriptSpaceCB->IsChecked());
2161         rSet.Put(*pNewItem);
2162         delete pNewItem;
2163         bRet = true;
2164     }
2165     if (m_pHangingPunctCB->IsEnabled() && m_pHangingPunctCB->IsValueChangedFromSaved())
2166     {
2167         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2168             pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone();
2169         pNewItem->SetValue(m_pHangingPunctCB->IsChecked());
2170         rSet.Put(*pNewItem);
2171         delete pNewItem;
2172         bRet = true;
2173     }
2174     if (m_pForbiddenRulesCB->IsEnabled() && m_pForbiddenRulesCB->IsValueChangedFromSaved())
2175     {
2176         SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2177             pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone();
2178         pNewItem->SetValue(m_pForbiddenRulesCB->IsChecked());
2179         rSet.Put(*pNewItem);
2180         delete pNewItem;
2181         bRet = true;
2182     }
2183     return bRet;
2184 }
2185
2186 static void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, CheckBox& rBox)
2187 {
2188     sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId);
2189     SfxItemState eState = rSet.GetItemState(_nWhich, true);
2190     if(!eState || eState == SFX_ITEM_DISABLED )
2191         rBox.Enable(false);
2192     else if(eState >= SFX_ITEM_AVAILABLE)
2193     {
2194         rBox.EnableTriState( false );
2195         rBox.Check(((const SfxBoolItem&)rSet.Get(_nWhich)).GetValue());
2196     }
2197     else
2198         rBox.SetState( TRISTATE_INDET );
2199     rBox.SaveValue();
2200 }
2201
2202 void SvxAsianTabPage::Reset( const SfxItemSet& rSet )
2203 {
2204     lcl_SetBox(rSet, SID_ATTR_PARA_FORBIDDEN_RULES, *m_pForbiddenRulesCB );
2205     lcl_SetBox(rSet, SID_ATTR_PARA_HANGPUNCTUATION, *m_pHangingPunctCB );
2206
2207     //character distance not yet available
2208     lcl_SetBox(rSet, SID_ATTR_PARA_SCRIPTSPACE, *m_pScriptSpaceCB );
2209 }
2210
2211 IMPL_LINK( SvxAsianTabPage, ClickHdl_Impl, CheckBox*, pBox )
2212 {
2213     pBox->EnableTriState( false );
2214     return 0;
2215 }
2216
2217 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */