sd/source/ui/app/sdmod2.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 <editeng/eeitem.hxx>
  21 #include <editeng/flditem.hxx>
  22 #include <sfx2/printer.hxx>
  23 #include <svl/inethist.hxx>
  24 #include <svl/poolitem.hxx>
  25 #include <svl/flagitem.hxx>
  26 #include <unotools/useroptions.hxx>
  27 #include <sfx2/bindings.hxx>
  28 #include <vcl/msgbox.hxx>
  29 #include <sfx2/viewfrm.hxx>
  30 #include <sfx2/docfile.hxx>
  31 #include <sfx2/request.hxx>
  32
  33 #include <editeng/measfld.hxx>
  34 #include <editeng/editstat.hxx>
  35 #include <editeng/editeng.hxx>
  36
  37 #include <svx/dialogs.hrc>
  38 #include <svx/svdotext.hxx>
  39 #include <svx/svdpagv.hxx>
  40 #include <svx/svdopage.hxx>
  41
  42 #include <sfx2/sfxdlg.hxx>
  43
  44
  45 #include <svx/sdr/contact/displayinfo.hxx>
  46
  47 #include "sdmod.hxx"
  48 #include "app.hrc"
  49 #include "glob.hrc"
  50 #include "strings.hrc"
  51 #include "res_bmp.hrc"
  52 #include "ViewShell.hxx"
  53 #include "FrameView.hxx"
  54 #include "sdattr.hxx"
  55 #include "tpoption.hrc"
  56 #include "optsitem.hxx"
  57 #include "DrawDocShell.hxx"
  58 #include "drawdoc.hxx"
  59 #include "Outliner.hxx"
  60 #include "sdresid.hxx"
  61 #include "pres.hxx"
  62 #include "DrawViewShell.hxx"
  63 #include "OutlineViewShell.hxx"
  64 #include "OutlineView.hxx"
  65 #include "ViewShellBase.hxx"
  66 #include "sdpage.hxx"
  67 #include "sdxfer.hxx"
  68 #include "sdabstdlg.hxx"
  69 #include "prntopts.hrc"
  70 #include <svl/intitem.hxx>
  71
  72 /** retrieves the page that is currently painted. This will only be the master page
  73     if the current drawn view only shows the master page*/
  74 static SdPage* GetCurrentPage( sd::ViewShell* pViewSh, EditFieldInfo* pInfo, bool& bMasterView )
  75 {
  76     if( !pInfo )
  77         return 0;
  78
  79     bMasterView = false;
  80     SdPage* pPage = dynamic_cast< SdPage* >( pInfo->GetSdrPage() );
  81     SdrOutliner* pOutliner = dynamic_cast< SdrOutliner* >( pInfo->GetOutliner() );
  82
  83     // special case, someone already set the current page on the EditFieldInfo
  84     // This is used from the svx::UnoGraphicsExporter f.e.
  85     if( pPage )
  86     {
  87         bMasterView = false;
  88         return pPage;
  89     }
  90
  91     // first try to check if we are inside the outline view
  92     sd::OutlineView* pSdView = NULL;
  93     if( pViewSh && pViewSh->ISA(sd::OutlineViewShell))
  94         pSdView = static_cast<sd::OutlineView*> (static_cast<sd::OutlineViewShell*>(pViewSh)->GetView());
  95
  96     if (pSdView != NULL && (pOutliner ==  pSdView->GetOutliner()))
  97     {
  98         // outline mode
  99         int nPgNum = 0;
 100         Outliner* pOutl = pSdView->GetOutliner();
 101         long nPos = pInfo->GetPara();
 102         sal_Int32 nParaPos = 0;
 103
 104         for( Paragraph* pPara = pOutl->GetParagraph( 0 ); pPara && nPos >= 0; pPara = pOutl->GetParagraph( ++nParaPos ), nPos-- )
 105         {
 106             if( pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ) )
 107                 nPgNum++;
 108         }
 109
 110         pPage = pViewSh->GetDoc()->GetSdPage( (sal_uInt16)nPgNum, PK_STANDARD );
 111     }
 112     else
 113     {
 114         // draw mode, slide mode and preview. Get the processed page from the outliner
 115         if(pOutliner)
 116         {
 117             pPage = dynamic_cast< SdPage* >(const_cast< SdrPage* >(pOutliner->getVisualizedPage()));
 118         }
 119
 120         // The path using GetPaintingPageView() and GetCurrentPaintingDisplayInfo()
 121         // is no longer needed. I debugged and checked all usages of PageNumber decompositions
 122         // which all use the new possibility of setting the visualized page at the SdrOutliner.
 123
 124         // if all else failed, geht the current page from the object that is
 125         // currently formated from the document
 126         if(!pPage)
 127         {
 128             const SdrTextObj* pTextObj = (pViewSh && pViewSh->GetDoc()) ? pViewSh->GetDoc()->GetFormattingTextObj() : NULL;
 129
 130             if( pTextObj )
 131             {
 132                 pPage = dynamic_cast< SdPage* >( pTextObj->GetPage() );
 133             }
 134         }
 135
 136         if(pPage)
 137         {
 138             bMasterView = pPage && pPage->IsMasterPage();
 139         }
 140     }
 141
 142     return pPage;
 143 }
 144
 145 /**
 146  * Link for CalcFieldValue of Outliners
 147  */
 148 IMPL_LINK(SdModule, CalcFieldValueHdl, EditFieldInfo*, pInfo)
 149 {
 150     if (pInfo)
 151     {
 152         const SvxFieldData* pField = pInfo->GetField().GetField();
 153         ::sd::DrawDocShell*     pDocShell = NULL;
 154         SdDrawDocument* pDoc = 0;
 155
 156         SdrOutliner* pSdrOutliner = dynamic_cast< SdrOutliner* >( pInfo->GetOutliner() );
 157         if( pSdrOutliner )
 158         {
 159             const SdrTextObj* pTextObj = pSdrOutliner->GetTextObj();
 160
 161             if( pTextObj )
 162                 pDoc = dynamic_cast< SdDrawDocument* >( pTextObj->GetModel() );
 163
 164             if( pDoc )
 165                 pDocShell = pDoc->GetDocSh();
 166         }
 167
 168         if( !pDocShell )
 169             pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
 170
 171         const SvxDateField* pDateField = 0;
 172         const SvxExtTimeField* pExtTimeField = 0;
 173         const SvxExtFileField* pExtFileField = 0;
 174         const SvxAuthorField* pAuthorField = 0;
 175         const SvxURLField* pURLField = 0;
 176
 177         if( (pDateField = dynamic_cast< const SvxDateField* >(pField)) != 0 )
 178         {
 179             LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
 180             pInfo->SetRepresentation( pDateField->GetFormatted( *GetNumberFormatter(), eLang ) );
 181         }
 182         else if( (pExtTimeField = dynamic_cast< const SvxExtTimeField *>(pField)) != 0 )
 183         {
 184             LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
 185             pInfo->SetRepresentation( pExtTimeField->GetFormatted( *GetNumberFormatter(), eLang ) );
 186         }
 187         else if( (pExtFileField = dynamic_cast< const SvxExtFileField * >(pField)) != 0 )
 188         {
 189             if( pDocShell && (pExtFileField->GetType() != SVXFILETYPE_FIX) )
 190             {
 191                 String aName;
 192                 if( pDocShell->HasName() )
 193                     aName = pDocShell->GetMedium()->GetName();
 194                 else
 195                     aName = pDocShell->GetName();
 196
 197                 const_cast< SvxExtFileField* >(pExtFileField)->SetFile( aName );
 198             }
 199             pInfo->SetRepresentation( pExtFileField->GetFormatted() );
 200
 201         }
 202         else if( (pAuthorField = dynamic_cast< const SvxAuthorField* >( pField )) != 0  )
 203         {
 204             if( pAuthorField->GetType() != SVXAUTHORTYPE_FIX )
 205             {
 206                 SvtUserOptions aUserOptions;
 207                 SvxAuthorField aAuthorField(
 208                         aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID(),
 209                         pAuthorField->GetType(), pAuthorField->GetFormat() );
 210
 211                 *(const_cast< SvxAuthorField* >(pAuthorField)) = aAuthorField;
 212             }
 213             pInfo->SetRepresentation( pAuthorField->GetFormatted() );
 214
 215         }
 216         else if( dynamic_cast< const SvxPageField*  >(pField) )
 217         {
 218             String aRepresentation;
 219             aRepresentation += sal_Unicode( ' ' );
 220
 221             ::sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : NULL;
 222             if(pViewSh == NULL)
 223             {
 224                 ::sd::ViewShellBase* pBase = PTR_CAST(::sd::ViewShellBase, SfxViewShell::Current());
 225                 if(pBase)
 226                     pViewSh = pBase->GetMainViewShell().get();
 227             }
 228             if( !pDoc && pViewSh )
 229                 pDoc = pViewSh->GetDoc();
 230
 231             bool bMasterView;
 232             SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
 233
 234             if( pPage && pDoc && !bMasterView )
 235             {
 236                 int nPgNum;
 237
 238                 if( (pPage->GetPageKind() == PK_HANDOUT) && pViewSh )
 239                 {
 240                     nPgNum = pViewSh->GetPrintedHandoutPageNum();
 241                 }
 242                 else
 243                 {
 244                     nPgNum = (pPage->GetPageNum() - 1) / 2 + 1;
 245                 }
 246                 aRepresentation = pDoc->CreatePageNumValue((sal_uInt16)nPgNum);
 247             }
 248             else
 249                 aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_NUMBER).toString();
 250
 251             pInfo->SetRepresentation( aRepresentation );
 252         }
 253         else if( dynamic_cast< const SvxPagesField*  >(pField) )
 254         {
 255             String aRepresentation;
 256             aRepresentation += sal_Unicode( ' ' );
 257
 258             ::sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : NULL;
 259             if(pViewSh == NULL)
 260             {
 261                 ::sd::ViewShellBase* pBase = PTR_CAST(::sd::ViewShellBase, SfxViewShell::Current());
 262                 if(pBase)
 263                     pViewSh = pBase->GetMainViewShell().get();
 264             }
 265             if( !pDoc && pViewSh )
 266                 pDoc = pViewSh->GetDoc();
 267
 268             bool bMasterView;
 269             SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
 270
 271             sal_uInt16 nPageCount = 0;
 272
 273             if( !bMasterView )
 274             {
 275                 if( pPage && (pPage->GetPageKind() == PK_HANDOUT) && pViewSh )
 276                 {
 277                     nPageCount = pViewSh->GetPrintedHandoutPageCount();
 278                 }
 279                 else if( pDoc )
 280                 {
 281                     nPageCount = (sal_uInt16)pDoc->GetSdPageCount(PK_STANDARD);
 282                 }
 283             }
 284
 285             if( nPageCount > 0 )
 286                 aRepresentation = pDoc->CreatePageNumValue(nPageCount);
 287             else
 288                 aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_COUNT).toString();
 289
 290             pInfo->SetRepresentation( aRepresentation );
 291         }
 292         else if( (pURLField = dynamic_cast< const SvxURLField* >(pField)) != 0 )
 293         {
 294             switch ( pURLField->GetFormat() )
 295             {
 296                 case SVXURLFORMAT_APPDEFAULT: //!!! adjustable at App???
 297                 case SVXURLFORMAT_REPR:
 298                     pInfo->SetRepresentation( pURLField->GetRepresentation() );
 299                     break;
 300
 301                 case SVXURLFORMAT_URL:
 302                     pInfo->SetRepresentation( pURLField->GetURL() );
 303                     break;
 304             }
 305
 306             String aURL = pURLField->GetURL();
 307
 308             svtools::ColorConfig aConfig;
 309             svtools::ColorConfigEntry eEntry =
 310                 INetURLHistory::GetOrCreate()->QueryUrl( aURL ) ? svtools::LINKSVISITED : svtools::LINKS;
 311             pInfo->SetTxtColor( aConfig.GetColorValue(eEntry).nColor );
 312         }
 313         else if ( dynamic_cast< const SdrMeasureField* >(pField))
 314         {
 315             pInfo->ClearFldColor();
 316         }
 317         else
 318         {
 319             String aRepresentation;
 320
 321             bool bHeaderField = dynamic_cast< const SvxHeaderField* >( pField ) != 0;
 322             bool bFooterField = !bHeaderField && (dynamic_cast< const SvxFooterField* >( pField ) != 0 );
 323             bool bDateTimeField = !bHeaderField && !bFooterField && (dynamic_cast< const SvxDateTimeField* >( pField ) != 0);
 324
 325             if( bHeaderField || bFooterField || bDateTimeField )
 326             {
 327                 sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : NULL;
 328                 bool bMasterView = false;
 329                 SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
 330
 331                 if( (pPage == NULL) || bMasterView )
 332                 {
 333                     if( bHeaderField )
 334                         aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_HEADER).toString();
 335                     else if (bFooterField )
 336                         aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_FOOTER).toString();
 337                     else if (bDateTimeField )
 338                         aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_DATETIME).toString();
 339                 }
 340                 else
 341                 {
 342                     const sd::HeaderFooterSettings &rSettings = pPage->getHeaderFooterSettings();
 343
 344                     if( bHeaderField )
 345                     {
 346                         aRepresentation = rSettings.maHeaderText;
 347                     }
 348                     else if( bFooterField )
 349                     {
 350                         aRepresentation = rSettings.maFooterText;
 351                     }
 352                     else if( bDateTimeField )
 353                     {
 354                         if( rSettings.mbDateTimeIsFixed )
 355                         {
 356                             aRepresentation = rSettings.maDateTimeText;
 357                         }
 358                         else
 359                         {
 360                             Date aDate( Date::SYSTEM );
 361                             Time aTime( Time::SYSTEM );
 362                             LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
 363                             aRepresentation = SvxDateTimeField::GetFormatted( aDate, aTime, (SvxDateFormat)rSettings.meDateTimeFormat, *GetNumberFormatter(), eLang );
 364                         }
 365                     }
 366                 }
 367             }
 368             else
 369             {
 370                 OSL_FAIL("sd::SdModule::CalcFieldValueHdl(), unknown field type!");
 371             }
 372
 373             if( aRepresentation.Len() == 0 )                // TODO: Edit engine doesn't handle empty fields?
 374                 aRepresentation += sal_Unicode( ' ' );
 375             pInfo->SetRepresentation( aRepresentation );
 376         }
 377     }
 378
 379     return(0);
 380 }
 381
 382
 383 /**
 384  * virtual methods for option dialog
 385  */
 386 SfxItemSet*  SdModule::CreateItemSet( sal_uInt16 nSlot )
 387 {
 388     ::sd::FrameView* pFrameView = NULL;
 389     ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 390     SdDrawDocument* pDoc = NULL;
 391
 392     // Here we set the DocType of the option dialog (not document!)
 393     DocumentType eDocType = DOCUMENT_TYPE_IMPRESS;
 394     if( nSlot == SID_SD_GRAPHIC_OPTIONS )
 395         eDocType = DOCUMENT_TYPE_DRAW;
 396
 397     if (pDocSh)
 398     {
 399         pDoc = pDocSh->GetDoc();
 400
 401         // If the option dialog is identical to the document type,
 402         // we can pass the FrameView too:
 403         if( pDoc && eDocType == pDoc->GetDocumentType() )
 404             pFrameView = pDocSh->GetFrameView();
 405
 406         ::sd::ViewShell* pViewShell = pDocSh->GetViewShell();
 407         if (pViewShell != NULL)
 408             pViewShell->WriteFrameViewData();
 409     }
 410
 411     SdOptions* pOptions = GetSdOptions(eDocType);
 412
 413     // Pool has by default MapUnit Twips (Awgh!)
 414     SfxItemPool& rPool = GetPool();
 415     rPool.SetDefaultMetric( SFX_MAPUNIT_100TH_MM );
 416
 417     SfxItemSet*  pRet = new SfxItemSet( rPool,
 418                         SID_ATTR_METRIC, SID_ATTR_METRIC,
 419                         SID_ATTR_DEFTABSTOP, SID_ATTR_DEFTABSTOP,
 420
 421                         ATTR_OPTIONS_LAYOUT, ATTR_OPTIONS_LAYOUT,
 422                         ATTR_OPTIONS_CONTENTS, ATTR_OPTIONS_CONTENTS,
 423                         ATTR_OPTIONS_MISC, ATTR_OPTIONS_MISC,
 424
 425                         ATTR_OPTIONS_SNAP, ATTR_OPTIONS_SNAP,
 426
 427                         ATTR_OPTIONS_SCALE_START, ATTR_OPTIONS_SCALE_END,
 428
 429                         ATTR_OPTIONS_PRINT, ATTR_OPTIONS_PRINT,
 430
 431                         SID_ATTR_GRID_OPTIONS, SID_ATTR_GRID_OPTIONS,
 432                         0 );
 433
 434     // TP_OPTIONS_LAYOUT:
 435     pRet->Put( SdOptionsLayoutItem( ATTR_OPTIONS_LAYOUT, pOptions, pFrameView ) );
 436
 437     sal_uInt16 nDefTab = 0;
 438     if( pFrameView)
 439         nDefTab = pDoc->GetDefaultTabulator();
 440     else
 441         nDefTab = pOptions->GetDefTab();
 442     pRet->Put( SfxUInt16Item( SID_ATTR_DEFTABSTOP, nDefTab ) );
 443
 444     FieldUnit nMetric = (FieldUnit)0xffff;
 445     if( pFrameView)
 446         nMetric = pDoc->GetUIUnit();
 447     else
 448         nMetric = (FieldUnit)pOptions->GetMetric();
 449
 450     if( nMetric == (FieldUnit)0xffff )
 451         nMetric = GetFieldUnit();
 452
 453     pRet->Put( SfxUInt16Item( SID_ATTR_METRIC, (sal_uInt16)nMetric ) );
 454
 455     // TP_OPTIONS_CONTENTS:
 456     pRet->Put( SdOptionsContentsItem( ATTR_OPTIONS_CONTENTS, pOptions, pFrameView ) );
 457
 458     // TP_OPTIONS_MISC:
 459     SdOptionsMiscItem aSdOptionsMiscItem( ATTR_OPTIONS_MISC, pOptions, pFrameView );
 460     if ( pFrameView )
 461     {
 462         aSdOptionsMiscItem.GetOptionsMisc().SetSummationOfParagraphs( pDoc->IsSummationOfParagraphs() );
 463         aSdOptionsMiscItem.GetOptionsMisc().SetPrinterIndependentLayout (
 464             (sal_uInt16)pDoc->GetPrinterIndependentLayout());
 465     }
 466     pRet->Put( aSdOptionsMiscItem );
 467
 468
 469     // TP_OPTIONS_SNAP:
 470     pRet->Put( SdOptionsSnapItem( ATTR_OPTIONS_SNAP, pOptions, pFrameView ) );
 471
 472     // TP_SCALE:
 473     sal_uInt32 nW = 10L;
 474     sal_uInt32 nH = 10L;
 475     sal_Int32  nX;
 476     sal_Int32  nY;
 477     if( pDocSh )
 478     {
 479         SdrPage* pPage = (SdrPage*) pDoc->GetSdPage(0, PK_STANDARD);
 480         Size aSize(pPage->GetSize());
 481         nW = aSize.Width();
 482         nH = aSize.Height();
 483     }
 484
 485     if(pFrameView)
 486     {
 487         const Fraction& rFraction =  pDoc->GetUIScale();
 488         nX=rFraction.GetNumerator();
 489         nY=rFraction.GetDenominator();
 490     }
 491     else
 492     {
 493         // Get options from configuration file
 494         pOptions->GetScale( nX, nY );
 495     }
 496
 497     pRet->Put( SfxInt32Item( ATTR_OPTIONS_SCALE_X, nX ) );
 498     pRet->Put( SfxInt32Item( ATTR_OPTIONS_SCALE_Y, nY ) );
 499     pRet->Put( SfxUInt32Item( ATTR_OPTIONS_SCALE_WIDTH, nW ) );
 500     pRet->Put( SfxUInt32Item( ATTR_OPTIONS_SCALE_HEIGHT, nH ) );
 501
 502
 503     // TP_OPTIONS_PRINT:
 504     pRet->Put( SdOptionsPrintItem( ATTR_OPTIONS_PRINT, pOptions ) );
 505
 506     // RID_SVXPAGE_GRID:
 507     pRet->Put( SdOptionsGridItem( SID_ATTR_GRID_OPTIONS, pOptions ) );
 508
 509     return pRet;
 510 }
 511 void SdModule::ApplyItemSet( sal_uInt16 nSlot, const SfxItemSet& rSet )
 512 {
 513     const SfxPoolItem*  pItem = NULL;
 514     sal_Bool bNewDefTab = sal_False;
 515     sal_Bool bNewPrintOptions = sal_False;
 516     sal_Bool bMiscOptions = sal_False;
 517
 518     ::sd::DrawDocShell* pDocSh = PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 519     SdDrawDocument* pDoc = NULL;
 520     // Here we set the DocType of the option dialog (not document!)
 521     DocumentType eDocType = DOCUMENT_TYPE_IMPRESS;
 522     if( nSlot == SID_SD_GRAPHIC_OPTIONS )
 523         eDocType = DOCUMENT_TYPE_DRAW;
 524
 525     ::sd::ViewShell* pViewShell = NULL;
 526
 527     if (pDocSh)
 528     {
 529         pDoc = pDocSh->GetDoc();
 530
 531         pViewShell = pDocSh->GetViewShell();
 532         if (pViewShell != NULL)
 533             pViewShell->WriteFrameViewData();
 534     }
 535     SdOptions* pOptions = GetSdOptions(eDocType);
 536     // Grid
 537     if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_GRID_OPTIONS ,
 538                             sal_False, (const SfxPoolItem**) &pItem ))
 539     {
 540         const SdOptionsGridItem* pGridItem = (SdOptionsGridItem*) pItem;
 541         pGridItem->SetOptions( pOptions );
 542     }
 543
 544     // Layout
 545     const SdOptionsLayoutItem* pLayoutItem = NULL;
 546     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_LAYOUT,
 547                             sal_False, (const SfxPoolItem**) &pLayoutItem ))
 548     {
 549         pLayoutItem->SetOptions( pOptions );
 550     }
 551
 552     // Metric
 553     if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_METRIC, sal_False, &pItem ) )
 554     {
 555         if( pDoc && eDocType == pDoc->GetDocumentType() )
 556             PutItem( *pItem );
 557         pOptions->SetMetric( ( (SfxUInt16Item*) pItem )->GetValue() );
 558     }
 559     sal_uInt16 nDefTab = pOptions->GetDefTab();
 560     // Default-Tabulator
 561     if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_DEFTABSTOP, sal_False, &pItem ) )
 562     {
 563         nDefTab = ( (SfxUInt16Item*) pItem )->GetValue();
 564         pOptions->SetDefTab( nDefTab );
 565
 566         bNewDefTab = sal_True;
 567     }
 568
 569     // Scale
 570     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_SCALE_X, sal_False, &pItem ) )
 571     {
 572         sal_Int32 nX = ( (SfxInt32Item*) pItem )->GetValue();
 573         if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_SCALE_Y, sal_False, &pItem ) )
 574         {
 575             sal_Int32 nY = ( (SfxInt32Item*) pItem )->GetValue();
 576             pOptions->SetScale( nX, nY );
 577
 578             // Apply to document only if doc type match
 579             if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
 580             {
 581                 pDoc->SetUIScale( Fraction( nX, nY ) );
 582                 if( pViewShell )
 583                     pViewShell->SetRuler( pViewShell->HasRuler() );
 584             }
 585         }
 586     }
 587
 588     // Contents
 589     const SdOptionsContentsItem* pContentsItem = NULL;
 590     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_CONTENTS,
 591                             sal_False, (const SfxPoolItem**) &pContentsItem ))
 592     {
 593         pContentsItem->SetOptions( pOptions );
 594     }
 595
 596     // Misc
 597     const SdOptionsMiscItem* pMiscItem = NULL;
 598     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_MISC,
 599                             sal_False, (const SfxPoolItem**) &pMiscItem ))
 600     {
 601         pMiscItem->SetOptions( pOptions );
 602         bMiscOptions = sal_True;
 603     }
 604
 605     // Snap
 606     const SdOptionsSnapItem* pSnapItem = NULL;
 607     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_SNAP,
 608                             sal_False, (const SfxPoolItem**) &pSnapItem ))
 609     {
 610         pSnapItem->SetOptions( pOptions );
 611     }
 612
 613     SfxItemSet aPrintSet( GetPool(),
 614                     SID_PRINTER_NOTFOUND_WARN,  SID_PRINTER_NOTFOUND_WARN,
 615                     SID_PRINTER_CHANGESTODOC,   SID_PRINTER_CHANGESTODOC,
 616                     ATTR_OPTIONS_PRINT,         ATTR_OPTIONS_PRINT,
 617                     0 );
 618
 619     // Print
 620     const SdOptionsPrintItem* pPrintItem = NULL;
 621     if( SFX_ITEM_SET == rSet.GetItemState( ATTR_OPTIONS_PRINT,
 622                             sal_False, (const SfxPoolItem**) &pPrintItem ))
 623     {
 624         pPrintItem->SetOptions( pOptions );
 625
 626         // set PrintOptionsSet
 627         SdOptionsPrintItem aPrintItem( ATTR_OPTIONS_PRINT, pOptions );
 628         SfxFlagItem aFlagItem( SID_PRINTER_CHANGESTODOC );
 629         sal_uInt16      nFlags = 0;
 630
 631         nFlags =  (aPrintItem.GetOptionsPrint().IsWarningSize() ? SFX_PRINTER_CHG_SIZE : 0) |
 632                 (aPrintItem.GetOptionsPrint().IsWarningOrientation() ? SFX_PRINTER_CHG_ORIENTATION : 0);
 633         aFlagItem.SetValue( nFlags );
 634
 635         aPrintSet.Put( aPrintItem );
 636         aPrintSet.Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, aPrintItem.GetOptionsPrint().IsWarningPrinter() ) );
 637         aPrintSet.Put( aFlagItem );
 638
 639         bNewPrintOptions = sal_True;
 640     }
 641
 642     // Only if also the document type matches...
 643     if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
 644     {
 645         if( bNewPrintOptions )
 646         {
 647             pDocSh->GetPrinter(sal_True)->SetOptions( aPrintSet );
 648         }
 649
 650         // set DefTab at Model
 651         if( bNewDefTab )
 652         {
 653             SdDrawDocument* pDocument = pDocSh->GetDoc();
 654             pDocument->SetDefaultTabulator( nDefTab );
 655
 656             ::sd::Outliner* pOutl = pDocument->GetOutliner( sal_False );
 657             if( pOutl )
 658                 pOutl->SetDefTab( nDefTab );
 659
 660             ::sd::Outliner* pInternalOutl = pDocument->GetInternalOutliner( sal_False );
 661             if( pInternalOutl )
 662                 pInternalOutl->SetDefTab( nDefTab );
 663         }
 664         if ( bMiscOptions )
 665         {
 666             pDoc->SetSummationOfParagraphs( pMiscItem->GetOptionsMisc().IsSummationOfParagraphs() );
 667             sal_uInt32 nSum = pMiscItem->GetOptionsMisc().IsSummationOfParagraphs() ? EE_CNTRL_ULSPACESUMMATION : 0;
 668             sal_uInt32 nCntrl;
 669
 670             SdDrawDocument* pDocument = pDocSh->GetDoc();
 671             SdrOutliner& rOutl = pDocument->GetDrawOutliner();
 672             nCntrl = rOutl.GetControlWord() &~ EE_CNTRL_ULSPACESUMMATION;
 673             rOutl.SetControlWord( nCntrl | nSum );
 674             ::sd::Outliner* pOutl = pDocument->GetOutliner( sal_False );
 675             if( pOutl )
 676             {
 677                 nCntrl = pOutl->GetControlWord() &~ EE_CNTRL_ULSPACESUMMATION;
 678                 pOutl->SetControlWord( nCntrl | nSum );
 679             }
 680             pOutl = pDocument->GetInternalOutliner( sal_False );
 681             if( pOutl )
 682             {
 683                 nCntrl = pOutl->GetControlWord() &~ EE_CNTRL_ULSPACESUMMATION;
 684                 pOutl->SetControlWord( nCntrl | nSum );
 685             }
 686
 687             // Set printer independent layout mode.
 688             if( pDoc->GetPrinterIndependentLayout() != pMiscItem->GetOptionsMisc().GetPrinterIndependentLayout() )
 689                 pDoc->SetPrinterIndependentLayout (pMiscItem->GetOptionsMisc().GetPrinterIndependentLayout());
 690         }
 691     }
 692
 693     pOptions->StoreConfig();
 694
 695     // Only if also the document type matches...
 696     if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
 697     {
 698         FieldUnit eUIUnit = (FieldUnit) pOptions->GetMetric();
 699         pDoc->SetUIUnit(eUIUnit);
 700
 701         if (pViewShell)
 702         {
 703             // make sure no one is in text edit mode, cause there
 704             // are some pointers remembered else (!)
 705             if(pViewShell->GetView())
 706                 pViewShell->GetView()->SdrEndTextEdit();
 707
 708             ::sd::FrameView* pFrame = pViewShell->GetFrameView();
 709             pFrame->Update(pOptions);
 710             pViewShell->ReadFrameViewData(pFrame);
 711             pViewShell->SetUIUnit(eUIUnit);
 712             pViewShell->SetDefTabHRuler( nDefTab );
 713         }
 714     }
 715
 716     if( pViewShell && pViewShell->GetViewFrame() )
 717         pViewShell->GetViewFrame()->GetBindings().InvalidateAll( sal_True );
 718 }
 719
 720 SfxTabPage* SdModule::CreateTabPage( sal_uInt16 nId, Window* pParent, const SfxItemSet& rSet )
 721 {
 722     SfxTabPage* pRet = NULL;
 723     SfxAllItemSet aSet(*(rSet.GetPool()));
 724     SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 725     if( pFact )
 726     {
 727         switch(nId)
 728         {
 729             case SID_SD_TP_CONTENTS:
 730             case SID_SI_TP_CONTENTS:
 731             {   ::CreateTabPage fnCreatePage = pFact->GetSdOptionsContentsTabPageCreatorFunc();
 732                 if( fnCreatePage )
 733                     pRet = (*fnCreatePage)( pParent, rSet );
 734             }
 735             break;
 736             case SID_SD_TP_SNAP:
 737             case SID_SI_TP_SNAP:
 738             {   ::CreateTabPage fnCreatePage = pFact->GetSdOptionsSnapTabPageCreatorFunc();
 739                 if( fnCreatePage )
 740                     pRet = (*fnCreatePage)( pParent, rSet );
 741             }
 742             break;
 743             case SID_SD_TP_PRINT:
 744             case SID_SI_TP_PRINT:
 745             {
 746                 ::CreateTabPage fnCreatePage = pFact->GetSdPrintOptionsTabPageCreatorFunc();
 747                 if( fnCreatePage )
 748                 {
 749                     pRet = (*fnCreatePage)( pParent, rSet );
 750                     if(SID_SD_TP_PRINT == nId)
 751                         aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_DRAW_MODE));
 752                     pRet->PageCreated(aSet);
 753                 }
 754             }
 755             break;
 756             case SID_SI_TP_MISC:
 757             case SID_SD_TP_MISC:
 758             {
 759                 ::CreateTabPage fnCreatePage = pFact->GetSdOptionsMiscTabPageCreatorFunc();
 760                 if( fnCreatePage )
 761                 {
 762                     pRet = (*fnCreatePage)( pParent, rSet );
 763                     if(SID_SD_TP_MISC == nId)
 764                         aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_DRAW_MODE));
 765                     else
 766                         aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_IMPRESS_MODE));
 767                     pRet->PageCreated(aSet);
 768                 }
 769             }
 770             break;
 771             case RID_OFA_TP_INTERNATIONAL_SD:
 772             case RID_OFA_TP_INTERNATIONAL_IMPR:
 773             case RID_SVXPAGE_TEXTANIMATION :
 774             {
 775                 SfxAbstractDialogFactory* pSfxFact = SfxAbstractDialogFactory::Create();
 776                 if ( pSfxFact )
 777                 {
 778                     ::CreateTabPage fnCreatePage = pSfxFact->GetTabPageCreatorFunc( nId );
 779                     if ( fnCreatePage )
 780                         pRet = (*fnCreatePage)( pParent, rSet );
 781                 }
 782             }
 783             break;
 784         }
 785         DBG_ASSERT( pRet, "SdModule::CreateTabPage(): no valid ID for TabPage!" );
 786     }
 787
 788     return pRet;
 789 }
 790
 791 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */