sd/source/ui/func/futempl.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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  21 #include <com/sun/star/beans/XPropertySet.hpp>
  22 #include <com/sun/star/container/XNameAccess.hpp>
  23 #include <com/sun/star/frame/XModel.hpp>
  24
  25 #include <futempl.hxx>
  26
  27 #include <svx/svxids.hrc>
  28 #include <sfx2/bindings.hxx>
  29 #include <sfx2/dispatch.hxx>
  30 #include <editeng/eeitem.hxx>
  31 #include <sfx2/request.hxx>
  32 #include <sfx2/sfxdlg.hxx>
  33 #include <editeng/numitem.hxx>
  34 #include <svx/svdopage.hxx>
  35 #include <editeng/colritem.hxx>
  36 #include <editeng/brushitem.hxx>
  37 #include <svx/svditer.hxx>
  38 #include <svx/sdr/properties/properties.hxx>
  39 #include <svl/intitem.hxx>
  40
  41 #include <sfx2/viewfrm.hxx>
  42 #include <svx/xlndsit.hxx>
  43 #include <svx/xlnstit.hxx>
  44 #include <svx/xlnedit.hxx>
  45 #include <svx/xbtmpit.hxx>
  46 #include <svx/xflgrit.hxx>
  47 #include <svx/xflftrit.hxx>
  48 #include <svx/xflhtit.hxx>
  49 #include <o3tl/string_view.hxx>
  50 #include <app.hrc>
  51 #include <stlsheet.hxx>
  52 #include <sdpage.hxx>
  53 #include <stlpool.hxx>
  54 #include <sdmod.hxx>
  55 #include <View.hxx>
  56 #include <drawdoc.hxx>
  57 #include <DrawDocShell.hxx>
  58 #include <DrawViewShell.hxx>
  59 #include <ViewShell.hxx>
  60
  61 #include <strings.hrc>
  62 #include <prlayout.hxx>
  63 #include <sdresid.hxx>
  64 #include <OutlineView.hxx>
  65 #include <sdabstdlg.hxx>
  66 #include <memory>
  67
  68 using namespace com::sun::star::uno;
  69 using namespace com::sun::star::container;
  70 using namespace com::sun::star::beans;
  71 using namespace com::sun::star::style;
  72
  73 namespace sd
  74 {
  75
  76
  77 FuTemplate::FuTemplate (
  78     ViewShell* pViewSh,
  79     ::sd::Window* pWin,
  80     ::sd::View* pView,
  81     SdDrawDocument* pDoc,
  82     SfxRequest& rReq )
  83     : FuPoor( pViewSh, pWin, pView, pDoc, rReq )
  84 {
  85 }
  86
  87 rtl::Reference<FuPoor> FuTemplate::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
  88 {
  89     rtl::Reference<FuPoor> xFunc( new FuTemplate( pViewSh, pWin, pView, pDoc, rReq ) );
  90     xFunc->DoExecute(rReq);
  91     return xFunc;
  92 }
  93
  94 void FuTemplate::DoExecute( SfxRequest& rReq )
  95 {
  96     const SfxItemSet* pArgs = rReq.GetArgs();
  97     sal_uInt16 nSId = rReq.GetSlot();
  98
  99     // get StyleSheet parameter
 100     SfxStyleSheetBasePool* pSSPool = mpDoc->GetDocSh()->GetStyleSheetPool();
 101     SfxStyleSheetBase* pStyleSheet = nullptr;
 102
 103     const SfxPoolItem* pItem;
 104     SfxStyleFamily nFamily = SfxStyleFamily(USHRT_MAX);
 105     if( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILY,
 106         false, &pItem ))
 107     {
 108         nFamily = static_cast<SfxStyleFamily>( pArgs->Get( SID_STYLE_FAMILY ).GetValue());
 109     }
 110     else if( pArgs && SfxItemState::SET == pArgs->GetItemState( SID_STYLE_FAMILYNAME,
 111         false, &pItem ))
 112     {
 113         OUString sFamily = pArgs->Get( SID_STYLE_FAMILYNAME ).GetValue();
 114         if (sFamily == "graphics")
 115             nFamily = SfxStyleFamily::Para;
 116         else
 117             nFamily = SfxStyleFamily::Pseudo;
 118     }
 119
 120     OUString aStyleName;
 121     sal_uInt16 nRetMask = static_cast<sal_uInt16>(SfxStyleSearchBits::All);
 122
 123     switch( nSId )
 124     {
 125         case SID_STYLE_APPLY:
 126         case SID_STYLE_EDIT:
 127         case SID_STYLE_DELETE:
 128         case SID_STYLE_HIDE:
 129         case SID_STYLE_SHOW:
 130         case SID_STYLE_FAMILY:
 131         case SID_STYLE_NEW_BY_EXAMPLE:
 132         {
 133             const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_APPLY_STYLE);
 134             const SfxStringItem* pFamilyItem = rReq.GetArg<SfxStringItem>(SID_STYLE_FAMILYNAME);
 135             if ( pFamilyItem && pNameItem )
 136             {
 137                 try
 138                 {
 139                     Reference< XStyleFamiliesSupplier > xModel(mpDoc->GetDocSh()->GetModel(), UNO_QUERY_THROW );
 140                     Reference< XNameAccess > xCont( xModel->getStyleFamilies() );
 141                     Reference< XNameAccess > xStyles( xCont->getByName(pFamilyItem->GetValue()), UNO_QUERY_THROW );
 142                     Reference< XPropertySet > xInfo( xStyles->getByName( pNameItem->GetValue() ), UNO_QUERY_THROW );
 143
 144                     OUString aUIName;
 145                     xInfo->getPropertyValue( u"DisplayName"_ustr ) >>= aUIName;
 146                     if ( !aUIName.isEmpty() )
 147                         rReq.AppendItem( SfxStringItem( nSId, aUIName ) );
 148                 }
 149                 catch( Exception& )
 150                 {
 151                 }
 152             }
 153
 154             if (pArgs && pArgs->GetItemState(nSId) == SfxItemState::SET)
 155                 aStyleName = static_cast<const SfxStringItem &>( pArgs->Get( nSId ) ).GetValue();
 156         }
 157     }
 158
 159     switch( nSId )
 160     {
 161         case SID_STYLE_NEW:
 162         {
 163             SfxStyleSheetBase *p = pSSPool->Find(aStyleName, nFamily );
 164             if(p)
 165             {
 166                 pSSPool->Remove(p);
 167                 p = nullptr;
 168             }
 169             pStyleSheet = &pSSPool->Make( aStyleName, nFamily, SfxStyleSearchBits::UserDefined );
 170
 171             if (pArgs && pArgs->GetItemState(SID_STYLE_REFERENCE) == SfxItemState::SET)
 172             {
 173                 OUString aParentName( pArgs->Get(SID_STYLE_REFERENCE).GetValue());
 174                 pStyleSheet->SetParent(aParentName);
 175             }
 176             else
 177             {
 178                 pStyleSheet->SetParent(SdResId(STR_STANDARD_STYLESHEET_NAME));
 179             }
 180         }
 181         break;
 182
 183         case SID_STYLE_NEW_BY_EXAMPLE:
 184         {
 185             // at the moment, the dialog to enter the name of the template is still opened
 186             SfxStyleSheetBase *p = pSSPool->Find(aStyleName, nFamily );
 187             if(p)
 188             {
 189                 pSSPool->Remove(p);
 190                 p = nullptr;
 191             }
 192             pStyleSheet = &pSSPool->Make( aStyleName, nFamily, SfxStyleSearchBits::UserDefined );
 193             pStyleSheet->SetParent(SdResId(STR_STANDARD_STYLESHEET_NAME));
 194         }
 195         break;
 196
 197         case SID_STYLE_EDIT:
 198             pStyleSheet = pSSPool->Find( aStyleName, nFamily);
 199         break;
 200
 201         case SID_STYLE_DELETE:
 202             pStyleSheet = pSSPool->Find( aStyleName, nFamily);
 203             if( pStyleSheet )
 204             {
 205                 pSSPool->Remove( pStyleSheet );
 206                 nRetMask = sal_uInt16(true);
 207                 mpDoc->SetChanged();
 208             }
 209             else
 210             {
 211                 nRetMask = sal_uInt16(false);
 212             }
 213         break;
 214
 215         case SID_STYLE_HIDE:
 216         case SID_STYLE_SHOW:
 217             pStyleSheet = pSSPool->Find( aStyleName, nFamily);
 218             pStyleSheet->SetHidden( nSId == SID_STYLE_HIDE );
 219             nRetMask = sal_uInt16(true);
 220         break;
 221
 222         case SID_STYLE_APPLY:
 223             // apply the template to the document
 224             pStyleSheet = pSSPool->Find( aStyleName, nFamily);
 225
 226             // do not set presentation styles, they will be set implicit
 227             if ( pStyleSheet && pStyleSheet->GetFamily() != SfxStyleFamily::Pseudo )
 228             {
 229                 SfxStyleSheet* pOldStyleSheet = mpView->GetStyleSheet();
 230                 OUString aStr;
 231
 232                 if( // if the object had no style sheet, allow all
 233                     !pOldStyleSheet ||
 234
 235                     // allow if old and new style sheet has same family
 236                     pStyleSheet->GetFamily() == pOldStyleSheet->GetFamily() ||
 237
 238                     // allow if old was background objects and new is graphics
 239                     (pStyleSheet->GetFamily() == SfxStyleFamily::Para && pOldStyleSheet->GetHelpId( aStr ) == HID_PSEUDOSHEET_BACKGROUNDOBJECTS) ||
 240
 241                     // allow if old was presentation and we are a drawing document
 242                     (pOldStyleSheet->GetFamily() == SfxStyleFamily::Page && mpDoc->GetDocumentType() == DocumentType::Draw) )
 243                 {
 244                     mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));
 245                     mpDoc->SetChanged();
 246                     mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
 247                 }
 248             }
 249         break;
 250
 251         case SID_STYLE_WATERCAN:
 252         {
 253             if (SdModule* mod = SdModule::get(); !mod->GetWaterCan())
 254             {
 255                 if (pArgs && pArgs->GetItemState( nSId ) == SfxItemState::SET)
 256                 {
 257                     aStyleName = static_cast<const SfxStringItem &>( pArgs->Get( nSId ) ).GetValue();
 258                     mod->SetWaterCan(true);
 259                     pStyleSheet = pSSPool->Find( aStyleName, nFamily);
 260                 }
 261                 // no presentation object templates, they are only allowed implicitly
 262                 if( pStyleSheet && pStyleSheet->GetFamily() != SfxStyleFamily::Pseudo )
 263                 {
 264                     static_cast<SdStyleSheetPool*>( pSSPool )->SetActualStyleSheet( pStyleSheet );
 265
 266                     // we switch explicitly into selection mode
 267                     mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT,
 268                                         SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 269
 270                 }
 271                 else
 272                     mod->SetWaterCan(false);
 273             }
 274             else
 275             {
 276                 mod->SetWaterCan(false);
 277                 // we have to re-enable to tools-bar
 278                 mpViewShell->Invalidate();
 279             }
 280         }
 281         break;
 282
 283         default:
 284         break;
 285     }
 286
 287     switch( nSId )
 288     {
 289         case SID_STYLE_NEW:
 290         case SID_STYLE_EDIT:
 291         {
 292             PresentationObjects ePO = PresentationObjects::Outline_1;
 293
 294             if( pStyleSheet )
 295             {
 296                 ScopedVclPtr<SfxAbstractTabDialog> pStdDlg;
 297                 ScopedVclPtr<SfxAbstractTabDialog> pPresDlg;
 298                 SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 299
 300                 SfxStyleFamily eFamily = pStyleSheet->GetFamily();
 301
 302                 if (eFamily == SfxStyleFamily::Para)
 303                 {
 304                     pStdDlg.disposeAndReset(pFact ? pFact->CreateSdTabTemplateDlg(mpViewShell->GetFrameWeld(), mpDoc->GetDocSh(), *pStyleSheet, mpDoc, mpView) : nullptr);
 305                 }
 306                 else if (eFamily == SfxStyleFamily::Pseudo)
 307                 {
 308                     OUString aName(pStyleSheet->GetName());
 309                     bool bBackground = false;
 310                     bool bOldDocInOtherLanguage = false;
 311
 312                     if (aName == SdResId(STR_PSEUDOSHEET_TITLE))
 313                     {
 314                         ePO    = PresentationObjects::Title;
 315                     }
 316                     else if (aName == SdResId(STR_PSEUDOSHEET_SUBTITLE))
 317                     {
 318                         ePO    = PresentationObjects::Subtitle;
 319                     }
 320                     else if (aName ==
 321                              SdResId(STR_PSEUDOSHEET_BACKGROUND))
 322                     {
 323                         bBackground = true;
 324                         ePO    = PresentationObjects::Background;
 325                     }
 326                     else if (aName ==
 327                              SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS))
 328                     {
 329                         ePO    = PresentationObjects::BackgroundObjects;
 330                     }
 331                     else if (aName ==
 332                              SdResId(STR_PSEUDOSHEET_NOTES))
 333                     {
 334                         ePO    = PresentationObjects::Notes;
 335                     }
 336                     else if(aName.indexOf(SdResId(STR_PSEUDOSHEET_OUTLINE)) != -1)
 337                     {
 338                         OUString aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE));
 339                         // determine number, mind the blank between name and number
 340                         std::u16string_view aNumStr(aName.subView(aOutlineStr.getLength() + 1));
 341                         sal_uInt16 nLevel = static_cast<sal_uInt16>(o3tl::toInt32(aNumStr));
 342                         switch (nLevel)
 343                         {
 344                             case 1: ePO = PresentationObjects::Outline_1; break;
 345                             case 2: ePO = PresentationObjects::Outline_2; break;
 346                             case 3: ePO = PresentationObjects::Outline_3; break;
 347                             case 4: ePO = PresentationObjects::Outline_4; break;
 348                             case 5: ePO = PresentationObjects::Outline_5; break;
 349                             case 6: ePO = PresentationObjects::Outline_6; break;
 350                             case 7: ePO = PresentationObjects::Outline_7; break;
 351                             case 8: ePO = PresentationObjects::Outline_8; break;
 352                             case 9: ePO = PresentationObjects::Outline_9; break;
 353                         }
 354                     }
 355                     else
 356                     {
 357                         OSL_FAIL("StyleSheet from older version with different language");
 358                         bOldDocInOtherLanguage = true;
 359                     }
 360
 361                     if( !bOldDocInOtherLanguage )
 362                     {
 363                         pPresDlg.disposeAndReset(pFact ? pFact->CreateSdPresLayoutTemplateDlg(mpDocSh,  mpViewShell->GetFrameWeld(), bBackground, *pStyleSheet, ePO, pSSPool ) : nullptr);
 364                     }
 365                 }
 366
 367                 sal_uInt16 nResult = RET_CANCEL;
 368                 const SfxItemSet* pOutSet = nullptr;
 369                 if (pStdDlg)
 370                 {
 371                     nResult = pStdDlg->Execute();
 372                     pOutSet = pStdDlg->GetOutputItemSet();
 373                 }
 374                 else if( pPresDlg )
 375                 {
 376                     nResult = pPresDlg->Execute();
 377                     pOutSet = pPresDlg->GetOutputItemSet();
 378                 }
 379
 380                 switch( nResult )
 381                 {
 382                     case RET_OK:
 383                     {
 384                         nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());
 385
 386                         if (eFamily == SfxStyleFamily::Pseudo)
 387                         {
 388                             SfxItemSet aTempSet(*pOutSet);
 389                             /* Extract SvxBrushItem out of set and insert SvxColorItem */
 390                             const SvxBrushItem* pBrushItem = aTempSet.GetItem<SvxBrushItem>( SID_ATTR_BRUSH_CHAR );
 391
 392                             if ( pBrushItem )
 393                             {
 394                                 SvxColorItem aBackColorItem(pBrushItem->GetColor(), EE_CHAR_BKGCOLOR);
 395                                 aTempSet.ClearItem( EE_CHAR_BKGCOLOR );
 396                                 aTempSet.Put( aBackColorItem );
 397                             }
 398                             static_cast<SdStyleSheet*>(pStyleSheet)->AdjustToFontHeight(aTempSet);
 399
 400                             /* Special treatment: reset the INVALIDS to
 401                                NULL-Pointer (otherwise INVALIDs or pointer point
 402                                to DefaultItems in the template; both would
 403                                prevent the attribute inheritance) */
 404                             aTempSet.ClearInvalidItems();
 405
 406                             // EE_PARA_NUMBULLET item is only valid in first outline template
 407                             if( (ePO >= PresentationObjects::Outline_2) && (ePO <= PresentationObjects::Outline_9) )
 408                             {
 409                                 const SvxNumBulletItem* pBulletItem = nullptr;
 410                                 if (aTempSet.GetItemState(EE_PARA_NUMBULLET, true, &pBulletItem) == SfxItemState::SET)
 411                                 {
 412                                     SvxNumRule aRule(pBulletItem->GetNumRule());
 413
 414                                     OUString sStyleName(SdResId(STR_PSEUDOSHEET_OUTLINE) + " 1");
 415                                     SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( sStyleName, SfxStyleFamily::Pseudo);
 416
 417                                     if(pFirstStyleSheet)
 418                                     {
 419                                         pFirstStyleSheet->GetItemSet().Put( SvxNumBulletItem( aRule, EE_PARA_NUMBULLET ));
 420                                         SdStyleSheet* pRealSheet = static_cast<SdStyleSheet*>(pFirstStyleSheet)->GetRealStyleSheet();
 421                                         pRealSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
 422                                     }
 423
 424                                     aTempSet.ClearItem( EE_PARA_NUMBULLET );
 425                                 }
 426                             }
 427
 428                             pStyleSheet->GetItemSet().Put(aTempSet);
 429                             SdStyleSheet::BroadcastSdStyleSheetChange(pStyleSheet, ePO, pSSPool);
 430                         }
 431
 432                         SfxItemSet& rAttr = pStyleSheet->GetItemSet();
 433
 434                         sdr::properties::CleanupFillProperties( rAttr );
 435
 436                         // check for unique names of named items for xml
 437                         const SfxPoolItem* pOldItem = nullptr;
 438                         if( rAttr.GetItemState( XATTR_FILLBITMAP, true, &pOldItem ) == SfxItemState::SET )
 439                         {
 440                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillBitmapItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 441                             if( pNewItem )
 442                             {
 443                                 rAttr.Put( std::move(pNewItem) );
 444                             }
 445                         }
 446                         if( rAttr.GetItemState( XATTR_LINEDASH, true, &pOldItem ) == SfxItemState::SET )
 447                         {
 448                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineDashItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 449                             if( pNewItem )
 450                             {
 451                                 rAttr.Put( std::move(pNewItem) );
 452                             }
 453                         }
 454                         if( rAttr.GetItemState( XATTR_LINESTART, true, &pOldItem ) == SfxItemState::SET )
 455                         {
 456                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineStartItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 457                             if( pNewItem )
 458                             {
 459                                 rAttr.Put( std::move(pNewItem) );
 460                             }
 461                         }
 462                         if( rAttr.GetItemState( XATTR_LINEEND, true, &pOldItem ) == SfxItemState::SET )
 463                         {
 464                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XLineEndItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 465                             if( pNewItem )
 466                             {
 467                                 rAttr.Put( std::move(pNewItem) );
 468                             }
 469                         }
 470                         if( rAttr.GetItemState( XATTR_FILLGRADIENT, true, &pOldItem ) == SfxItemState::SET )
 471                         {
 472                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillGradientItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 473                             if( pNewItem )
 474                             {
 475                                 rAttr.Put( std::move(pNewItem) );
 476                             }
 477                         }
 478                         if( rAttr.GetItemState( XATTR_FILLFLOATTRANSPARENCE, true, &pOldItem ) == SfxItemState::SET )
 479                         {
 480                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillFloatTransparenceItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 481                             if( pNewItem )
 482                             {
 483                                 rAttr.Put( std::move(pNewItem) );
 484                             }
 485                         }
 486                         if( rAttr.GetItemState( XATTR_FILLHATCH, true, &pOldItem ) == SfxItemState::SET )
 487                         {
 488                             std::unique_ptr<SfxPoolItem> pNewItem = static_cast<const XFillHatchItem*>(pOldItem)->checkForUniqueItem( *mpDoc );
 489                             if( pNewItem )
 490                             {
 491                                 rAttr.Put( std::move(pNewItem) );
 492                             }
 493                         }
 494
 495                         static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );
 496
 497                         DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( mpViewShell );
 498                         if( pDrawViewShell )
 499                         {
 500                             PageKind ePageKind = pDrawViewShell->GetPageKind();
 501                             if( ePageKind == PageKind::Notes || ePageKind == PageKind::Handout )
 502                             {
 503                                 SdPage* pPage = mpViewShell->GetActualPage();
 504
 505                                 if(pDrawViewShell->GetEditMode() == EditMode::MasterPage)
 506                                 {
 507                                     pPage = static_cast<SdPage*>((&(pPage->TRG_GetMasterPage())));
 508                                 }
 509
 510                                 if( pPage )
 511                                 {
 512                                     SdrObjListIter aIter( pPage );
 513                                     while( aIter.IsMore() )
 514                                     {
 515                                         SdrObject* pObj = aIter.Next();
 516                                         if( dynamic_cast< const SdrPageObj *>( pObj ) !=  nullptr )
 517                                         {
 518                                             // repaint only
 519                                             pObj->ActionChanged();
 520                                             // pObj->SendRepaintBroadcast();
 521                                         }
 522                                     }
 523                                 }
 524                             }
 525                         }
 526
 527                         if( mpDoc->GetOnlineSpell() )
 528                         {
 529                             if( SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE, false ) ||
 530                                 SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE_CJK, false ) ||
 531                                 SfxItemState::SET == rAttr.GetItemState(EE_CHAR_LANGUAGE_CTL, false ) )
 532                             {
 533                                 mpDoc->StopOnlineSpelling();
 534                                 mpDoc->StartOnlineSpelling();
 535                             }
 536                         }
 537
 538                         mpDoc->SetChanged();
 539                     }
 540                     break;
 541
 542                     default:
 543                     {
 544                         if( nSId == SID_STYLE_NEW )
 545                             pSSPool->Remove( pStyleSheet );
 546                     }
 547                     return; // Cancel
 548                 }
 549             }
 550         }
 551         break;
 552
 553         case SID_STYLE_NEW_BY_EXAMPLE:
 554         {
 555             if( pStyleSheet )
 556             {
 557                 nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());
 558                 SfxItemSet aCoreSet( mpDoc->GetPool() );
 559                 mpView->GetAttributes( aCoreSet, true );
 560
 561                 // if the object had a template, this becomes parent of the new template
 562                 SfxStyleSheet* pOldStyle = mpView->GetStyleSheet();
 563
 564                 // if pOldStyle == pStyleSheet -> recursion
 565                 if( pOldStyle != pStyleSheet )
 566                 {
 567                     if (pOldStyle)
 568                     {
 569                         pStyleSheet->SetParent(pOldStyle->GetName());
 570                     }
 571
 572                     SfxItemSet* pStyleSet = &pStyleSheet->GetItemSet();
 573                     pStyleSet->Put(aCoreSet);
 574
 575                     /* apply template (but not when somebody is editing a text.
 576                        To do this, the edit engine had to be capable to use
 577                        templates on a character level. */
 578                     if (!mpView->GetTextEditObject())
 579                     {
 580                         mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));
 581                     }
 582
 583                     static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );
 584                     mpDoc->SetChanged();
 585
 586                     mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
 587                 }
 588             }
 589         }
 590         break;
 591
 592         case SID_STYLE_UPDATE_BY_EXAMPLE:
 593         {
 594             const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 595             if ((rMarkList.GetMarkCount() != 0 && rMarkList.GetMarkCount() == 1) ||
 596                  dynamic_cast< const OutlineView *>( mpView ) !=  nullptr)
 597             {
 598                 pStyleSheet = mpView->GetStyleSheet();
 599
 600                 if( pStyleSheet )
 601                 {
 602                     nRetMask = static_cast<sal_uInt16>(pStyleSheet->GetMask());
 603                     SfxItemSet aCoreSet( mpDoc->GetPool() );
 604                     mpView->GetAttributes( aCoreSet );
 605
 606                     SfxItemSet* pStyleSet = &pStyleSheet->GetItemSet();
 607                     pStyleSet->Put( aCoreSet );
 608
 609                     mpView->SetStyleSheet( static_cast<SfxStyleSheet*>(pStyleSheet));
 610
 611                     static_cast<SfxStyleSheet*>( pStyleSheet )->Broadcast( SfxHint( SfxHintId::DataChanged ) );
 612                     mpDoc->SetChanged();
 613                     mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_STYLE_FAMILY2 );
 614                 }
 615             }
 616         }
 617         break;
 618
 619     }
 620     if( nRetMask != static_cast<sal_uInt16>(SfxStyleSearchBits::All) )
 621         rReq.SetReturnValue( SfxUInt16Item( nSId, nRetMask ) );
 622 }
 623
 624 void FuTemplate::Activate()
 625 {
 626 }
 627
 628 void FuTemplate::Deactivate()
 629 {
 630 }
 631
 632 } // end of namespace sd
 633
 634 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */