1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sd.hxx" 26 27 #include "PageListWatcher.hxx" 28 #include <com/sun/star/text/WritingMode.hpp> 29 #include <com/sun/star/document/PrinterIndependentLayout.hpp> 30 #include <com/sun/star/i18n/ScriptType.hpp> 31 #include <editeng/forbiddencharacterstable.hxx> 32 33 #include <svx/svxids.hrc> 34 #include <svl/srchitem.hxx> 35 #include <editeng/eeitem.hxx> 36 #include <editeng/scriptspaceitem.hxx> 37 38 #include <unotools/useroptions.hxx> 39 40 #include <sfx2/printer.hxx> 41 #include <sfx2/app.hxx> 42 #include <sfx2/linkmgr.hxx> 43 #include <svx/dialogs.hrc> 44 #include "Outliner.hxx" 45 #include "app.hxx" 46 #include <editeng/eeitem.hxx> 47 #include <editeng/editstat.hxx> 48 #include <editeng/fontitem.hxx> 49 #include <svl/flagitem.hxx> 50 #include <svx/svdoattr.hxx> 51 #include <svx/svdotext.hxx> 52 #include <editeng/bulitem.hxx> 53 #include <editeng/numitem.hxx> 54 #include <svx/svditer.hxx> 55 #include <editeng/unolingu.hxx> 56 #include <svl/itempool.hxx> 57 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 58 #include <svx/xtable.hxx> 59 #include <com/sun/star/linguistic2/XHyphenator.hpp> 60 #include <com/sun/star/linguistic2/XSpellChecker1.hpp> 61 #include <com/sun/star/beans/XPropertySet.hpp> 62 #include <editeng/outlobj.hxx> 63 #include <unotools/saveopt.hxx> 64 #include <comphelper/extract.hxx> 65 #include <i18npool/mslangid.hxx> 66 #include <unotools/charclass.hxx> 67 #include <comphelper/processfactory.hxx> 68 #ifndef _SVTOOLS_PATHOPTIONS_HXX_ 69 #include <unotools/pathoptions.hxx> 70 #endif 71 #include <unotools/lingucfg.hxx> 72 #include <unotools/linguprops.hxx> 73 74 #include "eetext.hxx" 75 #include "drawdoc.hxx" 76 #include "sdpage.hxx" 77 #include "pglink.hxx" 78 #include "sdattr.hxx" 79 #include "glob.hrc" 80 #include "glob.hxx" 81 #include "stlpool.hxx" 82 #include "sdiocmpt.hxx" 83 #include "sdresid.hxx" 84 #include "cusshow.hxx" 85 #include "../ui/inc/DrawDocShell.hxx" 86 #include "../ui/inc/GraphicDocShell.hxx" 87 #include "../ui/inc/sdxfer.hxx" 88 #include "../ui/inc/ViewShell.hxx" 89 #include "../ui/inc/optsitem.hxx" 90 #include "../ui/inc/FrameView.hxx" 91 92 // #90477# 93 #include <tools/tenccvt.hxx> 94 95 using ::rtl::OUString; 96 using namespace ::sd; 97 using namespace ::com::sun::star; 98 using namespace ::com::sun::star::uno; 99 using namespace ::com::sun::star::lang; 100 using namespace ::com::sun::star::linguistic2; 101 102 ////////////////////////////////////////////////////////////////////////////// 103 104 TYPEINIT1( SdDrawDocument, FmFormModel ); 105 106 SdDrawDocument* SdDrawDocument::pDocLockedInsertingLinks = NULL; 107 108 ////////////////////////////////////////////////////////////////////////////// 109 110 PresentationSettings::PresentationSettings() 111 : mbAll( true ), 112 mbEndless( false ), 113 mbCustomShow(false), 114 mbManual( false ), 115 mbMouseVisible( false ), 116 mbMouseAsPen( false ), 117 mbLockedPages( false ), 118 mbAlwaysOnTop( false ), 119 mbFullScreen( true ), 120 mbAnimationAllowed( true ), 121 mnPauseTimeout( 10 ), 122 mbShowPauseLogo( false ), 123 mbStartWithNavigator(false) 124 { 125 } 126 127 // --------------------------------------------------------------------------- 128 129 PresentationSettings::PresentationSettings( const PresentationSettings& r ) 130 : maPresPage( r.maPresPage ), 131 mbAll( r.mbAll ), 132 mbEndless( r.mbEndless ), 133 mbCustomShow( r.mbCustomShow ), 134 mbManual( r.mbManual ), 135 mbMouseVisible( r.mbMouseVisible ), 136 mbMouseAsPen( r.mbMouseAsPen ), 137 mbLockedPages( r.mbLockedPages ), 138 mbAlwaysOnTop( r.mbAlwaysOnTop ), 139 mbFullScreen( r.mbFullScreen ), 140 mbAnimationAllowed( r.mbAnimationAllowed ), 141 mnPauseTimeout( r.mnPauseTimeout ), 142 mbShowPauseLogo( r.mbShowPauseLogo ), 143 mbStartWithNavigator( r.mbStartWithNavigator ) 144 { 145 } 146 147 // --------------------------------------------------------------------------- 148 149 SdDrawDocument::SdDrawDocument(DocumentType eType, SfxObjectShell* pDrDocSh) 150 : FmFormModel( SvtPathOptions().GetPalettePath(), NULL, pDrDocSh ) 151 , bReadOnly(sal_False) 152 , mpOutliner(NULL) 153 , mpInternalOutliner(NULL) 154 , mpWorkStartupTimer(NULL) 155 , mpOnlineSpellingTimer(NULL) 156 , mpOnlineSpellingList(NULL) 157 , mpOnlineSearchItem(NULL) 158 , mpFrameViewList( new List() ) 159 , mpCustomShowList(NULL) 160 , mpDocSh(static_cast< ::sd::DrawDocShell*>(pDrDocSh)) 161 , mpCreatingTransferable( NULL ) 162 , mbHasOnlineSpellErrors(sal_False) 163 , mbInitialOnlineSpellingEnabled(sal_True) 164 , mbNewOrLoadCompleted(sal_False) 165 , mbStartWithPresentation( false ) 166 , meLanguage( LANGUAGE_SYSTEM ) 167 , meLanguageCJK( LANGUAGE_SYSTEM ) 168 , meLanguageCTL( LANGUAGE_SYSTEM ) 169 , mePageNumType(SVX_ARABIC) 170 , mbAllocDocSh(sal_False) 171 , meDocType(eType) 172 , mpCharClass(NULL) 173 , mpLocale(NULL) 174 , mpDrawPageListWatcher(0) 175 , mpMasterPageListWatcher(0) 176 { 177 // #109538# 178 mpDrawPageListWatcher = ::std::auto_ptr<ImpDrawPageListWatcher>( 179 new ImpDrawPageListWatcher(*this)); 180 mpMasterPageListWatcher = ::std::auto_ptr<ImpMasterPageListWatcher>( 181 new ImpMasterPageListWatcher(*this)); 182 183 SetObjectShell(pDrDocSh); // for the VCDrawModel 184 185 if (mpDocSh) 186 { 187 SetSwapGraphics(sal_True); 188 } 189 190 // set measurement unit (of App) and scale (of SdMod) 191 sal_Int32 nX, nY; 192 SdOptions* pOptions = SD_MOD()->GetSdOptions(meDocType); 193 pOptions->GetScale( nX, nY ); 194 195 // #92067# Allow UI scale only for draw documents. 196 if( eType == DOCUMENT_TYPE_DRAW ) 197 SetUIUnit( (FieldUnit)pOptions->GetMetric(), Fraction( nX, nY ) ); // user-defined 198 else 199 SetUIUnit( (FieldUnit)pOptions->GetMetric(), Fraction( 1, 1 ) ); // default 200 201 SetScaleUnit(MAP_100TH_MM); 202 SetScaleFraction(Fraction(1, 1)); 203 SetDefaultFontHeight(847); // 24p 204 205 pItemPool->SetDefaultMetric(SFX_MAPUNIT_100TH_MM); 206 pItemPool->FreezeIdRanges(); 207 SetTextDefaults(); 208 209 // also the DrawingEngine needs to know where it is 210 FmFormModel::SetStyleSheetPool( new SdStyleSheetPool( GetPool(), this ) ); 211 212 // Set the StyleSheetPool to the DrawOutliner, in order to read text objects 213 // correctly. The link to the StyleRequest handler of the document will be 214 // set first in NewOrLoadCompleted, because only then all templates exist. 215 SdrOutliner& rOutliner = GetDrawOutliner(); 216 rOutliner.SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 217 SetCalcFieldValueHdl( &rOutliner ); 218 219 // set linguistic options 220 { 221 const SvtLinguConfig aLinguConfig; 222 SvtLinguOptions aOptions; 223 aLinguConfig.GetOptions( aOptions ); 224 225 SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage, 226 ::com::sun::star::i18n::ScriptType::LATIN), EE_CHAR_LANGUAGE ); 227 SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CJK, 228 ::com::sun::star::i18n::ScriptType::ASIAN), EE_CHAR_LANGUAGE_CJK ); 229 SetLanguage( MsLangId::resolveSystemLanguageByScriptType(aOptions.nDefaultLanguage_CTL, 230 ::com::sun::star::i18n::ScriptType::COMPLEX), EE_CHAR_LANGUAGE_CTL ); 231 232 mbOnlineSpell = aOptions.bIsSpellAuto; 233 } 234 235 LanguageType eRealLanguage = MsLangId::getRealLanguage( meLanguage ); 236 mpLocale = new ::com::sun::star::lang::Locale( MsLangId::convertLanguageToLocale( eRealLanguage )); 237 mpCharClass = new CharClass( *mpLocale ); 238 239 // If the current application language is a language that uses right-to-left text... 240 LanguageType eRealCTLLanguage = Application::GetSettings().GetLanguage(); 241 if( MsLangId::isRightToLeft( eRealCTLLanguage ) ) 242 { 243 // ... then we have to set this as a default 244 SetDefaultWritingMode( ::com::sun::star::text::WritingMode_RL_TB ); 245 } 246 247 // for korean and japanese languages we have a different default for apply spacing between asian, latin and ctl text 248 if( ( LANGUAGE_KOREAN == eRealCTLLanguage ) || ( LANGUAGE_KOREAN_JOHAB == eRealCTLLanguage ) || ( LANGUAGE_JAPANESE == eRealCTLLanguage ) ) 249 { 250 GetPool().GetSecondaryPool()->SetPoolDefaultItem( SvxScriptSpaceItem( sal_False, EE_PARA_ASIANCJKSPACING ) ); 251 } 252 253 // set DefTab and SpellOptions 254 // now at the module (SD) 255 sal_uInt16 nDefTab = pOptions->GetDefTab(); 256 SetDefaultTabulator( nDefTab ); 257 258 try 259 { 260 Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() ); 261 if ( xSpellChecker.is() ) 262 rOutliner.SetSpeller( xSpellChecker ); 263 264 Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() ); 265 if( xHyphenator.is() ) 266 rOutliner.SetHyphenator( xHyphenator ); 267 268 SetForbiddenCharsTable( new SvxForbiddenCharactersTable( ::comphelper::getProcessServiceFactory() ) ); 269 } 270 catch(...) 271 { 272 DBG_ERROR("Can't get SpellChecker"); 273 } 274 275 rOutliner.SetDefaultLanguage( Application::GetSettings().GetLanguage() ); 276 277 if (mpDocSh) 278 { 279 sfx2::LinkManager *linkMgr = new sfx2::LinkManager(mpDocSh); 280 linkMgr->SetAutoAskUpdateAllLinks(); 281 SetLinkManager( linkMgr ); 282 } 283 284 sal_uLong nCntrl = rOutliner.GetControlWord(); 285 nCntrl |= EE_CNTRL_ALLOWBIGOBJS; 286 nCntrl |= EE_CNTRL_URLSFXEXECUTE; 287 288 if (mbOnlineSpell) 289 nCntrl |= EE_CNTRL_ONLINESPELLING; 290 else 291 nCntrl &= ~EE_CNTRL_ONLINESPELLING; 292 293 nCntrl &= ~ EE_CNTRL_ULSPACESUMMATION; 294 if ( meDocType != DOCUMENT_TYPE_IMPRESS ) 295 SetSummationOfParagraphs( sal_False ); 296 else 297 { 298 SetSummationOfParagraphs( pOptions->IsSummationOfParagraphs() ); 299 if ( pOptions->IsSummationOfParagraphs() ) 300 nCntrl |= EE_CNTRL_ULSPACESUMMATION; 301 } 302 rOutliner.SetControlWord(nCntrl); 303 304 // Initialize the printer independent layout mode. 305 SetPrinterIndependentLayout (pOptions->GetPrinterIndependentLayout()); 306 307 // Set the StyleSheetPool to the HitTestOutliner. 308 // The link to the StyleRequest handler of the document will be set 309 // first in NewOrLoadCompleted, because only then all templates exist. 310 SfxItemSet aSet2( pHitTestOutliner->GetEmptyItemSet() ); 311 pHitTestOutliner->SetStyleSheetPool( (SfxStyleSheetPool*)GetStyleSheetPool() ); 312 313 SetCalcFieldValueHdl( pHitTestOutliner ); 314 315 try 316 { 317 Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() ); 318 if ( xSpellChecker.is() ) 319 pHitTestOutliner->SetSpeller( xSpellChecker ); 320 321 Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() ); 322 if( xHyphenator.is() ) 323 pHitTestOutliner->SetHyphenator( xHyphenator ); 324 } 325 catch(...) 326 { 327 DBG_ERROR("Can't get SpellChecker"); 328 } 329 330 pHitTestOutliner->SetDefaultLanguage( Application::GetSettings().GetLanguage() ); 331 332 sal_uLong nCntrl2 = pHitTestOutliner->GetControlWord(); 333 nCntrl2 |= EE_CNTRL_ALLOWBIGOBJS; 334 nCntrl2 |= EE_CNTRL_URLSFXEXECUTE; 335 nCntrl2 &= ~EE_CNTRL_ONLINESPELLING; 336 337 nCntrl2 &= ~ EE_CNTRL_ULSPACESUMMATION; 338 if ( pOptions->IsSummationOfParagraphs() ) 339 nCntrl2 |= EE_CNTRL_ULSPACESUMMATION; 340 341 pHitTestOutliner->SetControlWord( nCntrl2 ); 342 343 /************************************************************************** 344 * Create layer 345 * 346 * The following default layer will created on Pages and MasterPages: 347 * 348 * Layer STR_LAYOUT : Default layer for all drawing objects 349 * 350 * Layer STR_BCKGRND : Background of the MasterPage 351 * (it's currently not used on normal Pages) 352 * 353 * Layer STR_BCKGRNDOBJ : Objects on the background of the MasterPage 354 * (it's currently not used on normal Pages) 355 * 356 * Layer STR_CONTROLS : Default layer for Controls 357 * 358 **************************************************************************/ 359 { 360 String aControlLayerName( SdResId(STR_LAYER_CONTROLS) ); 361 362 SdrLayerAdmin& rLayerAdmin = GetLayerAdmin(); 363 rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_LAYOUT)) ); 364 rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_BCKGRND)) ); 365 rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_BCKGRNDOBJ)) ); 366 rLayerAdmin.NewLayer( aControlLayerName ); 367 rLayerAdmin.NewLayer( String(SdResId(STR_LAYER_MEASURELINES)) ); 368 369 rLayerAdmin.SetControlLayerName(aControlLayerName); 370 } 371 372 373 } 374 375 /************************************************************************* 376 |* 377 |* Destructor 378 |* 379 \************************************************************************/ 380 381 SdDrawDocument::~SdDrawDocument() 382 { 383 Broadcast(SdrHint(HINT_MODELCLEARED)); 384 385 if (mpWorkStartupTimer) 386 { 387 if ( mpWorkStartupTimer->IsActive() ) 388 mpWorkStartupTimer->Stop(); 389 390 delete mpWorkStartupTimer; 391 mpWorkStartupTimer = NULL; 392 } 393 394 StopOnlineSpelling(); 395 delete mpOnlineSearchItem; 396 mpOnlineSearchItem = NULL; 397 398 CloseBookmarkDoc(); 399 SetAllocDocSh(sal_False); 400 401 // #116168# 402 ClearModel(sal_True); 403 404 if (pLinkManager) 405 { 406 // deallocate BaseLinks 407 if ( pLinkManager->GetLinks().Count() ) 408 { 409 pLinkManager->Remove( 0, pLinkManager->GetLinks().Count() ); 410 } 411 412 delete pLinkManager; 413 pLinkManager = NULL; 414 } 415 416 ::sd::FrameView* pFrameView = NULL; 417 418 for (sal_uLong i = 0; i < mpFrameViewList->Count(); i++) 419 { 420 // if necessary delete FrameViews 421 pFrameView = 422 static_cast< ::sd::FrameView*>(mpFrameViewList->GetObject(i)); 423 424 if (pFrameView) 425 delete pFrameView; 426 } 427 428 delete mpFrameViewList; 429 mpFrameViewList = NULL; 430 431 if (mpCustomShowList) 432 { 433 for (sal_uLong j = 0; j < mpCustomShowList->Count(); j++) 434 { 435 // if necessary delete CustomShows 436 SdCustomShow* pCustomShow = (SdCustomShow*) mpCustomShowList->GetObject(j); 437 delete pCustomShow; 438 } 439 440 delete mpCustomShowList; 441 mpCustomShowList = NULL; 442 } 443 444 delete mpOutliner; 445 mpOutliner = NULL; 446 447 delete mpInternalOutliner; 448 mpInternalOutliner = NULL; 449 450 delete mpLocale; 451 mpLocale = NULL; 452 453 delete mpCharClass; 454 mpCharClass = NULL; 455 } 456 457 /************************************************************************* 458 |* 459 |* This methods creates a new document (SdDrawDocument) and gives back a 460 |* pointer to it. The Drawing Engine uses this method to be able to put 461 |* the document or parts of it into Clipboard/DragServer. 462 |* 463 \************************************************************************/ 464 465 SdrModel* SdDrawDocument::AllocModel() const 466 { 467 SdDrawDocument* pNewModel = NULL; 468 469 if( mpCreatingTransferable ) 470 { 471 // the document will created for Drag&Drop/Clipboard, 472 // for this the document has to know a DocShell (SvPersist) 473 SfxObjectShell* pObj = NULL; 474 ::sd::DrawDocShell* pNewDocSh = NULL; 475 476 if( meDocType == DOCUMENT_TYPE_IMPRESS ) 477 mpCreatingTransferable->SetDocShell( new ::sd::DrawDocShell( 478 SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType ) ); 479 else 480 mpCreatingTransferable->SetDocShell( new ::sd::GraphicDocShell( 481 SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType ) ); 482 483 pNewDocSh = static_cast< ::sd::DrawDocShell*>( pObj = mpCreatingTransferable->GetDocShell() ); 484 pNewDocSh->DoInitNew( NULL ); 485 pNewModel = pNewDocSh->GetDoc(); 486 487 // only necessary for Clipboard, 488 // for Drag&Drop this will happen in DragServer 489 SdStyleSheetPool* pOldStylePool = (SdStyleSheetPool*) GetStyleSheetPool(); 490 SdStyleSheetPool* pNewStylePool = (SdStyleSheetPool*) pNewModel->GetStyleSheetPool(); 491 492 pNewStylePool->CopyGraphicSheets(*pOldStylePool); 493 pNewStylePool->CopyCellSheets(*pOldStylePool); 494 pNewStylePool->CopyTableStyles(*pOldStylePool); 495 496 497 for (sal_uInt16 i = 0; i < GetMasterSdPageCount(PK_STANDARD); i++) 498 { 499 // take all layouts of the MasterPage 500 String aOldLayoutName(((SdDrawDocument*) this)->GetMasterSdPage(i, PK_STANDARD)->GetLayoutName()); 501 aOldLayoutName.Erase( aOldLayoutName.SearchAscii( SD_LT_SEPARATOR ) ); 502 SdStyleSheetVector aCreatedSheets; 503 pNewStylePool->CopyLayoutSheets(aOldLayoutName, *pOldStylePool, aCreatedSheets ); 504 } 505 506 pNewModel->NewOrLoadCompleted( DOC_LOADED ); // loaded from source document 507 } 508 else if( mbAllocDocSh ) 509 { 510 // a DocShell will be created which will be returned with GetAllocedDocSh() 511 SdDrawDocument* pDoc = (SdDrawDocument*) this; 512 pDoc->SetAllocDocSh(sal_False); 513 pDoc->mxAllocedDocShRef = new ::sd::DrawDocShell( 514 SFX_CREATE_MODE_EMBEDDED, sal_True, meDocType); 515 pDoc->mxAllocedDocShRef->DoInitNew(NULL); 516 pNewModel = pDoc->mxAllocedDocShRef->GetDoc(); 517 } 518 else 519 { 520 pNewModel = new SdDrawDocument(meDocType, NULL); 521 } 522 523 return pNewModel; 524 } 525 526 /************************************************************************* 527 |* 528 |* This methods creates a new page (SdPage) and gives back a pointer to it. 529 |* The Drawing Engine uses this method when loading to create pages (whose 530 |* types are not knowed for it because these are DERIVATIONS of SdrPage). 531 |* 532 \************************************************************************/ 533 534 SdrPage* SdDrawDocument::AllocPage(FASTBOOL bMasterPage) 535 { 536 return new SdPage(*this, NULL, (sal_Bool)bMasterPage); 537 } 538 539 /************************************************************************* 540 |* 541 |* SetChanged(), the modele was changed 542 |* 543 \************************************************************************/ 544 545 void SdDrawDocument::SetChanged(sal_Bool bFlag) 546 { 547 if (mpDocSh) 548 { 549 if (mbNewOrLoadCompleted && mpDocSh->IsEnableSetModified()) 550 { 551 // forward to baseclass 552 FmFormModel::SetChanged(bFlag); 553 554 // pass to ObjectShell 555 mpDocSh->SetModified(bFlag); 556 } 557 } 558 else 559 { 560 // forward to baseclass 561 FmFormModel::SetChanged(bFlag); 562 } 563 } 564 565 /************************************************************************* 566 |* 567 |* NbcSetChanged(), the model changed, don't call anybody else 568 |* 569 \************************************************************************/ 570 571 void SdDrawDocument::NbcSetChanged(sal_Bool bFlag) 572 { 573 // #100237# forward to baseclass 574 FmFormModel::SetChanged(bFlag); 575 } 576 577 /************************************************************************* 578 |* 579 |* NewOrLoadCompleted 580 |* 581 |* Will be called when the document was loaded respectively when it is 582 |* certain that it will not be loaded any longer. 583 |* 584 \************************************************************************/ 585 586 void SdDrawDocument::NewOrLoadCompleted(DocCreationMode eMode) 587 { 588 if (eMode == NEW_DOC) 589 { 590 // new document: 591 // create Presentation and default templates, 592 // create pool for virtual controls 593 CreateLayoutTemplates(); 594 CreateDefaultCellStyles(); 595 596 static_cast< SdStyleSheetPool* >( mxStyleSheetPool.get() )->CreatePseudosIfNecessary(); 597 } 598 else if (eMode == DOC_LOADED) 599 { 600 // document was loaded: 601 602 CheckMasterPages(); 603 604 if ( GetMasterSdPageCount(PK_STANDARD) > 1 ) 605 RemoveUnnecessaryMasterPages( NULL, sal_True, sal_False ); 606 607 for ( sal_uInt16 i = 0; i < GetPageCount(); i++ ) 608 { 609 // Check for correct layout names 610 SdPage* pPage = (SdPage*) GetPage( i ); 611 612 if(pPage->TRG_HasMasterPage()) 613 { 614 SdPage& rMaster = (SdPage&)pPage->TRG_GetMasterPage(); 615 616 if(rMaster.GetLayoutName() != pPage->GetLayoutName()) 617 { 618 pPage->SetLayoutName(rMaster.GetLayoutName()); 619 } 620 } 621 } 622 623 for ( sal_uInt16 nPage = 0; nPage < GetMasterPageCount(); nPage++) 624 { 625 // LayoutName and PageName must be the same 626 SdPage* pPage = (SdPage*) GetMasterPage( nPage ); 627 628 String aName( pPage->GetLayoutName() ); 629 aName.Erase( aName.SearchAscii( SD_LT_SEPARATOR ) ); 630 631 if( aName != pPage->GetName() ) 632 pPage->SetName( aName ); 633 } 634 635 // create language-dependent names of the default layer 636 RestoreLayerNames(); 637 638 // set language-dependent names of the templates 639 static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->UpdateStdNames(); 640 641 // if necessary create missing templates (e.g., formerly there was no Subtitle) 642 static_cast<SdStyleSheetPool*>(mxStyleSheetPool.get())->CreatePseudosIfNecessary(); 643 } 644 645 // set default template at the Drawing Engine 646 String aName( SdResId(STR_STANDARD_STYLESHEET_NAME)); 647 SetDefaultStyleSheet(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(aName, SD_STYLE_FAMILY_GRAPHICS))); 648 649 // #119287# Set default StyleSheet for SdrGrafObj and SdrOle2Obj 650 SetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(static_cast<SfxStyleSheet*>(mxStyleSheetPool->Find(String( SdResId(STR_POOLSHEET_OBJNOLINENOFILL)), SD_STYLE_FAMILY_GRAPHICS))); 651 652 // initialize Draw-Outliner and Document Outliner, 653 // but not the global Outliner because it is not document-specific 654 // like StyleSheetPool and StyleRequestHandler 655 ::Outliner& rDrawOutliner = GetDrawOutliner(); 656 rDrawOutliner.SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 657 sal_uLong nCntrl = rDrawOutliner.GetControlWord(); 658 if (mbOnlineSpell) 659 nCntrl |= EE_CNTRL_ONLINESPELLING; 660 else 661 nCntrl &= ~EE_CNTRL_ONLINESPELLING; 662 rDrawOutliner.SetControlWord(nCntrl); 663 664 // initialize HitTest-Outliner and Document Outliner, 665 // but not the global Outliner because it is not document-specific 666 // like StyleSheetPool and StyleRequestHandler 667 pHitTestOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 668 669 if(mpOutliner) 670 { 671 mpOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 672 } 673 if(mpInternalOutliner) 674 { 675 mpInternalOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 676 } 677 678 if ( eMode == DOC_LOADED ) 679 { 680 // presentation objects have to be Listener again of the respective templates 681 SdStyleSheetPool* pSPool = (SdStyleSheetPool*) GetStyleSheetPool(); 682 sal_uInt16 nPage, nPageCount; 683 684 // #96323# create missing layout style sheets for broken documents 685 // that where created with the 5.2 686 nPageCount = GetMasterSdPageCount( PK_STANDARD ); 687 for (nPage = 0; nPage < nPageCount; nPage++) 688 { 689 SdPage* pPage = GetMasterSdPage(nPage, PK_STANDARD); 690 pSPool->CreateLayoutStyleSheets( pPage->GetName(), sal_True ); 691 } 692 693 // Default and note pages: 694 for (nPage = 0; nPage < GetPageCount(); nPage++) 695 { 696 SdPage* pPage = (SdPage*)GetPage(nPage); 697 NewOrLoadCompleted( pPage, pSPool ); 698 } 699 700 // Masterpages: 701 for (nPage = 0; nPage < GetMasterPageCount(); nPage++) 702 { 703 SdPage* pPage = (SdPage*)GetMasterPage(nPage); 704 705 NewOrLoadCompleted( pPage, pSPool ); 706 } 707 } 708 709 mbNewOrLoadCompleted = sal_True; 710 711 /************************************************************************** 712 * Update all linked Pages 713 **************************************************************************/ 714 SdPage* pPage = NULL; 715 sal_uInt16 nMaxSdPages = GetSdPageCount(PK_STANDARD); 716 717 for (sal_uInt16 nSdPage=0; nSdPage < nMaxSdPages; nSdPage++) 718 { 719 pPage = (SdPage*) GetSdPage(nSdPage, PK_STANDARD); 720 721 if (pPage && pPage->GetFileName().Len() && pPage->GetBookmarkName().Len()) 722 { 723 pPage->SetModel(this); 724 } 725 } 726 727 UpdateAllLinks(); 728 729 SetChanged( sal_False ); 730 } 731 732 /** updates all links, only links in this document should by resolved */ 733 void SdDrawDocument::UpdateAllLinks() 734 { 735 if ( !pDocLockedInsertingLinks && pLinkManager && pLinkManager->GetLinks().Count() ) 736 { 737 pDocLockedInsertingLinks = this; // lock inserting links. only links in this document should by resolved 738 739 pLinkManager->UpdateAllLinks(); // query box: update all links? 740 741 if( pDocLockedInsertingLinks == this ) 742 pDocLockedInsertingLinks = NULL; // unlock inserting links 743 } 744 } 745 746 /** this loops over the presentation objectes of a page and repairs some new settings 747 from old binary files and resets all default strings for empty presentation objects. 748 */ 749 void SdDrawDocument::NewOrLoadCompleted( SdPage* pPage, SdStyleSheetPool* pSPool ) 750 { 751 /* cl removed because not needed anymore since binfilter 752 SdrObjListIter aShapeIter( *pPage ); 753 while( aShapeIter.IsMore() ) 754 { 755 OutlinerParaObject* pOPO = aShapeIter.Next()->GetOutlinerParaObject(); 756 if( pOPO ) 757 { 758 if( pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW ) 759 pOPO->SetOutlinerMode( OUTLINERMODE_TEXTOBJECT ); 760 761 pOPO->FinishLoad( pSPool ); 762 } 763 } 764 */ 765 766 const sd::ShapeList& rPresentationShapes( pPage->GetPresentationShapeList() ); 767 if(!rPresentationShapes.isEmpty()) 768 { 769 // create lists with title and outline templates 770 String aName = pPage->GetLayoutName(); 771 aName.Erase( aName.SearchAscii( SD_LT_SEPARATOR )); 772 773 List* pOutlineList = pSPool->CreateOutlineSheetList(aName); 774 SfxStyleSheet* pTitleSheet = (SfxStyleSheet*) 775 pSPool->GetTitleSheet(aName); 776 777 SdrObject* pObj = rPresentationShapes.getNextShape(0); 778 779 // now search for title and outline text objects and 780 // change objects into Listener 781 while(pObj) 782 { 783 if (pObj->GetObjInventor() == SdrInventor) 784 { 785 OutlinerParaObject* pOPO = pObj->GetOutlinerParaObject(); 786 sal_uInt16 nId = pObj->GetObjIdentifier(); 787 788 if (nId == OBJ_TITLETEXT) 789 { 790 if( pOPO && pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW ) 791 pOPO->SetOutlinerMode( OUTLINERMODE_TITLEOBJECT ); 792 793 // sal_True: in doing so do not delete hard attributes 794 if (pTitleSheet) 795 pObj->SetStyleSheet(pTitleSheet, sal_True); 796 } 797 else if (nId == OBJ_OUTLINETEXT) 798 { 799 if( pOPO && pOPO->GetOutlinerMode() == OUTLINERMODE_DONTKNOW ) 800 pOPO->SetOutlinerMode( OUTLINERMODE_OUTLINEOBJECT ); 801 802 for (sal_uInt16 nSheet = 0; nSheet < 10; nSheet++) 803 { 804 SfxStyleSheet* pSheet = (SfxStyleSheet*)pOutlineList->GetObject(nSheet); 805 if (pSheet) 806 { 807 pObj->StartListening(*pSheet); 808 809 if( nSheet == 0) 810 // text frame listen to StyleSheet of Layer1 811 pObj->NbcSetStyleSheet(pSheet, sal_True); 812 } 813 } 814 } 815 816 if (pObj->ISA(SdrTextObj) && pObj->IsEmptyPresObj() && pPage) 817 { 818 PresObjKind ePresObjKind = pPage->GetPresObjKind(pObj); 819 String aString( pPage->GetPresObjText(ePresObjKind) ); 820 821 if (aString.Len()) 822 { 823 sd::Outliner* pInternalOutl = GetInternalOutliner(sal_True); 824 pPage->SetObjText( (SdrTextObj*) pObj, pInternalOutl, ePresObjKind, aString ); 825 pObj->NbcSetStyleSheet( pPage->GetStyleSheetForPresObj( ePresObjKind ), sal_True ); 826 pInternalOutl->Clear(); 827 } 828 } 829 } 830 831 pObj = rPresentationShapes.getNextShape(pObj); 832 } 833 834 delete pOutlineList; 835 } 836 } 837 838 /************************************************************************* 839 |* 840 |* Local Outliner that is used for the outline mode. 841 |* If necessary, insert OutlinerViews into this outliner ! 842 |* 843 \************************************************************************/ 844 845 ::sd::Outliner* SdDrawDocument::GetOutliner(sal_Bool bCreateOutliner) 846 { 847 if (!mpOutliner && bCreateOutliner) 848 { 849 mpOutliner = new ::sd::Outliner( this, OUTLINERMODE_TEXTOBJECT ); 850 851 if (mpDocSh) 852 mpOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *mpDocSh ) ); 853 854 mpOutliner->SetDefTab( nDefaultTabulator ); 855 mpOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 856 } 857 858 return(mpOutliner); 859 } 860 861 862 /************************************************************************* 863 |* 864 |* Internal Outliner that is used for creating text objects. 865 |* No OutlinerViews will be inserted into this Outliner! 866 |* 867 \************************************************************************/ 868 869 ::sd::Outliner* SdDrawDocument::GetInternalOutliner(sal_Bool bCreateOutliner) 870 { 871 if ( !mpInternalOutliner && bCreateOutliner ) 872 { 873 mpInternalOutliner = new ::sd::Outliner( this, OUTLINERMODE_TEXTOBJECT ); 874 // MT: 875 // This Outliner is used to create special text objects only. 876 // As no portion information have to be saved in these text objects, 877 // the update mode can/should stay always sal_False. 878 mpInternalOutliner->SetUpdateMode( sal_False ); 879 mpInternalOutliner->EnableUndo( sal_False ); 880 881 if (mpDocSh) 882 mpInternalOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *mpDocSh ) ); 883 884 mpInternalOutliner->SetDefTab( nDefaultTabulator ); 885 mpInternalOutliner->SetStyleSheetPool((SfxStyleSheetPool*)GetStyleSheetPool()); 886 } 887 888 DBG_ASSERT( !mpInternalOutliner || ( mpInternalOutliner->GetUpdateMode() == sal_False ) , "InternalOutliner: UpdateMode = sal_True !" ); 889 DBG_ASSERT( !mpInternalOutliner || ( mpInternalOutliner->IsUndoEnabled() == sal_False ), "InternalOutliner: Undo = sal_True !" ); 890 891 // MT: Who fills it with spam has to empty it right after: 892 // Advantages: 893 // a) No uncessary clear calls. 894 // b) No spam in memory. 895 DBG_ASSERT( !mpInternalOutliner || ( ( mpInternalOutliner->GetParagraphCount() == 1 ) && ( mpInternalOutliner->GetText( mpInternalOutliner->GetParagraph( 0 ) ).Len() == 0 ) ), "InternalOutliner: Nicht leer!" ); 896 897 return mpInternalOutliner; 898 } 899 900 /************************************************************************* 901 |* 902 |* OnlineSpelling on/off 903 |* 904 \************************************************************************/ 905 906 void SdDrawDocument::SetOnlineSpell(sal_Bool bIn) 907 { 908 mbOnlineSpell = bIn; 909 sal_uLong nCntrl = 0; 910 911 if(mpOutliner) 912 { 913 nCntrl = mpOutliner->GetControlWord(); 914 915 if(mbOnlineSpell) 916 nCntrl |= EE_CNTRL_ONLINESPELLING; 917 else 918 nCntrl &= ~EE_CNTRL_ONLINESPELLING; 919 920 mpOutliner->SetControlWord(nCntrl); 921 } 922 923 if (mpInternalOutliner) 924 { 925 nCntrl = mpInternalOutliner->GetControlWord(); 926 927 if (mbOnlineSpell) 928 nCntrl |= EE_CNTRL_ONLINESPELLING; 929 else 930 nCntrl &= ~EE_CNTRL_ONLINESPELLING; 931 932 mpInternalOutliner->SetControlWord(nCntrl); 933 } 934 935 ::Outliner& rOutliner = GetDrawOutliner(); 936 937 nCntrl = rOutliner.GetControlWord(); 938 939 if (mbOnlineSpell) 940 nCntrl |= EE_CNTRL_ONLINESPELLING; 941 else 942 nCntrl &= ~EE_CNTRL_ONLINESPELLING; 943 944 rOutliner.SetControlWord(nCntrl); 945 946 if (mbOnlineSpell) 947 { 948 StartOnlineSpelling(); 949 } 950 else 951 { 952 StopOnlineSpelling(); 953 } 954 } 955 956 957 /************************************************************************* 958 |* 959 |* OnlineSpelling: Marking on/off 960 |* 961 \************************************************************************/ 962 963 uno::Reference< uno::XInterface > SdDrawDocument::createUnoModel() 964 { 965 uno::Reference< uno::XInterface > xModel; 966 967 try 968 { 969 if ( mpDocSh ) 970 xModel = mpDocSh->GetModel(); 971 } 972 catch( uno::RuntimeException& ) 973 { 974 } 975 976 return xModel; 977 } 978 979 SvxNumType SdDrawDocument::GetPageNumType() const 980 { 981 return mePageNumType; 982 } 983 984 985 986 987 void SdDrawDocument::SetPrinterIndependentLayout (sal_Int32 nMode) 988 { 989 // #108104# 990 // DBG_ASSERT (mpDocSh!=NULL, "No available document shell to set ref device at."); 991 992 switch (nMode) 993 { 994 case ::com::sun::star::document::PrinterIndependentLayout::DISABLED: 995 case ::com::sun::star::document::PrinterIndependentLayout::ENABLED: 996 // Just store supported modes and inform the doc shell. 997 mnPrinterIndependentLayout = nMode; 998 999 // #108104# 1000 // Since it is possible that a SdDrawDocument is constructed without a 1001 // SdDrawDocShell the pointer member mpDocSh needs to be tested 1002 // before the call is executed. This is e.-g. used for copy/paste. 1003 if(mpDocSh) 1004 { 1005 mpDocSh->UpdateRefDevice (); 1006 } 1007 1008 break; 1009 1010 default: 1011 // Ignore unknown values. 1012 break; 1013 } 1014 } 1015 1016 sal_Int32 SdDrawDocument::GetPrinterIndependentLayout (void) 1017 { 1018 return mnPrinterIndependentLayout; 1019 } 1020 1021 bool SdDrawDocument::IsStartWithPresentation() const 1022 { 1023 return mbStartWithPresentation; 1024 } 1025 1026 void SdDrawDocument::SetStartWithPresentation( bool bStartWithPresentation ) 1027 { 1028 mbStartWithPresentation = bStartWithPresentation; 1029 } 1030 1031 // #109538# 1032 void SdDrawDocument::PageListChanged() 1033 { 1034 mpDrawPageListWatcher->Invalidate(); 1035 } 1036 1037 // #109538# 1038 void SdDrawDocument::MasterPageListChanged() 1039 { 1040 mpMasterPageListWatcher->Invalidate(); 1041 } 1042 1043 void SdDrawDocument::SetCalcFieldValueHdl(::Outliner* pOutliner) 1044 { 1045 pOutliner->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl)); 1046 } 1047 1048 sal_uInt16 SdDrawDocument::GetAnnotationAuthorIndex( const rtl::OUString& rAuthor ) 1049 { 1050 // force current user to have first color 1051 if( maAnnotationAuthors.empty() ) 1052 { 1053 SvtUserOptions aUserOptions; 1054 maAnnotationAuthors.push_back( aUserOptions.GetFullName() ); 1055 } 1056 1057 sal_uInt16 idx = 0; 1058 for( std::vector< OUString >::iterator iter( maAnnotationAuthors.begin() ); iter != maAnnotationAuthors.end(); iter++ ) 1059 { 1060 if( (*iter) == rAuthor ) 1061 { 1062 break; 1063 } 1064 idx++; 1065 } 1066 1067 if( idx == maAnnotationAuthors.size() ) 1068 { 1069 maAnnotationAuthors.push_back( rAuthor ); 1070 } 1071 1072 return idx; 1073 } 1074 1075 // eof 1076