sd/source/ui/view/drtxtob.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 "TextObjectBar.hxx"
  21
  22 #include <svx/svxids.hrc>
  23
  24 #include <i18nlangtag/mslangid.hxx>
  25 #include <editeng/ulspitem.hxx>
  26 #include <editeng/lspcitem.hxx>
  27 #include <editeng/adjustitem.hxx>
  28 #include <editeng/editview.hxx>
  29 #include <editeng/editeng.hxx>
  30 #include <editeng/outliner.hxx>
  31 #include <editeng/unolingu.hxx>
  32 #include <editeng/kernitem.hxx>
  33 #include <vcl/vclenum.hxx>
  34 #include <sfx2/app.hxx>
  35 #include <sfx2/request.hxx>
  36 #include <svl/whiter.hxx>
  37 #include <svl/itempool.hxx>
  38 #include <svl/stritem.hxx>
  39 #include <svl/style.hxx>
  40 #include <svl/languageoptions.hxx>
  41 #include <sfx2/tplpitem.hxx>
  42 #include <editeng/escapementitem.hxx>
  43 #include <svx/svdoutl.hxx>
  44 #include <svl/intitem.hxx>
  45 #include <editeng/scripttypeitem.hxx>
  46 #include <editeng/outlobj.hxx>
  47 #include <editeng/writingmodeitem.hxx>
  48 #include <editeng/frmdiritem.hxx>
  49 #include <editeng/fhgtitem.hxx>
  50
  51 #include <sfx2/objface.hxx>
  52
  53 #include "app.hrc"
  54 #include "glob.hrc"
  55 #include "res_bmp.hrc"
  56
  57 #include "drawdoc.hxx"
  58 #include "DrawViewShell.hxx"
  59 #include "OutlineViewShell.hxx"
  60 #include "ViewShellBase.hxx"
  61 #include "ToolBarManager.hxx"
  62 #include "futempl.hxx"
  63 #include "sdresid.hxx"
  64 #include "Window.hxx"
  65 #include "OutlineView.hxx"
  66
  67 using namespace sd;
  68 using namespace ::com::sun::star;
  69
  70 #define TextObjectBar
  71 #include "sdslots.hxx"
  72
  73 namespace sd {
  74
  75 /**
  76  * Declare default interface (Slotmap must not be empty, therefore enter
  77  * something that (hopefully) never occurs.
  78  */
  79 SFX_IMPL_INTERFACE(TextObjectBar, SfxShell)
  80
  81 void TextObjectBar::InitInterface_Impl()
  82 {
  83 }
  84
  85 TYPEINIT1( TextObjectBar, SfxShell );
  86
  87 TextObjectBar::TextObjectBar (
  88     ViewShell* pSdViewSh,
  89     SfxItemPool& rItemPool,
  90     ::sd::View* pSdView )
  91     : SfxShell(pSdViewSh->GetViewShell()),
  92       mpViewShell( pSdViewSh ),
  93       mpView( pSdView )
  94 {
  95     SetPool(&rItemPool);
  96
  97     if( mpView )
  98     {
  99         OutlineView* pOutlinerView = dynamic_cast< OutlineView* >( mpView );
 100         if( pOutlinerView )
 101         {
 102             SetUndoManager(&pOutlinerView->GetOutliner().GetUndoManager());
 103         }
 104         else
 105         {
 106             DrawDocShell* pDocShell = mpView->GetDoc().GetDocSh();
 107             if( pDocShell )
 108             {
 109                 SetUndoManager(pDocShell->GetUndoManager());
 110                 DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( pSdViewSh );
 111                 if ( pDrawViewShell )
 112                     SetRepeatTarget(pSdView);
 113             }
 114         }
 115     }
 116
 117     SetName( OUString( "TextObjectBar" ));
 118
 119     // SetHelpId( SD_IF_SDDRAWTEXTOBJECTBAR );
 120 }
 121
 122 TextObjectBar::~TextObjectBar()
 123 {
 124     SetRepeatTarget(NULL);
 125 }
 126
 127 void TextObjectBar::GetCharState( SfxItemSet& rSet )
 128 {
 129     SfxItemSet  aCharAttrSet( mpView->GetDoc().GetPool() );
 130     mpView->GetAttributes( aCharAttrSet );
 131
 132     SfxItemSet aNewAttr( mpViewShell->GetPool(),EE_ITEMS_START,EE_ITEMS_END);
 133
 134     aNewAttr.Put(aCharAttrSet, false);
 135     rSet.Put(aNewAttr, false);
 136
 137     SvxKerningItem aKern = static_cast<const SvxKerningItem&>( aCharAttrSet.Get( EE_CHAR_KERNING ) );
 138     //aKern.SetWhich(SID_ATTR_CHAR_KERNING);
 139     rSet.Put(aKern);
 140
 141     SfxItemState eState = aCharAttrSet.GetItemState( EE_CHAR_KERNING, true );
 142     if ( eState == SfxItemState::DONTCARE )
 143     {
 144         rSet.InvalidateItem(EE_CHAR_KERNING);
 145     }
 146 }
 147
 148 /**
 149  * Status of attribute items.
 150  */
 151 void TextObjectBar::GetAttrState( SfxItemSet& rSet )
 152 {
 153     SfxWhichIter        aIter( rSet );
 154     sal_uInt16              nWhich = aIter.FirstWhich();
 155     SfxItemSet          aAttrSet( mpView->GetDoc().GetPool() );
 156     SvtLanguageOptions  aLangOpt;
 157     bool            bDisableParagraphTextDirection = !aLangOpt.IsCTLFontEnabled();
 158     bool            bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled();
 159
 160     mpView->GetAttributes( aAttrSet );
 161
 162     while ( nWhich )
 163     {
 164         sal_uInt16 nSlotId = SfxItemPool::IsWhich(nWhich)
 165             ? GetPool().GetSlotId(nWhich)
 166             : nWhich;
 167
 168         switch ( nSlotId )
 169         {
 170             case SID_ATTR_CHAR_FONT:
 171             case SID_ATTR_CHAR_FONTHEIGHT:
 172             case SID_ATTR_CHAR_WEIGHT:
 173             case SID_ATTR_CHAR_POSTURE:
 174         case SID_ATTR_CHAR_SHADOWED:
 175             case SID_ATTR_CHAR_STRIKEOUT:
 176             {
 177                 sal_uInt16 stretchX = 100;
 178                 sal_uInt16 stretchY = 100;
 179                 SvxScriptSetItem aSetItem( nSlotId, GetPool() );
 180                 aSetItem.GetItemSet().Put( aAttrSet, false );
 181
 182                 SvtScriptType nScriptType = mpView->GetScriptType();
 183
 184                 if( (nSlotId == SID_ATTR_CHAR_FONT) || (nSlotId == SID_ATTR_CHAR_FONTHEIGHT) )
 185                 {
 186                     // input language should be preferred over
 187                     // current cursor position to detect script type
 188                     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 189                     SdrOutliner *pOutliner = mpView->GetTextEditOutliner();
 190
 191                     if (mpView->ISA(OutlineView))
 192                     {
 193                         pOLV = static_cast<OutlineView*>(mpView)->GetViewByWindow(
 194                             mpViewShell->GetActiveWindow());
 195                     }
 196
 197                     if( pOutliner )
 198                         pOutliner->GetGlobalCharStretching( stretchX, stretchY );
 199
 200                     if(pOLV && !pOLV->GetSelection().HasRange())
 201                     {
 202                         if( mpViewShell && mpViewShell->GetViewShell() && mpViewShell->GetViewShell()->GetWindow() )
 203                         {
 204                             LanguageType nInputLang = mpViewShell->GetViewShell()->GetWindow()->GetInputLanguage();
 205                             if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
 206                                 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
 207                         }
 208                     }
 209                 }
 210
 211                 const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType );
 212                 if( pI )
 213                 {
 214                     if( nSlotId == SID_ATTR_CHAR_FONTHEIGHT )
 215                     {
 216                         SvxFontHeightItem aFontItem = dynamic_cast<const SvxFontHeightItem&>(*pI);
 217                         aFontItem.SetHeight(aFontItem.GetHeight(), stretchX, aFontItem.GetPropUnit());
 218                         aAttrSet.Put( aFontItem, nWhich );
 219                     }
 220                     else
 221                     {
 222                         aAttrSet.Put( *pI, nWhich );
 223                     }
 224                 }
 225                 else
 226                 {
 227                     aAttrSet.InvalidateItem( nWhich );
 228                 }
 229             }
 230             break;
 231
 232             case SID_STYLE_APPLY:
 233             case SID_STYLE_FAMILY2:
 234             {
 235                 SfxStyleSheet* pStyleSheet = mpView->GetStyleSheetFromMarked();
 236                 if( pStyleSheet )
 237                     rSet.Put( SfxTemplateItem( nWhich, pStyleSheet->GetName() ) );
 238                 else
 239                 {
 240                     rSet.Put( SfxTemplateItem( nWhich, OUString() ) );
 241                 }
 242             }
 243             break;
 244
 245             case SID_OUTLINE_LEFT:
 246             case SID_OUTLINE_RIGHT:
 247             case SID_OUTLINE_UP:
 248             case SID_OUTLINE_DOWN:
 249             {
 250                 bool bDisableLeft     = true;
 251                 bool bDisableRight    = true;
 252                 bool bDisableUp       = true;
 253                 bool bDisableDown     = true;
 254
 255                 //fdo#78151 it doesn't make sense to promote or demote outline levels in master view.
 256                 const DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >(mpViewShell);
 257                 const bool bInMasterView = pDrawViewShell && pDrawViewShell->GetEditMode() == EM_MASTERPAGE;
 258
 259                 if (!bInMasterView)
 260                 {
 261                     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 262
 263                     if (mpView->ISA(OutlineView))
 264                     {
 265                         pOLV = static_cast<OutlineView*>(mpView)->GetViewByWindow(
 266                             mpViewShell->GetActiveWindow());
 267                     }
 268
 269                     bool bOutlineViewSh = mpViewShell->ISA(OutlineViewShell);
 270
 271                     if (pOLV &&
 272                         ( pOLV->GetOutliner()->GetMode() == OUTLINERMODE_OUTLINEOBJECT || bOutlineViewSh ) )
 273                     {
 274                         // Outliner at outline-mode
 275                         ::Outliner* pOutl = pOLV->GetOutliner();
 276
 277                         std::vector<Paragraph*> aSelList;
 278                         pOLV->CreateSelectionList(aSelList);
 279                         Paragraph* pPara = aSelList.empty() ? NULL : *(aSelList.begin());
 280
 281                         // find out if we are a OutlineView
 282                         bool bIsOutlineView(OUTLINERMODE_OUTLINEVIEW == pOLV->GetOutliner()->GetMode());
 283
 284                         // This is ONLY for OutlineViews
 285                         if(bIsOutlineView)
 286                         {
 287                             // allow move up if position is 2 or greater OR it
 288                             // is a title object (and thus depth==1)
 289                             if(pOutl->GetAbsPos(pPara) > 1 || ( ::Outliner::HasParaFlag(pPara,ParaFlag::ISPAGE) && pOutl->GetAbsPos(pPara) > 0 ) )
 290                             {
 291                                 // not at top
 292                                 bDisableUp = false;
 293                             }
 294                         }
 295                         else
 296                         {
 297                             // old behaviour for OUTLINERMODE_OUTLINEOBJECT
 298                             if(pOutl->GetAbsPos(pPara) > 0)
 299                             {
 300                                 // not at top
 301                                 bDisableUp = false;
 302                             }
 303                         }
 304
 305                         for (std::vector<Paragraph*>::const_iterator iter = aSelList.begin(); iter != aSelList.end(); ++iter)
 306                         {
 307                             pPara = *iter;
 308
 309                             sal_Int16 nDepth = pOutl->GetDepth( pOutl->GetAbsPos( pPara ) );
 310
 311                             if (nDepth > 0 || (bOutlineViewSh && (nDepth <= 0) && !::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE )) )
 312                             {
 313                                 // not minimum depth
 314                                 bDisableLeft = false;
 315                             }
 316
 317                             if( (nDepth < pOLV->GetOutliner()->GetMaxDepth() && ( !bOutlineViewSh || pOutl->GetAbsPos(pPara) != 0 )) ||
 318                                 (bOutlineViewSh && (nDepth <= 0) && ::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ) && pOutl->GetAbsPos(pPara) != 0) )
 319                             {
 320                                 // not maximum depth and not at top
 321                                 bDisableRight = false;
 322                             }
 323                         }
 324
 325                         if ( ( pOutl->GetAbsPos(pPara) < pOutl->GetParagraphCount() - 1 ) &&
 326                              ( pOutl->GetParagraphCount() > 1 || !bOutlineViewSh) )
 327                         {
 328                             // not last paragraph
 329                             bDisableDown = false;
 330                         }
 331
 332                         // disable when first para and 2nd is not a title
 333                         pPara = aSelList.empty() ? NULL : *(aSelList.begin());
 334
 335                         if(!bDisableDown && bIsOutlineView
 336                             && pPara
 337                             && 0 == pOutl->GetAbsPos(pPara)
 338                             && pOutl->GetParagraphCount() > 1
 339                             && !::Outliner::HasParaFlag( pOutl->GetParagraph(1), ParaFlag::ISPAGE ) )
 340                         {
 341                             // Needs to be disabled
 342                             bDisableDown = true;
 343                         }
 344                     }
 345                 }
 346
 347                 if (bDisableLeft)
 348                     rSet.DisableItem(SID_OUTLINE_LEFT);
 349                 if (bDisableRight)
 350                     rSet.DisableItem(SID_OUTLINE_RIGHT);
 351                 if (bDisableUp)
 352                     rSet.DisableItem(SID_OUTLINE_UP);
 353                 if (bDisableDown)
 354                     rSet.DisableItem(SID_OUTLINE_DOWN);
 355             }
 356             break;
 357
 358             case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
 359             case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
 360             {
 361                 if ( bDisableVerticalText )
 362                 {
 363                     rSet.DisableItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT );
 364                     rSet.DisableItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM );
 365                 }
 366                 else
 367                 {
 368                     bool bLeftToRight = true;
 369
 370                     SdrOutliner* pOutl = mpView->GetTextEditOutliner();
 371                     if( pOutl )
 372                     {
 373                         if( pOutl->IsVertical() )
 374                             bLeftToRight = false;
 375                     }
 376                     else
 377                         bLeftToRight = static_cast<const SvxWritingModeItem&>( aAttrSet.Get( SDRATTR_TEXTDIRECTION ) ).GetValue() == com::sun::star::text::WritingMode_LR_TB;
 378
 379                     rSet.Put( SfxBoolItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT, bLeftToRight ) );
 380                     rSet.Put( SfxBoolItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM, !bLeftToRight ) );
 381
 382                     if( !bLeftToRight )
 383                         bDisableParagraphTextDirection = true;
 384                 }
 385             }
 386             break;
 387
 388             case SID_GROW_FONT_SIZE:
 389             case SID_SHRINK_FONT_SIZE:
 390             {
 391                 // todo
 392             }
 393             break;
 394
 395             case SID_THES:
 396             {
 397                 if (mpView->GetTextEditOutlinerView())
 398                 {
 399                     EditView & rEditView = mpView->GetTextEditOutlinerView()->GetEditView();
 400                     OUString        aStatusVal;
 401                     LanguageType    nLang = LANGUAGE_NONE;
 402                     bool bIsLookUpWord = GetStatusValueForThesaurusFromContext( aStatusVal, nLang, rEditView );
 403                     rSet.Put( SfxStringItem( SID_THES, aStatusVal ) );
 404
 405                     // disable "Thesaurus" context menu entry if there is nothing to look up
 406                     uno::Reference< linguistic2::XThesaurus > xThes( LinguMgr::GetThesaurus() );
 407                     if (!bIsLookUpWord ||
 408                         !xThes.is() || nLang == LANGUAGE_NONE || !xThes->hasLocale( LanguageTag( nLang). getLocale() ))
 409                         rSet.DisableItem( SID_THES );
 410                 }
 411                 else
 412                 {
 413                     rSet.DisableItem( SID_THES );
 414                 }
 415                 //! avoid putting the same item as SfxBoolItem at the end of this function
 416                 nSlotId = 0;
 417             }
 418             break;
 419
 420             default:
 421             break;
 422         }
 423
 424         nWhich = aIter.NextWhich();
 425     }
 426
 427     rSet.Put( aAttrSet, false ); // <- sal_False, so DontCare-Status gets acquired
 428
 429     // these are disabled in outline-mode
 430     if (!mpViewShell || !mpViewShell->ISA(DrawViewShell))
 431     {
 432         rSet.DisableItem( SID_ATTR_PARA_ADJUST_LEFT );
 433         rSet.DisableItem( SID_ATTR_PARA_ADJUST_RIGHT );
 434         rSet.DisableItem( SID_ATTR_PARA_ADJUST_CENTER );
 435         rSet.DisableItem( SID_ATTR_PARA_ADJUST_BLOCK );
 436         rSet.DisableItem( SID_ATTR_PARA_LINESPACE_10 );
 437         rSet.DisableItem( SID_ATTR_PARA_LINESPACE_15 );
 438         rSet.DisableItem( SID_ATTR_PARA_LINESPACE_20 );
 439         rSet.DisableItem( SID_PARASPACE_INCREASE );
 440         rSet.DisableItem( SID_PARASPACE_DECREASE );
 441         rSet.DisableItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM );
 442         rSet.DisableItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT );
 443         rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT );
 444         rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT );
 445     }
 446     else
 447     {
 448         // paragraph spacing
 449         OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
 450         if( pOLV )
 451         {
 452             ESelection aSel = pOLV->GetSelection();
 453             aSel.Adjust();
 454             sal_Int32 nStartPara = aSel.nStartPara;
 455             sal_Int32 nEndPara = aSel.nEndPara;
 456             if( !aSel.HasRange() )
 457             {
 458                 nStartPara = 0;
 459                 nEndPara = pOLV->GetOutliner()->GetParagraphCount() - 1;
 460             }
 461             long nUpper = 0L;
 462             for( sal_Int32 nPara = nStartPara; nPara <= nEndPara; nPara++ )
 463             {
 464                 const SfxItemSet& rItems = pOLV->GetOutliner()->GetParaAttribs( nPara );
 465                 const SvxULSpaceItem& rItem = static_cast<const SvxULSpaceItem&>( rItems.Get( EE_PARA_ULSPACE ) );
 466                 nUpper = std::max( nUpper, (long)rItem.GetUpper() );
 467             }
 468             if( nUpper == 0L )
 469                 rSet.DisableItem( SID_PARASPACE_DECREASE );
 470         }
 471         else
 472         {
 473             // never disabled at the moment!
 474             //rSet.DisableItem( SID_PARASPACE_INCREASE );
 475             //rSet.DisableItem( SID_PARASPACE_DECREASE );
 476         }
 477
 478         // paragraph justification
 479         SvxLRSpaceItem aLR = static_cast<const SvxLRSpaceItem&>( aAttrSet.Get( EE_PARA_LRSPACE ) );
 480         rSet.Put(aLR);
 481         SvxAdjust eAdj = static_cast<const SvxAdjustItem&>( aAttrSet.Get( EE_PARA_JUST ) ).GetAdjust();
 482         switch( eAdj )
 483         {
 484             case SVX_ADJUST_LEFT:
 485                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_LEFT, true ) );
 486             break;
 487             case SVX_ADJUST_CENTER:
 488                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_CENTER, true ) );
 489             break;
 490             case SVX_ADJUST_RIGHT:
 491                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_RIGHT, true ) );
 492             break;
 493             case SVX_ADJUST_BLOCK:
 494                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_BLOCK, true ) );
 495             break;
 496             default:
 497             break;
 498         }
 499
 500         Invalidate(SID_ATTR_PARA_ADJUST_LEFT);
 501         Invalidate(SID_ATTR_PARA_ADJUST_CENTER);
 502         Invalidate(SID_ATTR_PARA_ADJUST_RIGHT);
 503         Invalidate(SID_ATTR_PARA_ADJUST_BLOCK);
 504         Invalidate(SID_ATTR_PARA_LINESPACE);
 505         Invalidate(SID_ATTR_PARA_ULSPACE);
 506
 507         // paragraph text direction
 508         if( bDisableParagraphTextDirection )
 509         {
 510             rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT );
 511             rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT );
 512         }
 513         else
 514         {
 515             switch( static_cast<const SvxFrameDirectionItem&>( aAttrSet.Get( EE_PARA_WRITINGDIR ) ).GetValue() )
 516             {
 517                 case FRMDIR_VERT_TOP_LEFT:
 518                 case FRMDIR_VERT_TOP_RIGHT:
 519                 {
 520                     rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT );
 521                     rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT );
 522                 }
 523                 break;
 524
 525                 case FRMDIR_HORI_LEFT_TOP:
 526                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, true ) );
 527                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, false ) );
 528                 break;
 529
 530                 case FRMDIR_HORI_RIGHT_TOP:
 531                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, false ) );
 532                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, true ) );
 533                 break;
 534
 535                 // The case for the superordinate object is missing.
 536                 case FRMDIR_ENVIRONMENT:
 537                 {
 538                     SdDrawDocument& rDoc = mpView->GetDoc();
 539                     ::com::sun::star::text::WritingMode eMode = rDoc.GetDefaultWritingMode();
 540                     bool bIsLeftToRight(false);
 541
 542                     if(::com::sun::star::text::WritingMode_LR_TB == eMode
 543                         || ::com::sun::star::text::WritingMode_TB_RL == eMode)
 544                     {
 545                         bIsLeftToRight = true;
 546                     }
 547
 548                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, bIsLeftToRight ) );
 549                     rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, !bIsLeftToRight ) );
 550                 }
 551                 break;
 552             }
 553         }
 554
 555         SvxLRSpaceItem aLRSpace = static_cast<const SvxLRSpaceItem&>( aAttrSet.Get( EE_PARA_LRSPACE ) );
 556         aLRSpace.SetWhich(SID_ATTR_PARA_LRSPACE);
 557         rSet.Put(aLRSpace);
 558         Invalidate(SID_ATTR_PARA_LRSPACE);
 559         //Added by xuxu
 560         SfxItemState eState = aAttrSet.GetItemState( EE_PARA_LRSPACE );
 561         if ( eState == SfxItemState::DONTCARE )
 562         {
 563             rSet.InvalidateItem(EE_PARA_LRSPACE);
 564             rSet.InvalidateItem(SID_ATTR_PARA_LRSPACE);
 565         }
 566         sal_uInt16 nLineSpace = (sal_uInt16) static_cast<const SvxLineSpacingItem&>( aAttrSet.
 567                             Get( EE_PARA_SBL ) ).GetPropLineSpace();
 568         switch( nLineSpace )
 569         {
 570             case 100:
 571                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_10, true ) );
 572             break;
 573             case 150:
 574                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_15, true ) );
 575             break;
 576             case 200:
 577                 rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_20, true ) );
 578             break;
 579         }
 580     }
 581
 582     // justification (superscript, subscript) is also needed in outline-mode
 583     SvxEscapement eEsc = (SvxEscapement ) static_cast<const SvxEscapementItem&>(
 584                     aAttrSet.Get( EE_CHAR_ESCAPEMENT ) ).GetEnumValue();
 585
 586     if( eEsc == SVX_ESCAPEMENT_SUPERSCRIPT )
 587         rSet.Put( SfxBoolItem( SID_SET_SUPER_SCRIPT, true ) );
 588     else if( eEsc == SVX_ESCAPEMENT_SUBSCRIPT )
 589         rSet.Put( SfxBoolItem( SID_SET_SUB_SCRIPT, true ) );
 590 }
 591
 592 } // end of namespace sd
 593
 594 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */