svx/source/toolbars/fontworkbar.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 <svx/svdundo.hxx>
  21 #include <sfx2/app.hxx>
  22 #include <sfx2/request.hxx>
  23 #include <sfx2/objface.hxx>
  24 #include <sfx2/viewsh.hxx>
  25 #include "svx/unoapi.hxx"
  26 #include <com/sun/star/drawing/XShape.hpp>
  27 #include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
  28 #include <svx/dialmgr.hxx>
  29 #include <svx/svdoashp.hxx>
  30 #include <svx/dialogs.hrc>
  31 #include <svx/svdview.hxx>
  32 #include <svx/sdasitm.hxx>
  33 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
  34 #include <sfx2/bindings.hxx>
  35 #include <editeng/eeitem.hxx>
  36 #include <editeng/charscaleitem.hxx>
  37 #include <editeng/kernitem.hxx>
  38 #include <svx/sdrpaintwindow.hxx>
  39
  40 #include <svx/svxids.hrc>
  41 #include <svx/fontworkbar.hxx>
  42 #include "svx/fontworkgallery.hxx"
  43
  44
  45 using namespace ::svx;
  46 using namespace ::cppu;
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::beans;
  49 using namespace ::com::sun::star::uno;
  50
  51 void SetAlignmentState( SdrView* pSdrView, SfxItemSet& rSet )
  52 {
  53     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
  54     const size_t nCount = rMarkList.GetMarkCount();
  55
  56     sal_Int32   nAlignment = -1;
  57     for( size_t i = 0; i < nCount; ++i )
  58     {
  59         SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
  60         if( pObj->ISA(SdrObjCustomShape) )
  61         {
  62             sal_Int32 nOldAlignment = nAlignment;
  63             const SdrTextHorzAdjustItem&      rTextHorzAdjustItem    = static_cast<const SdrTextHorzAdjustItem&>(pObj->GetMergedItem( SDRATTR_TEXT_HORZADJUST ));
  64             const SdrTextFitToSizeTypeItem&   rTextFitToSizeTypeItem = static_cast<const SdrTextFitToSizeTypeItem&>(pObj->GetMergedItem( SDRATTR_TEXT_FITTOSIZE ));
  65             switch ( rTextHorzAdjustItem.GetValue() )
  66             {
  67                 case SDRTEXTHORZADJUST_LEFT   : nAlignment = 0; break;
  68                 case SDRTEXTHORZADJUST_CENTER : nAlignment = 1; break;
  69                 case SDRTEXTHORZADJUST_RIGHT  : nAlignment = 2; break;
  70                 case SDRTEXTHORZADJUST_BLOCK  :
  71                 {
  72                     if ( rTextFitToSizeTypeItem.GetValue() == SDRTEXTFIT_NONE )
  73                         nAlignment = 3;
  74                     else if ( rTextFitToSizeTypeItem.GetValue() == SDRTEXTFIT_ALLLINES )
  75                         nAlignment = 4;
  76                 }
  77             }
  78             if ( ( nOldAlignment != -1 ) && ( nOldAlignment != nAlignment ) )
  79             {
  80                 nAlignment = -1;
  81                 break;
  82             }
  83         }
  84     }
  85     rSet.Put( SfxInt32Item( SID_FONTWORK_ALIGNMENT, nAlignment ) );
  86 }
  87
  88 void SetCharacterSpacingState( SdrView* pSdrView, SfxItemSet& rSet )
  89 {
  90     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
  91     const size_t nCount = rMarkList.GetMarkCount();
  92
  93     sal_Int32   nCharacterSpacing = -1;
  94     for( size_t i = 0; i < nCount; ++i )
  95     {
  96         SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
  97         if( pObj->ISA(SdrObjCustomShape) )
  98         {
  99             sal_Int32 nOldCharacterSpacing = nCharacterSpacing;
 100             const SvxCharScaleWidthItem& rCharScaleWidthItem = static_cast<const SvxCharScaleWidthItem&>(pObj->GetMergedItem( EE_CHAR_FONTWIDTH ));
 101             nCharacterSpacing = rCharScaleWidthItem.GetValue();
 102             if ( ( nOldCharacterSpacing != -1 ) && ( nOldCharacterSpacing != nCharacterSpacing ) )
 103             {
 104                 nCharacterSpacing = -1;
 105                 break;
 106             }
 107         }
 108     }
 109     rSet.Put( SfxInt32Item( SID_FONTWORK_CHARACTER_SPACING, nCharacterSpacing ) );
 110 }
 111
 112
 113 void SetKernCharacterPairsState( SdrView* pSdrView, SfxItemSet& rSet )
 114 {
 115     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 116     const size_t nCount = rMarkList.GetMarkCount();
 117
 118     bool    bChecked = false;
 119     for( size_t i = 0; i < nCount; ++i )
 120     {
 121         SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
 122         if( pObj->ISA(SdrObjCustomShape) )
 123         {
 124             const SvxKerningItem& rKerningItem = static_cast<const SvxKerningItem&>(pObj->GetMergedItem( EE_CHAR_KERNING ));
 125             if ( rKerningItem.GetValue() )
 126                 bChecked = true;
 127         }
 128     }
 129     rSet.Put( SfxBoolItem( SID_FONTWORK_KERN_CHARACTER_PAIRS, bChecked ) );
 130 }
 131
 132 void SetFontWorkShapeTypeState( SdrView* pSdrView, SfxItemSet& rSet )
 133 {
 134     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 135     const size_t nCount = rMarkList.GetMarkCount();
 136
 137     OUString aFontWorkShapeType;
 138
 139     for( size_t i = 0; i < nCount; ++i )
 140     {
 141         SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
 142         if( pObj->ISA( SdrObjCustomShape ) )
 143         {
 144             const OUString sType( "Type" );
 145             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )));
 146             const Any* pAny = aGeometryItem.GetPropertyValueByName( sType );
 147             if( pAny )
 148             {
 149                 OUString aType;
 150                 if ( *pAny >>= aType )
 151                 {
 152                     if ( !aFontWorkShapeType.isEmpty() )
 153                     {
 154                         if ( !aFontWorkShapeType.equals( aType ) )  // different FontWorkShapeTypes selected ?
 155                         {
 156                             aFontWorkShapeType.clear();
 157                             break;
 158                         }
 159                     }
 160                     aFontWorkShapeType = aType;
 161                 }
 162             }
 163         }
 164     }
 165     rSet.Put( SfxStringItem( SID_FONTWORK_SHAPE_TYPE, aFontWorkShapeType ) );
 166 }
 167
 168 // Standardinterface deklarieren (Die Slotmap darf nicht leer sein, also
 169 // tragen wir etwas ein, was hier (hoffentlich) nie vorkommt).
 170 static SfxSlot aFontworkBarSlots_Impl[] =
 171 {
 172     { 0, 0, 0, SfxSlotMode::NONE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 173 };
 174
 175 SFX_IMPL_INTERFACE(FontworkBar, SfxShell)
 176
 177 void FontworkBar::InitInterface_Impl()
 178 {
 179     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, RID_SVX_FONTWORK_BAR);
 180 }
 181
 182 TYPEINIT1( FontworkBar, SfxShell );
 183
 184 FontworkBar::FontworkBar(SfxViewShell* pViewShell )
 185 : SfxShell(pViewShell)
 186 {
 187     DBG_ASSERT( pViewShell, "svx::FontworkBar::FontworkBar(), I need a viewshell!" );
 188     if( pViewShell )
 189         SetPool(&pViewShell->GetPool());
 190
 191     SetHelpId( SVX_INTERFACE_FONTWORK_BAR );
 192     SetName( SVX_RESSTR( RID_SVX_FONTWORK_BAR ));
 193 }
 194
 195 FontworkBar::~FontworkBar()
 196 {
 197     SetRepeatTarget(NULL);
 198 }
 199
 200 static vcl::Window* ImpGetViewWin(SdrView* pView)
 201 {
 202     if( pView )
 203     {
 204         const sal_uInt32 nCount(pView->PaintWindowCount());
 205         for(sal_uInt32 nNum(0L); nNum < nCount; nNum++)
 206         {
 207             OutputDevice* pOut = &(pView->GetPaintWindow(nNum)->GetOutputDevice());
 208
 209             if(OUTDEV_WINDOW == pOut->GetOutDevType())
 210             {
 211                 return static_cast<vcl::Window*>(pOut);
 212             }
 213         }
 214     }
 215
 216     return 0L;
 217 }
 218
 219 namespace svx {
 220 bool checkForSelectedFontWork( SdrView* pSdrView, sal_uInt32& nCheckStatus )
 221 {
 222     if ( nCheckStatus & 2 )
 223         return ( nCheckStatus & 1 ) != 0;
 224
 225     static const char sTextPath[] = "TextPath";
 226
 227     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 228     const size_t nCount = rMarkList.GetMarkCount();
 229     bool bFound = false;
 230     for(size_t i=0; (i<nCount) && !bFound ; ++i)
 231     {
 232         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 233         if( pObj->ISA(SdrObjCustomShape) )
 234         {
 235             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )));
 236             const Any* pAny = aGeometryItem.GetPropertyValueByName( sTextPath, sTextPath );
 237             if( pAny )
 238                 *pAny >>= bFound;
 239         }
 240     }
 241     if ( bFound )
 242         nCheckStatus |= 1;
 243     nCheckStatus |= 2;
 244     return bFound;
 245 }
 246 }
 247
 248 static void impl_execute( SdrView*, SfxRequest& rReq, SdrCustomShapeGeometryItem& rGeometryItem, SdrObject* pObj )
 249 {
 250     static const char  sTextPath[] = "TextPath";
 251     static const char  sSameLetterHeights[] = "SameLetterHeights";
 252
 253     sal_uInt16 nSID = rReq.GetSlot();
 254     switch( nSID )
 255     {
 256         case SID_FONTWORK_SAME_LETTER_HEIGHTS:
 257         {
 258             com::sun::star::uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sTextPath, sSameLetterHeights );
 259             if( pAny )
 260             {
 261                 bool bOn = false;
 262                 (*pAny) >>= bOn;
 263                 bOn = !bOn;
 264                 (*pAny) <<= bOn;
 265             }
 266         }
 267         break;
 268
 269         case SID_FONTWORK_ALIGNMENT:
 270         {
 271             if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_FONTWORK_ALIGNMENT ) == SfxItemState::SET )
 272             {
 273                 sal_Int32 nValue = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_FONTWORK_ALIGNMENT))->GetValue();
 274                 if ( ( nValue >= 0 ) && ( nValue < 5 ) )
 275                 {
 276                     SdrFitToSizeType eFTS = SDRTEXTFIT_NONE;
 277                     SdrTextHorzAdjust eHorzAdjust;
 278                     switch ( nValue )
 279                     {
 280                         case 4 : eFTS = SDRTEXTFIT_ALLLINES; // passthrough
 281                         case 3 : eHorzAdjust = SDRTEXTHORZADJUST_BLOCK; break;
 282                         default: eHorzAdjust = SDRTEXTHORZADJUST_LEFT; break;
 283                         case 1 : eHorzAdjust = SDRTEXTHORZADJUST_CENTER; break;
 284                         case 2 : eHorzAdjust = SDRTEXTHORZADJUST_RIGHT; break;
 285                     }
 286                     pObj->SetMergedItem( SdrTextHorzAdjustItem( eHorzAdjust ) );
 287                     pObj->SetMergedItem( SdrTextFitToSizeTypeItem( eFTS ) );
 288                     pObj->BroadcastObjectChange();
 289                 }
 290             }
 291         }
 292         break;
 293
 294         case SID_FONTWORK_CHARACTER_SPACING:
 295         {
 296             if( rReq.GetArgs() && ( rReq.GetArgs()->GetItemState( SID_FONTWORK_CHARACTER_SPACING ) == SfxItemState::SET ) )
 297             {
 298                 sal_Int32 nCharSpacing = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_FONTWORK_CHARACTER_SPACING))->GetValue();
 299                 pObj->SetMergedItem( SvxCharScaleWidthItem( (sal_uInt16)nCharSpacing, EE_CHAR_FONTWIDTH ) );
 300                 pObj->BroadcastObjectChange();
 301             }
 302         }
 303         break;
 304
 305         case SID_FONTWORK_KERN_CHARACTER_PAIRS:
 306         {
 307             if( rReq.GetArgs() && ( rReq.GetArgs()->GetItemState( SID_FONTWORK_KERN_CHARACTER_PAIRS ) == SfxItemState::SET ) )
 308             {
 309                 // sal_Bool bKernCharacterPairs = ((const SfxBoolItem*)rReq.GetArgs()->GetItem(SID_FONTWORK_KERN_CHARACTER_PAIRS))->GetValue();
 310 //TODO:             pObj->SetMergedItem( SvxCharScaleWidthItem( (sal_uInt16)nCharSpacing, EE_CHAR_FONTWIDTH ) );
 311                 pObj->BroadcastObjectChange();
 312             }
 313         }
 314         break;
 315     }
 316 }
 317
 318 #include "svx/gallery.hxx"
 319 #include <svx/fmmodel.hxx>
 320 #include <svx/fmpage.hxx>
 321 #include <svl/itempool.hxx>
 322
 323 void GetGeometryForCustomShape( SdrCustomShapeGeometryItem& rGeometryItem, const OUString& rCustomShape )
 324 {
 325     const OUString sType( "Type" );
 326
 327     com::sun::star::beans::PropertyValue aPropVal;
 328     aPropVal.Name = sType;
 329     aPropVal.Value <<= rCustomShape;
 330     rGeometryItem.SetPropertyValue( aPropVal );
 331
 332     const OUString sAdjustmentValues( "AdjustmentValues" );
 333     const OUString sCoordinateOrigin( "CoordinateOrigin" );
 334     const OUString sCoordinateSize( "CoordinateSize" );
 335     const OUString sEquations( "Equations" );
 336     const OUString sHandles( "Handles" );
 337     const OUString sPath( "Path" );
 338     rGeometryItem.ClearPropertyValue( sAdjustmentValues );
 339     rGeometryItem.ClearPropertyValue( sCoordinateOrigin );
 340     rGeometryItem.ClearPropertyValue( sCoordinateSize );
 341     rGeometryItem.ClearPropertyValue( sEquations );
 342     rGeometryItem.ClearPropertyValue( sHandles );
 343     rGeometryItem.ClearPropertyValue( sPath );
 344
 345     /* SJ: CustomShapes that are available in the gallery are having the highest
 346        priority, so we will take a look there before taking the internal default */
 347
 348     if ( GalleryExplorer::GetSdrObjCount( GALLERY_THEME_POWERPOINT ) )
 349     {
 350         std::vector< OUString > aObjList;
 351         if ( GalleryExplorer::FillObjListTitle( GALLERY_THEME_POWERPOINT, aObjList ) )
 352         {
 353             sal_uInt16 i;
 354             for ( i = 0; i < aObjList.size(); i++ )
 355             {
 356                 if ( aObjList[ i ].equalsIgnoreAsciiCase( rCustomShape ) )
 357                 {
 358                     FmFormModel aFormModel;
 359                     SfxItemPool& rPool = aFormModel.GetItemPool();
 360                     rPool.FreezeIdRanges();
 361                     if ( GalleryExplorer::GetSdrObj( GALLERY_THEME_POWERPOINT, i, &aFormModel ) )
 362                     {
 363                         const SdrObject* pSourceObj = aFormModel.GetPage( 0 )->GetObj( 0 );
 364                         if( pSourceObj )
 365                         {
 366                             PropertyValue aPropVal_;
 367                             const SdrCustomShapeGeometryItem& rSourceGeometry = static_cast<const SdrCustomShapeGeometryItem&>(pSourceObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ));
 368                             const com::sun::star::uno::Any* pAny = rSourceGeometry.GetPropertyValueByName( sType );
 369                             if ( pAny )
 370                             {
 371                                 aPropVal_.Name = sType;
 372                                 aPropVal_.Value = *pAny;
 373                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 374                             }
 375                             pAny = rSourceGeometry.GetPropertyValueByName( sAdjustmentValues );
 376                             if ( pAny )
 377                             {
 378                                 aPropVal_.Name = sAdjustmentValues;
 379                                 aPropVal_.Value = *pAny;
 380                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 381                             }
 382                             pAny = rSourceGeometry.GetPropertyValueByName( sCoordinateOrigin );
 383                             if ( pAny )
 384                             {
 385                                 aPropVal_.Name = sCoordinateOrigin;
 386                                 aPropVal_.Value = *pAny;
 387                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 388                             }
 389                             pAny = rSourceGeometry.GetPropertyValueByName( sCoordinateSize );
 390                             if ( pAny )
 391                             {
 392                                 aPropVal_.Name = sCoordinateSize;
 393                                 aPropVal_.Value = *pAny;
 394                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 395                             }
 396                             pAny = rSourceGeometry.GetPropertyValueByName( sEquations );
 397                             if ( pAny )
 398                             {
 399                                 aPropVal_.Name = sEquations;
 400                                 aPropVal_.Value = *pAny;
 401                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 402                             }
 403                             pAny = rSourceGeometry.GetPropertyValueByName( sHandles );
 404                             if ( pAny )
 405                             {
 406                                 aPropVal_.Name = sHandles;
 407                                 aPropVal_.Value = *pAny;
 408                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 409                             }
 410                             pAny = rSourceGeometry.GetPropertyValueByName( sPath );
 411                             if ( pAny )
 412                             {
 413                                 aPropVal_.Name = sPath;
 414                                 aPropVal_.Value = *pAny;
 415                                 rGeometryItem.SetPropertyValue( aPropVal_ );
 416                             }
 417                         }
 418                     }
 419                 }
 420             }
 421         }
 422     }
 423 }
 424
 425
 426 void FontworkBar::execute( SdrView* pSdrView, SfxRequest& rReq, SfxBindings& rBindings )
 427 {
 428     sal_uInt16 nStrResId = 0;
 429
 430     sal_uInt16 nSID = rReq.GetSlot();
 431     switch( nSID )
 432     {
 433         case SID_FONTWORK_GALLERY_FLOATER:
 434         {
 435             ScopedVclPtrInstance< FontWorkGalleryDialog > aDlg( pSdrView, ImpGetViewWin(pSdrView), nSID );
 436             aDlg->Execute();
 437         }
 438         break;
 439
 440         case SID_FONTWORK_SHAPE_TYPE:
 441         {
 442             OUString aCustomShape;
 443             const SfxItemSet* pArgs = rReq.GetArgs();
 444             if ( pArgs )
 445             {
 446                 const SfxStringItem& rItm = static_cast<const SfxStringItem&>(pArgs->Get( rReq.GetSlot() ));
 447                 aCustomShape = rItm.GetValue();
 448             }
 449             if ( !aCustomShape.isEmpty() )
 450             {
 451                 const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 452                 const size_t nCount = rMarkList.GetMarkCount();
 453                 for( size_t i = 0; i < nCount; ++i )
 454                 {
 455                     SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
 456                     if( pObj->ISA(SdrObjCustomShape) )
 457                     {
 458                         const bool bUndo = pSdrView->IsUndoEnabled();
 459
 460                         if( bUndo )
 461                         {
 462                             OUString aStr( SVX_RESSTR( RID_SVXSTR_UNDO_APPLY_FONTWORK_SHAPE ) );
 463                             pSdrView->BegUndo( aStr );
 464                             pSdrView->AddUndo( pSdrView->GetModel()->GetSdrUndoFactory().CreateUndoAttrObject( *pObj ) );
 465                         }
 466                         SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )));
 467                         GetGeometryForCustomShape( aGeometryItem, aCustomShape );
 468                         pObj->SetMergedItem( aGeometryItem );
 469
 470                         Reference< drawing::XShape > aXShape = GetXShapeForSdrObject( static_cast<SdrObjCustomShape*>(pObj) );
 471                         if ( aXShape.is() )
 472                         {
 473                             Reference< drawing::XEnhancedCustomShapeDefaulter > xDefaulter( aXShape, UNO_QUERY );
 474                             if( xDefaulter.is() )
 475                                 xDefaulter->createCustomShapeDefaults( aCustomShape );
 476                         }
 477
 478                         pObj->BroadcastObjectChange();
 479                         if( bUndo )
 480                             pSdrView->EndUndo();
 481                         pSdrView->AdjustMarkHdl(); //HMH sal_True );
 482                         rBindings.Invalidate( SID_FONTWORK_SHAPE_TYPE );
 483                     }
 484                 }
 485             }
 486         }
 487         break;
 488
 489         case SID_FONTWORK_CHARACTER_SPACING_DIALOG :
 490         {
 491             if( rReq.GetArgs() && ( rReq.GetArgs()->GetItemState( SID_FONTWORK_CHARACTER_SPACING ) == SfxItemState::SET ) )
 492             {
 493                 sal_Int32 nCharSpacing = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_FONTWORK_CHARACTER_SPACING))->GetValue();
 494                 ScopedVclPtrInstance< FontworkCharacterSpacingDialog > aDlg( nullptr, nCharSpacing );
 495                 sal_uInt16 nRet = aDlg->Execute();
 496                 if( nRet != 0 )
 497                 {
 498                     SfxInt32Item aItem( SID_FONTWORK_CHARACTER_SPACING, aDlg->getScale() );
 499                     SfxPoolItem* aItems[] = { &aItem, 0 };
 500                     rBindings.Execute( SID_FONTWORK_CHARACTER_SPACING, (const SfxPoolItem**)aItems );
 501                 }
 502             }
 503         }
 504         break;
 505
 506         case SID_FONTWORK_SHAPE:
 507         case SID_FONTWORK_ALIGNMENT:
 508         {
 509             if ( !nStrResId )
 510                 nStrResId = RID_SVXSTR_UNDO_APPLY_FONTWORK_ALIGNMENT;
 511         }   // PASSTROUGH
 512         case SID_FONTWORK_CHARACTER_SPACING:
 513         {
 514             if ( !nStrResId )
 515                 nStrResId = RID_SVXSTR_UNDO_APPLY_FONTWORK_CHARACTER_SPACING;
 516         }   // PASSTROUGH
 517         case SID_FONTWORK_KERN_CHARACTER_PAIRS:
 518         {
 519             if ( !nStrResId )
 520                 nStrResId = RID_SVXSTR_UNDO_APPLY_FONTWORK_CHARACTER_SPACING;
 521         }   // PASSTROUGH
 522         case SID_FONTWORK_SAME_LETTER_HEIGHTS:
 523         {
 524             if ( !nStrResId )
 525                 nStrResId = RID_SVXSTR_UNDO_APPLY_FONTWORK_SAME_LETTER_HEIGHT;
 526
 527             const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 528             const size_t nCount = rMarkList.GetMarkCount();
 529             for( size_t i = 0; i < nCount; ++i )
 530             {
 531                 SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 532                 if( pObj->ISA(SdrObjCustomShape) )
 533                 {
 534                     const bool bUndo = pSdrView->IsUndoEnabled();
 535                     if( bUndo )
 536                     {
 537                         OUString aStr( SVX_RESSTR( nStrResId ) );
 538                         pSdrView->BegUndo( aStr );
 539                         pSdrView->AddUndo( pSdrView->GetModel()->GetSdrUndoFactory().CreateUndoAttrObject( *pObj ) );
 540                     }
 541                     SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )));
 542                     impl_execute( pSdrView, rReq, aGeometryItem, pObj );
 543                     pObj->SetMergedItem( aGeometryItem );
 544                     pObj->BroadcastObjectChange();
 545                     if( bUndo )
 546                         pSdrView->EndUndo();
 547                 }
 548             }
 549         }
 550         break;
 551     };
 552 }
 553
 554 void FontworkBar::getState( SdrView* pSdrView, SfxItemSet& rSet )
 555 {
 556     sal_uInt32 nCheckStatus = 0;
 557
 558     if ( rSet.GetItemState( SID_FONTWORK_ALIGNMENT_FLOATER ) != SfxItemState::UNKNOWN )
 559     {
 560         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 561             rSet.DisableItem( SID_FONTWORK_ALIGNMENT_FLOATER );
 562     }
 563     if ( rSet.GetItemState( SID_FONTWORK_ALIGNMENT ) != SfxItemState::UNKNOWN )
 564     {
 565         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 566             rSet.DisableItem( SID_FONTWORK_ALIGNMENT );
 567         else
 568             SetAlignmentState( pSdrView, rSet );
 569     }
 570     if ( rSet.GetItemState( SID_FONTWORK_CHARACTER_SPACING_FLOATER ) != SfxItemState::UNKNOWN )
 571     {
 572         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 573             rSet.DisableItem( SID_FONTWORK_CHARACTER_SPACING_FLOATER );
 574     }
 575     if ( rSet.GetItemState( SID_FONTWORK_CHARACTER_SPACING ) != SfxItemState::UNKNOWN )
 576     {
 577         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 578             rSet.DisableItem( SID_FONTWORK_CHARACTER_SPACING );
 579         else
 580             SetCharacterSpacingState( pSdrView, rSet );
 581     }
 582     if ( rSet.GetItemState( SID_FONTWORK_KERN_CHARACTER_PAIRS ) != SfxItemState::UNKNOWN )
 583     {
 584         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 585             rSet.DisableItem( SID_FONTWORK_KERN_CHARACTER_PAIRS );
 586         else
 587             SetKernCharacterPairsState( pSdrView, rSet );
 588     }
 589     if ( rSet.GetItemState( SID_FONTWORK_SAME_LETTER_HEIGHTS ) != SfxItemState::UNKNOWN )
 590     {
 591         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus ) )
 592             rSet.DisableItem( SID_FONTWORK_SAME_LETTER_HEIGHTS );
 593     }
 594     if ( rSet.GetItemState( SID_FONTWORK_SHAPE_TYPE ) != SfxItemState::UNKNOWN )
 595     {
 596         if ( !checkForSelectedFontWork( pSdrView, nCheckStatus  ) )
 597             rSet.DisableItem( SID_FONTWORK_SHAPE_TYPE );
 598         else
 599             SetFontWorkShapeTypeState( pSdrView, rSet );
 600     }
 601 }
 602
 603 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */