sd/source/ui/view/PrintManager.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PrintManager.cxx,v $
  10  * $Revision: 1.24.8.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include <basegfx/polygon/b2dpolygon.hxx>
  35 #include <basegfx/polygon/b2dpolypolygon.hxx>
  36 #include <basegfx/matrix/b2dhommatrix.hxx>
  37
  38 #include "PrintManager.hxx"
  39
  40 #include <svx/editstat.hxx>
  41 #include "optsitem.hxx"
  42 #include "sdattr.hxx"
  43 #include "sdpage.hxx"
  44 #include "drawdoc.hxx"
  45 #include "drawview.hxx"
  46 #include "ViewShellBase.hxx"
  47 #include "DrawViewShell.hxx"
  48 #include "OutlineViewShell.hxx"
  49 #include "Outliner.hxx"
  50 #include "Window.hxx"
  51 #include "FrameView.hxx"
  52 #include <sfx2/progress.hxx>
  53 #include <svtools/printdlg.hxx>
  54 #include <tools/multisel.hxx>
  55 #include <svtools/misccfg.hxx>
  56 #include <unotools/localedatawrapper.hxx>
  57 #include <svx/prtqry.hxx>
  58 #include "WindowUpdater.hxx"
  59 #include <sfx2/printer.hxx>
  60 #include <svx/svdoutl.hxx>
  61 #include "sdresid.hxx"
  62 #include <svx/svdetc.hxx>
  63 #include <svx/svdopage.hxx>
  64 #include <svx/svdpagv.hxx>
  65 #include <svx/svditer.hxx>
  66
  67 #include "strings.hrc"
  68
  69 #include <svx/svdopath.hxx>
  70 #include "sdabstdlg.hxx"
  71 #include "printdlg.hrc"
  72 #include "prntopts.hrc"
  73 #include "app.hrc"
  74 #include <svtools/intitem.hxx>
  75 #include <svx/paperinf.hxx>
  76 #include <svx/xlnclit.hxx>
  77 #include "printdialog.hxx"
  78
  79 namespace sd {
  80
  81 /** This simple container reduces the number of arguments that have to be
  82     passed around and makes it easier to modify the set of arguments.
  83 */
  84 class PrintManager::PrintInfo
  85 {
  86 public:
  87     PrintInfo (
  88         ViewShell& rViewShell,
  89         SfxPrinter& rPrinter,
  90         SfxProgress& rProgress,
  91         const MultiSelection& rSelPages,
  92         const String& rTimeDateStr,
  93         const Font& rTimeDateFont,
  94         const SdOptionsPrintItem* pPrintOpts,
  95         USHORT nPageMax,
  96         USHORT nCopies,
  97         USHORT nProgressOffset,
  98         USHORT nTotal)
  99         : mrViewShell(rViewShell),
 100           mrPrinter(rPrinter),
 101           mrProgress(rProgress),
 102           mrSelPages(rSelPages),
 103           mrTimeDateStr(rTimeDateStr),
 104           mrTimeDateFont(rTimeDateFont),
 105           mpPrintOpts(pPrintOpts),
 106           mnPageMax(nPageMax),
 107           mnCopies(nCopies),
 108           mnProgressOffset(nProgressOffset),
 109           mnTotal(nTotal)
 110     {}
 111
 112     ViewShell& mrViewShell;
 113     SfxPrinter& mrPrinter;
 114     SfxProgress& mrProgress;
 115     const MultiSelection& mrSelPages;
 116     const String& mrTimeDateStr;
 117     const Font& mrTimeDateFont;
 118     const SdOptionsPrintItem* mpPrintOpts;
 119     USHORT mnPageMax;
 120     USHORT mnCopies;
 121     USHORT mnProgressOffset;
 122     USHORT mnTotal;
 123 };
 124
 125
 126 PrintManager::PrintManager (ViewShellBase& rBase)
 127     : mrBase (rBase)
 128 {
 129 }
 130
 131
 132
 133
 134 PrintManager::~PrintManager (void)
 135 {
 136 }
 137
 138
 139
 140
 141 SfxPrinter* PrintManager::GetPrinter (BOOL bCreate)
 142 {
 143     return mrBase.GetDocShell()->GetPrinter (bCreate);
 144 }
 145
 146
 147
 148
 149 USHORT PrintManager::SetPrinter (
 150     SfxPrinter* pNewPrinter,
 151     USHORT nDiffFlags,bool bIsAPI)
 152 {
 153     return SetPrinterOptDlg (pNewPrinter,nDiffFlags,!bIsAPI);
 154 }
 155
 156
 157
 158
 159 USHORT PrintManager::SetPrinterOptDlg (
 160     SfxPrinter* pNewPrinter,
 161     USHORT nDiffFlags,
 162     BOOL _bShowDialog)
 163 {
 164     mrBase.GetDocShell()->SetPrinter(pNewPrinter);
 165
 166     if ( (nDiffFlags & SFX_PRINTER_CHG_ORIENTATION ||
 167           nDiffFlags & SFX_PRINTER_CHG_SIZE) && pNewPrinter  )
 168     {
 169         MapMode aMap = pNewPrinter->GetMapMode();
 170         aMap.SetMapUnit(MAP_100TH_MM);
 171         MapMode aOldMap = pNewPrinter->GetMapMode();
 172         pNewPrinter->SetMapMode(aMap);
 173         Size aNewSize = pNewPrinter->GetOutputSize();
 174
 175         BOOL bScaleAll = FALSE;
 176         if ( _bShowDialog )
 177         {
 178             WarningBox aWarnBox (
 179                 mrBase.GetWindow(),
 180                 (WinBits)(WB_YES_NO | WB_DEF_YES),
 181                 String(SdResId(STR_SCALE_OBJS_TO_PAGE)));
 182             bScaleAll = (aWarnBox.Execute() == RET_YES);
 183         }
 184
 185         ViewShell* pShell = mrBase.GetMainViewShell().get();
 186         if (pShell != NULL && pShell->ISA(DrawViewShell))
 187         {
 188             SdPage* pPage = mrBase.GetDocument()->GetSdPage(
 189                 0, PK_STANDARD );
 190             pShell->SetPageSizeAndBorder (
 191                 static_cast<DrawViewShell*>(pShell)->GetPageKind(),
 192                 aNewSize,
 193                 -1,-1,-1,-1,
 194                 bScaleAll,
 195                 pNewPrinter->GetOrientation(),
 196                 pPage->GetPaperBin(),
 197                 pPage->IsBackgroundFullSize());
 198         }
 199
 200         pNewPrinter->SetMapMode(aOldMap);
 201     }
 202
 203     return 0;
 204 }
 205
 206
 207
 208
 209 PrintDialog* PrintManager::CreatePrintDialog (::Window *pParent)
 210 {
 211     const bool bImpress = mrBase.GetDocument()->GetDocumentType() == DOCUMENT_TYPE_IMPRESS;
 212
 213     SdPrintDialog* pDlg = SdPrintDialog::Create(pParent,bImpress);
 214
 215     ViewShell* pShell = mrBase.GetMainViewShell().get();
 216     if (pShell!=NULL && ! pShell->ISA(OutlineViewShell))
 217     {
 218
 219         if (pShell->ISA(DrawViewShell))
 220         {
 221             pDlg->SetRangeText(UniString::CreateFromInt32(
 222                 static_cast<DrawViewShell*>(pShell)->GetCurPageId()));
 223         }
 224         /*              else if(pShell->ISA(::sd::slidesorter::SlideSorterViewShell))
 225         {
 226             String aStrRange(
 227                 dynamic_cast<sd::slidesorter::SlideSorterViewShell*>(pShell)->GetPageRangeString());
 228             if( aStrRange.Len() )
 229             {
 230                 pDlg->SetRangeText( aStrRange );
 231                 // According #79749 always check PRINTDIALOG_ALL
 232                 // pDlg->CheckRange( PRINTDIALOG_RANGE );
 233             }
 234         }
 235         */
 236     }
 237     else
 238     {
 239         String aStrRange(
 240             static_cast<OutlineViewShell*>(pShell)->GetPageRangeString());
 241         if( aStrRange.Len() )
 242         {
 243             pDlg->SetRangeText( aStrRange );
 244             // According #79749 always check PRINTDIALOG_ALL
 245             // pDlg->CheckRange( PRINTDIALOG_RANGE );
 246         }
 247     }
 248     pDlg->EnableRange( PRINTDIALOG_RANGE );
 249     pDlg->EnableRange( PRINTDIALOG_ALL );
 250     pDlg->EnableCollate();
 251
 252     if (pShell->ISA(DrawViewShell) && pShell->GetView()->AreObjectsMarked())
 253     {
 254         pDlg->EnableRange( PRINTDIALOG_SELECTION );
 255         // According #79749 always check PRINTDIALOG_ALL
 256         // pDlg->CheckRange( PRINTDIALOG_SELECTION );
 257     }
 258
 259     if( bImpress )
 260     {
 261         const SdOptionsPrintItem* pPrintOpts = 0;
 262
 263         SfxPrinter* pPrinter = mrBase.GetPrinter(FALSE);
 264         if( pPrinter )
 265         {
 266             const SfxPoolItem* pPoolItem = 0;
 267             if(pPrinter->GetOptions().GetItemState(ATTR_OPTIONS_PRINT, FALSE, &pPoolItem ) == SFX_ITEM_SET )
 268                 pPrintOpts = dynamic_cast< const SdOptionsPrintItem* >( pPoolItem );
 269         }
 270         pDlg->Init( pPrintOpts );
 271     }
 272
 273     return pDlg;
 274 }
 275
 276 SfxTabPage*  PrintManager::CreatePrintOptionsPage( ::Window *pParent, const SfxItemSet &rOptions)
 277 {
 278     SfxTabPage* pPage = 0;
 279     DocumentType eDocType = mrBase.GetDocument()->GetDocumentType();
 280     SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 281     ::CreateTabPage fnCreatePage = pFact ? pFact->GetSdPrintOptionsTabPageCreatorFunc() : 0;
 282     if( fnCreatePage )
 283     {
 284         pPage = (*fnCreatePage)( pParent, rOptions );
 285         if( eDocType == DOCUMENT_TYPE_DRAW )
 286         {
 287             SfxAllItemSet aSet(*(rOptions.GetPool()));
 288             aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_DRAW_MODE));
 289             pPage->PageCreated(aSet);
 290         }
 291     }
 292     return pPage;
 293 }
 294
 295
 296
 297
 298 USHORT  PrintManager::Print (SfxProgress& rProgress, BOOL bIsAPI, PrintDialog* pDlg)
 299 {
 300     SfxPrinter* pPrinter = mrBase.GetPrinter(TRUE);
 301     ViewShell* pShell = mrBase.GetMainViewShell().get();
 302
 303     if (pPrinter!=NULL && pShell!=NULL)
 304     {
 305         const PrinterOptions    aOldPrinterOptions( pPrinter->GetPrinterOptions() );
 306         MapMode                 aMap( pPrinter->GetMapMode() );
 307         const MapMode           aOldMap( aMap );
 308         USHORT                  nOldPaperBin = pPrinter->GetPaperBin();
 309
 310         aMap.SetMapUnit(MAP_100TH_MM);
 311         pPrinter->SetMapMode(aMap);
 312
 313         ::Outliner& rOutliner = mrBase.GetDocument()->GetDrawOutliner();
 314         ULONG nOldCntrl = rOutliner.GetControlWord();
 315         ULONG nCntrl = nOldCntrl;
 316         nCntrl &= ~EE_CNTRL_MARKFIELDS;
 317         nCntrl &= ~EE_CNTRL_ONLINESPELLING;
 318         rOutliner.SetControlWord( nCntrl );
 319
 320         // old place of FitPageToPrinterWithDialog().
 321         SdOptionsPrintItem* pPrintOpts = 0;
 322
 323         const SfxPoolItem* pPoolItem = 0;
 324         if (pPrinter->GetOptions().GetItemState( ATTR_OPTIONS_PRINT, FALSE, &pPoolItem ) == SFX_ITEM_SET )
 325             pPrintOpts = dynamic_cast< SdOptionsPrintItem* >( const_cast< SfxPoolItem* >( pPoolItem ) ) ;
 326
 327         if( dynamic_cast<SdPrintDialog*>(pDlg) && static_cast<SdPrintDialog*>(pDlg)->Fill( pPrintOpts ) )
 328         {
 329             SfxItemSet aNewOptions( pPrinter->GetOptions() );
 330             aNewOptions.Put( *pPrintOpts );
 331             pPrinter->SetOptions( aNewOptions );
 332             pPrintOpts = dynamic_cast< SdOptionsPrintItem* >( const_cast< SfxPoolItem* >( pPrinter->GetOptions().GetItem( ATTR_OPTIONS_PRINT ) ) );
 333         }
 334
 335         // Wenn wir im Gliederungsmodus sind, muss das Model auf Stand gebracht werden
 336         if (pShell->ISA(OutlineViewShell))
 337             static_cast<OutlineViewShell*>(pShell)->PrepareClose (FALSE, FALSE);
 338
 339         // Basisklasse rufen, um Basic anzusprechen
 340         mrBase.SfxViewShell::Print( rProgress, bIsAPI, pDlg );
 341
 342         // Setzen des Textes des Druckmonitors
 343         rProgress.SetText( String( SdResId( STR_STATSTR_PRINT ) ) );
 344
 345         PrintDialogRange        eOption;
 346         MultiSelection          aPrintSelection;
 347         String                  aTimeDateStr;
 348         Font                    aTimeDateFont(FAMILY_SWISS, Size(0, 423));
 349         PageKind                ePageKind = PK_STANDARD;
 350         USHORT                  nPage, nPageMax;
 351         USHORT                  nTotal, nCopies;
 352         USHORT                  nPrintCount = 0;
 353         USHORT                  nProgressOffset = 0;
 354         USHORT                  nCollateCopies = 1;
 355         BOOL                    bPrintMarkedOnly = FALSE;
 356         BOOL                    bPrintOutline = FALSE;
 357         BOOL                    bPrintHandout = FALSE;
 358         BOOL                    bPrintDraw = FALSE;
 359         BOOL                    bPrintNotes = FALSE;
 360         BOOL                            bHandoutHorizontal = TRUE;
 361         USHORT                          nSlidesPerHandout = 6;
 362
 363         Orientation eOldOrientation = pPrinter->GetOrientation();
 364
 365         if( pPrintOpts )
 366         {
 367             SfxMiscCfg* pMisc = SFX_APP()->GetMiscConfig();
 368
 369             if( pPrintOpts->GetOptionsPrint().IsDate() )
 370             {
 371                 aTimeDateStr += GetSdrGlobalData().GetLocaleData()->getDate( Date() );
 372                 aTimeDateStr += (sal_Unicode)' ';
 373             }
 374
 375             if( pPrintOpts->GetOptionsPrint().IsTime() )
 376                 aTimeDateStr += GetSdrGlobalData().GetLocaleData()->getTime( Time(), FALSE, FALSE );
 377
 378             if( pPrintOpts->GetOptionsPrint().IsOutline() )
 379                 bPrintOutline = TRUE;
 380
 381             if( pPrintOpts->GetOptionsPrint().IsHandout() )
 382             {
 383                 bPrintHandout = TRUE;
 384                 bHandoutHorizontal = pPrintOpts->GetOptionsPrint().IsHandoutHorizontal();
 385                 nSlidesPerHandout = pPrintOpts->GetOptionsPrint().GetHandoutPages();
 386             }
 387
 388             if( pPrintOpts->GetOptionsPrint().IsDraw() )
 389                 bPrintDraw = TRUE;
 390
 391             if( pPrintOpts->GetOptionsPrint().IsNotes() )
 392             {
 393                 bPrintNotes = TRUE;
 394                 ePageKind = PK_NOTES;
 395             }
 396
 397             pPrintOpts->GetOptionsPrint().SetWarningPrinter( pMisc->IsNotFoundWarning() );
 398             pPrintOpts->GetOptionsPrint().SetWarningSize( pMisc->IsPaperSizeWarning() );
 399             pPrintOpts->GetOptionsPrint().SetWarningOrientation( pMisc->IsPaperOrientationWarning() );
 400
 401             UINT16  nQuality = pPrintOpts->GetOptionsPrint().GetOutputQuality();
 402             ULONG   nMode = DRAWMODE_DEFAULT;
 403
 404             if( nQuality == 1 )
 405                 nMode = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP | DRAWMODE_GRAYGRADIENT;
 406             else if( nQuality == 2 )
 407                 nMode = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP | DRAWMODE_WHITEGRADIENT;
 408
 409             pPrinter->SetDrawMode( nMode );
 410         }
 411         else
 412             bPrintDraw = TRUE;
 413
 414         if( pDlg )
 415         {
 416             eOption = pDlg->GetCheckedRange();
 417
 418             if( eOption == PRINTDIALOG_SELECTION )
 419                 bPrintMarkedOnly = TRUE;
 420         }
 421         else
 422             // Bei PrintDirect wird gesamtes Dokument gedruckt
 423             eOption = PRINTDIALOG_ALL;
 424
 425         // #72527 If we are in PrintDirect and any objects
 426         // are selected, then a dialog (see ViewShell::DoPrint)
 427         // ask whether the total document should be printed
 428         // or only the selected objects. If only the selected
 429         // object, then the flag bPrintDirectSelected is TRUE
 430         if (mbPrintDirectSelected)
 431         {
 432             eOption = PRINTDIALOG_SELECTION;
 433             bPrintMarkedOnly = TRUE;
 434         }
 435
 436         nPageMax = mrBase.GetDocument()->GetSdPageCount( ePageKind );
 437         aPrintSelection.SetTotalRange( Range( 1, nPageMax ) );
 438
 439         switch( eOption )
 440         {
 441             case PRINTDIALOG_ALL:
 442                 aPrintSelection.Select(Range(1, nPageMax));
 443             break;
 444
 445             case PRINTDIALOG_RANGE:
 446                 aPrintSelection = MultiSelection(pDlg->GetRangeText());
 447             break;
 448
 449             default:
 450             {
 451                 if (pShell->ISA(DrawViewShell))
 452                     aPrintSelection.Select (
 453                         static_cast<DrawViewShell*>(pShell)->GetCurPageId());
 454                 else
 455                 {
 456                     if( msPageRange.Len() )
 457                         aPrintSelection = MultiSelection( msPageRange );
 458                     else
 459                         aPrintSelection.Select(Range(1, nPageMax));
 460                 }
 461             }
 462             break;
 463         }
 464
 465         nPage = Min(nPageMax, (USHORT) aPrintSelection.FirstSelected());
 466
 467         if ( nPage > 0 )
 468             nPage--;
 469
 470         nPageMax = Min(nPageMax, (USHORT) aPrintSelection.LastSelected());
 471
 472         if( bPrintOutline )
 473             nPrintCount++;
 474
 475         if( bPrintHandout )
 476             nPrintCount++;
 477
 478         if( bPrintDraw )
 479             nPrintCount++;
 480
 481         if( bPrintNotes )
 482             nPrintCount++;
 483
 484         nCopies = (pDlg ? pDlg->GetCopyCount() : 1);
 485
 486         USHORT nSelectCount = (USHORT) aPrintSelection.GetSelectCount();
 487         nTotal = nSelectCount * nCopies * nPrintCount;
 488
 489         if( pDlg && pDlg->IsCollateEnabled() && pDlg->IsCollateChecked() )
 490             nCollateCopies = nCopies;
 491
 492         // check if selected range of pages contains transparent objects
 493         BOOL bContainsTransparency = FALSE;
 494         BOOL bPrintExcluded = TRUE;
 495
 496         if( bPrintNotes || bPrintDraw || bPrintHandout )
 497         {
 498             if( pPrintOpts )
 499                 bPrintExcluded = pPrintOpts->GetOptionsPrint().IsHiddenPages();
 500
 501             for( USHORT j = nPage; ( j < nPageMax && !bContainsTransparency ); j++ )
 502             {
 503                 if( aPrintSelection.IsSelected( j + 1 ) )
 504                 {
 505                     SdPage* pPage = mrBase.GetDocument()->GetSdPage(
 506                         j, PK_STANDARD );
 507
 508                     if( pPage && ( !pPage->IsExcluded() || bPrintExcluded ) )
 509                     {
 510                         bContainsTransparency = (BOOL)pPage->HasTransparentObjects();
 511                         if( !bContainsTransparency )
 512                         {
 513                             if(pPage->TRG_HasMasterPage())
 514                             {
 515                                 bContainsTransparency = (BOOL)pPage->TRG_GetMasterPage().HasTransparentObjects();
 516                             }
 517                         }
 518                     }
 519                 }
 520             }
 521         }
 522
 523         if (pPrinter->InitJob (mrBase.GetWindow(), !bIsAPI && bContainsTransparency))
 524         {
 525             PrintInfo aInfo(
 526                 *pShell,
 527                 *pPrinter,
 528                 rProgress,
 529                 aPrintSelection,
 530                 aTimeDateStr,
 531                 aTimeDateFont,
 532                 pPrintOpts,
 533                 nPageMax,
 534                 nCollateCopies > 1 ? 1 : nCopies,
 535                 nProgressOffset,
 536                 nTotal);
 537
 538             if( bPrintHandout )
 539                 InitHandoutTemplate( aInfo, nSlidesPerHandout, bHandoutHorizontal );
 540
 541             for( USHORT n = 1; n <= nCollateCopies; n++ )
 542             {
 543                 if ( bPrintOutline )
 544                 {
 545                     // siehe unten in PrintOutline()
 546                     pPrinter->SetPaperBin( nOldPaperBin );
 547
 548                     PrintOutline(aInfo, nPage);
 549                     aInfo.mnProgressOffset += (nSelectCount * ( nCollateCopies > 1 ? 1 : nCopies));
 550                 }
 551
 552                 if ( bPrintHandout )
 553                 {
 554                     PrintHandout(aInfo, nPage );
 555                     aInfo.mnProgressOffset += (nSelectCount * ( nCollateCopies > 1 ? 1 : nCopies));
 556                 }
 557                 if( bPrintDraw )
 558                 {
 559                     PrintStdOrNotes(aInfo, nPage, PK_STANDARD, bPrintMarkedOnly);
 560                     aInfo.mnProgressOffset += (nSelectCount * ( nCollateCopies > 1 ? 1 : nCopies));
 561                 }
 562                 if( bPrintNotes )
 563                 {
 564                     PrintStdOrNotes(aInfo, nPage, PK_NOTES, FALSE);
 565                     aInfo.mnProgressOffset += (nSelectCount * ( nCollateCopies > 1 ? 1 : nCopies));
 566                 }
 567
 568                 // When in duplex mode then add an empty page after printing
 569                 // an odd number of pages.  This is to avoid the first page
 570                 // of the next run being printed on the backside of the
 571                 // current page.
 572                 if (nCollateCopies > 1
 573                     && n<nCollateCopies
 574                     && (pPrinter->GetCurPage()%2)==0
 575                     && (pPrinter->GetDuplexMode()==DUPLEX_ON))
 576                 {
 577                     pPrinter->StartPage();
 578                     pPrinter->EndPage();
 579                 }
 580             }
 581         }
 582
 583         pPrinter->SetOrientation( eOldOrientation );
 584         pPrinter->SetPrinterOptions( aOldPrinterOptions );
 585         pPrinter->SetMapMode( aOldMap );
 586
 587         rOutliner.SetControlWord(nOldCntrl);
 588
 589         // Druckerschach wieder zuruecksetzen
 590         pPrinter->SetPaperBin( nOldPaperBin );
 591     }
 592
 593     return 0;
 594
 595 }
 596
 597
 598
 599
 600 ErrCode PrintManager::DoPrint (
 601     SfxPrinter* pPrinter,
 602     PrintDialog* pPrintDialog,
 603     BOOL bSilent, BOOL bIsAPI )
 604 {
 605     ErrCode nResult = ERRCODE_NONE;
 606
 607     do
 608     {
 609         ViewShell* pShell = mrBase.GetMainViewShell().get();
 610         if (pShell == NULL)
 611             break;
 612
 613         if ( ! FitPageToPrinterWithDialog(pPrinter, bSilent))
 614             break;
 615
 616         const SdrMarkList& rMarkList = pShell->GetView()->GetMarkedObjectList();
 617
 618         // Retrieve the range of marked pages.
 619         String sNewPageRange (msPageRange);
 620
 621         RestrictPrintingToSelection (FALSE);
 622
 623         // #105477# Don't show query dialog if print dialog has been shown
 624         if ( !pPrintDialog
 625             && !bSilent && !bIsAPI
 626             && (rMarkList.GetMarkCount() || sNewPageRange.Len()) )
 627         {
 628             SvxPrtQryBox aQuery (mrBase.GetWindow());
 629
 630             switch (aQuery.Execute())
 631             {
 632                 case RET_CANCEL:
 633                     nResult = ERRCODE_IO_ABORT;
 634                     break;
 635
 636                 case RET_OK:
 637                     RestrictPrintingToSelection (TRUE);
 638                     SetPrintingPageRange (sNewPageRange);
 639                     break;
 640             }
 641         }
 642
 643         if (nResult == ERRCODE_NONE)
 644         {
 645             // Tell the printer which digit language to use.
 646             WindowUpdater* pWindowUpdater = pShell->GetWindowUpdater();
 647             if (pWindowUpdater != NULL)
 648                 pWindowUpdater->Update (pPrinter, mrBase.GetDocument());
 649
 650             //  Forward the call to SfxViewShell::DoPrint() which
 651             //  eventually calls Print() (after StartJob etc.)
 652             nResult = mrBase.SfxViewShell::DoPrint (
 653                 pPrinter, pPrintDialog, bSilent, bIsAPI );
 654
 655             RestrictPrintingToSelection (FALSE);
 656         }
 657     }
 658     while(false);
 659
 660     return nResult;
 661 }
 662
 663
 664
 665
 666 void PrintManager::PreparePrint (PrintDialog* )
 667 {
 668     SfxPrinter* pPrinter = GetPrinter(TRUE);
 669
 670     if (!pPrinter)
 671         return;
 672
 673     const SfxItemSet& rOptions = pPrinter->GetOptions();
 674     SdOptionsPrintItem* pPrintOpts = NULL;
 675
 676     if (rOptions.GetItemState( ATTR_OPTIONS_PRINT, FALSE,
 677         (const SfxPoolItem**) &pPrintOpts) != SFX_ITEM_SET)
 678     {
 679         pPrintOpts = NULL;
 680     }
 681
 682     // Einstellungen der ersten zu druckenden Seite setzen
 683
 684     if (pPrintOpts)
 685     {
 686         if ( pPrintOpts->GetOptionsPrint().IsHandout() )
 687         {
 688             // Handzettel
 689             SdPage* pPage = mrBase.GetDocument()->GetSdPage(0, PK_HANDOUT);
 690
 691             // Papierschacht
 692             if (!pPrintOpts->GetOptionsPrint().IsPaperbin()) // Drucken NICHT aus Druckereinstellung
 693             {
 694                 pPrinter->SetPaperBin(pPage->GetPaperBin());
 695             }
 696
 697             pPrinter->SetOrientation(pPage->TRG_GetMasterPage().GetOrientation());
 698         }
 699         else if ( pPrintOpts->GetOptionsPrint().IsDraw() || pPrintOpts->GetOptionsPrint().IsNotes() )
 700         {
 701             // Standard- oder Notizseiten
 702             if( !pPrintOpts->GetOptionsPrint().IsPaperbin() ) // Drucken NICHT aus Druckereinstellung
 703             {
 704                 PageKind ePageKind = PK_NOTES;
 705
 706                 if (pPrintOpts->GetOptionsPrint().IsDraw())
 707                 {
 708                     ePageKind = PK_STANDARD;
 709                 }
 710
 711                 SdPage* pPage = mrBase.GetDocument()->GetSdPage(0, ePageKind);
 712                 pPrinter->SetPaperBin(pPage->GetPaperBin());
 713
 714                 Orientation eOrientation = ORIENTATION_PORTRAIT;
 715
 716                 if ( !pPrintOpts->GetOptionsPrint().IsBooklet() )
 717                 {
 718                     eOrientation = pPage->GetOrientation();
 719                 }
 720                 else
 721                 {
 722                     Size aPageSize(pPage->GetSize());
 723
 724                     if( aPageSize.Width() < aPageSize.Height() )
 725                         eOrientation = ORIENTATION_LANDSCAPE;
 726                 }
 727
 728                 pPrinter->SetOrientation(eOrientation);
 729             }
 730         }
 731     }
 732 }
 733
 734
 735
 736
 737 void PrintManager::RestrictPrintingToSelection (bool bFlag)
 738 {
 739     mbPrintDirectSelected = bFlag ? TRUE : FALSE;
 740 }
 741
 742
 743
 744
 745 void PrintManager::SetPrintingPageRange (const String& rsPageRange)
 746 {
 747     msPageRange = rsPageRange;
 748 }
 749
 750
 751
 752
 753 bool PrintManager::FitPageToPrinterWithDialog (
 754     SfxPrinter* pPrinter,
 755     bool bSilent)
 756 {
 757     bool bContinuePrinting = true;
 758
 759     if (pPrinter != NULL)
 760     {
 761         // Remember old printer values so that they can be restored when
 762         // printing is aborted by the user.
 763         const PrinterOptions aOldPrinterOptions (pPrinter->GetPrinterOptions());
 764         const MapMode aOldMap (pPrinter->GetMapMode());
 765
 766         // Get values from the priner in order to decide whether to show a
 767         // dialog.
 768         const SfxItemSet&       rOptions = pPrinter->GetOptions();
 769         SdOptionsPrintItem* pPrintOpts = NULL;
 770         BOOL                bScalePage = TRUE;
 771         BOOL                bTilePage = FALSE;
 772         BOOL                bNotesPage = FALSE;
 773         BOOL                bPrintBooklet = FALSE;
 774
 775         if( rOptions.GetItemState( ATTR_OPTIONS_PRINT, FALSE, (const SfxPoolItem**) &pPrintOpts ) == SFX_ITEM_SET )
 776         {
 777             bScalePage = pPrintOpts->GetOptionsPrint().IsPagesize();
 778             bPrintBooklet = pPrintOpts->GetOptionsPrint().IsBooklet();
 779             bNotesPage = pPrintOpts->GetOptionsPrint().IsNotes();
 780             pPrintOpts->GetOptionsPrint().SetCutPage( FALSE );
 781         }
 782         else
 783             pPrintOpts = NULL;
 784
 785         SdPage* pPage = mrBase.GetDocument()->GetSdPage( 0, PK_STANDARD );
 786         Size    aPageSize( pPage->GetSize() );
 787         Size    aPrintSize( pPrinter->GetOutputSize() );
 788         long    nPageWidth = aPageSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder();
 789         long    nPageHeight = aPageSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder();
 790         long    nNotesPageWidth, nNotesPageHeight;
 791         long    nPrintWidth = aPrintSize.Width();
 792         long    nPrintHeight = aPrintSize.Height();
 793         USHORT  nRet = RET_OK;
 794
 795         if( bNotesPage ) {
 796             SdPage* pNotesPage = mrBase.GetDocument()->GetSdPage( 0, PK_NOTES );
 797             Size aNotesPageSize = Size( pNotesPage->GetSize () );
 798             nNotesPageWidth = aNotesPageSize.Width() - pNotesPage->GetLftBorder() - pNotesPage->GetRgtBorder();
 799             nNotesPageHeight = aNotesPageSize.Height() - pNotesPage->GetUppBorder() - pNotesPage->GetLwrBorder();
 800         }
 801
 802         // When necessary then show a dialog that asks the user how to fit
 803         // the pages to be printed to the (smaller) printer pages.
 804         if ( !bScalePage
 805             && !bTilePage
 806             && !bPrintBooklet
 807             && ( ( ( nPageWidth > nPrintWidth || nPageHeight > nPrintHeight )
 808                 && ( nPageWidth > nPrintHeight || nPageHeight > nPrintWidth )
 809                    ) ||
 810                  ( bNotesPage
 811                    && ( nNotesPageWidth > nPrintWidth || nNotesPageHeight > nPrintHeight )
 812                    && ( nNotesPageWidth > nPrintHeight || nNotesPageHeight > nPrintWidth ) )
 813                  )
 814             )
 815         {
 816             if (IsScreenFormat())
 817             {
 818                 // For the screen format the page content is always scaled
 819                 // to the printable area of the printer pages.
 820                 pPrintOpts->GetOptionsPrint().SetPagesize();
 821             }
 822             else
 823             {
 824
 825                 SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
 826                 AbstractSdPrintDlg* pDlg = pFact ? pFact->CreateSdPrintDlg(mrBase.GetWindow() ) : 0;
 827                 // Do not show the dialog when the bSilent flag is set.  We
 828                 // do create the dialog anyway so that we can extract the
 829                 // default method of mapping internal pages to printer pages
 830                 // from it.
 831                 if( ! bSilent && pDlg )
 832                     nRet = pDlg->Execute();
 833                 if( nRet == RET_OK )
 834                 {
 835                     switch (pDlg->GetAttr())
 836                     {
 837                         case 1:
 838                             pPrintOpts->GetOptionsPrint().SetPagesize();
 839                             break;
 840
 841                         case 2:
 842                             // Tiling is the default behaviour in
 843                             // ViewShell::PrintStdOrNotes().  The poperty of
 844                             // pPrintOpts is ignored there so setting it
 845                             // here may only lead to unwanted side effects.
 846                             break;
 847
 848                         case 3:
 849                             pPrintOpts->GetOptionsPrint().SetCutPage();
 850                             break;
 851                     }
 852                     bContinuePrinting = true;
 853                 }
 854                 delete pDlg;
 855             }
 856         }
 857
 858         // The user has pressed the 'Cancel' button.  Restore the old values and
 859         // return a flag to tell the caller to abort printing.
 860         if( nRet == RET_CANCEL )
 861         {
 862             pPrinter->SetPrinterOptions( aOldPrinterOptions );
 863             pPrinter->SetMapMode( aOldMap );
 864             bContinuePrinting = false;
 865         }
 866     }
 867
 868     return bContinuePrinting;
 869 }
 870
 871
 872
 873
 874 void PrintManager::PrintOutline (
 875     PrintInfo& rInfo,
 876     USHORT nPage)
 877 {
 878     // Papierschacht
 879     // Seiteneinstellungen koennen nicht fuer die Gliederung gemacht werden
 880     // (also auch nicht der Druckerschacht), deswegen wird der Druckerschacht
 881     // von der Seite PK_STANDARD genommen.
 882     /*
 883     if( pPrintOpts && !pPrintOpts->GetOptionsPrint().IsPaperbin() ) // Drucken NICHT aus Druckereinstellung
 884     {
 885         USHORT nPaperBin = GetDoc()->GetSdPage(nPage, PK_STANDARD)->GetPaperBin();
 886         rPrinter.SetPaperBin( nPaperBin );
 887     } */
 888     // Es wird jetzt (vorlaeufig ?) der Druckerschacht vom Drucker genommen
 889
 890     const MapMode       aOldMap( rInfo.mrPrinter.GetMapMode() );
 891     MapMode             aMap( aOldMap );
 892     const Orientation   eOldOrient = rInfo.mrPrinter.GetOrientation();
 893     Point               aPageOfs( rInfo.mrPrinter.GetPageOffset() );
 894     Fraction            aScale(1, 2);
 895     BOOL                bPrintExcluded = TRUE;
 896
 897     aMap.SetOrigin(Point() - aPageOfs);
 898     aMap.SetScaleX(aScale);
 899     aMap.SetScaleY(aScale);
 900     rInfo.mrPrinter.SetMapMode(aMap);
 901     rInfo.mrPrinter.SetOrientation(ORIENTATION_PORTRAIT);
 902
 903     if ( rInfo.mpPrintOpts )
 904         bPrintExcluded = rInfo.mpPrintOpts->GetOptionsPrint().IsHiddenPages();
 905
 906     Rectangle aOutRect(aPageOfs, rInfo.mrPrinter.GetOutputSize());
 907
 908     Link aOldLink;
 909     Outliner* pOutliner = rInfo.mrViewShell.GetDoc()->GetInternalOutliner();
 910     pOutliner->Init( OUTLINERMODE_OUTLINEVIEW );
 911     USHORT nOutlMode = pOutliner->GetMode();
 912     BOOL bOldUpdateMode = pOutliner->GetUpdateMode();
 913
 914     Size aPaperSize = pOutliner->GetPaperSize();
 915     pOutliner->SetPaperSize(aOutRect.GetSize());
 916     pOutliner->SetUpdateMode(TRUE);
 917
 918     long nPageH = aOutRect.GetHeight();
 919
 920     USHORT nPageCount = rInfo.mnProgressOffset;
 921
 922     while ( nPage < rInfo.mnPageMax )
 923     {
 924         Paragraph* pPara = NULL;
 925         long nH = 0;
 926
 927         pOutliner->Clear();
 928         pOutliner->SetFirstPageNumber(nPage+1);
 929
 930         while ( nH < nPageH && nPage < rInfo.mnPageMax )
 931         {
 932             if ( rInfo.mrSelPages.IsSelected(nPage+1) )
 933             {
 934                 //rProgress.SetState( nPageCount, nTotal );
 935                 //rProgress.SetStateText( nPageCount, nPage+1, nTotal );
 936
 937                 String aTmp = UniString::CreateFromInt32( nPage+1 );
 938                 aTmp += String( SdResId( STR_PRINT_OUTLINE ) );
 939                 rInfo.mrProgress.SetStateText(nPageCount, aTmp, rInfo.mnTotal );
 940
 941                 nPageCount = nPageCount + rInfo.mnCopies;
 942
 943                 SdPage* pPage = (SdPage*)rInfo.mrViewShell.GetDoc()->GetSdPage(nPage, PK_STANDARD);
 944                 SdrTextObj* pTextObj = NULL;
 945                 ULONG nObj = 0;
 946
 947                 if ( !pPage->IsExcluded() || bPrintExcluded )
 948                 {
 949                     while ( !pTextObj && nObj < pPage->GetObjCount() )
 950                     {
 951                         SdrObject* pObj = pPage->GetObj(nObj++);
 952                         if ( pObj->GetObjInventor() == SdrInventor &&
 953                              pObj->GetObjIdentifier() == OBJ_TITLETEXT )
 954                             pTextObj = (SdrTextObj*) pObj;
 955                     }
 956
 957                     pPara = pOutliner->GetParagraph( pOutliner->GetParagraphCount() - 1 );
 958
 959                     if ( pTextObj && !pTextObj->IsEmptyPresObj() &&
 960                             pTextObj->GetOutlinerParaObject() )
 961                         pOutliner->AddText( *(pTextObj->GetOutlinerParaObject()) );
 962                     else
 963                         pOutliner->Insert(String());
 964
 965                     pTextObj = NULL;
 966                     nObj = 0;
 967
 968                     while ( !pTextObj && nObj < pPage->GetObjCount() )
 969                     {
 970                         SdrObject* pObj = pPage->GetObj(nObj++);
 971                         if ( pObj->GetObjInventor() == SdrInventor &&
 972                              pObj->GetObjIdentifier() == OBJ_OUTLINETEXT )
 973                             pTextObj = (SdrTextObj*) pObj;
 974                     }
 975
 976                     BOOL bSubTitle = FALSE;
 977                     if (!pTextObj)
 978                     {
 979                         bSubTitle = TRUE;
 980                         pTextObj = (SdrTextObj*) pPage->GetPresObj(PRESOBJ_TEXT);  // Untertitel vorhanden?
 981                     }
 982
 983                     ULONG nParaCount1 = pOutliner->GetParagraphCount();
 984
 985                     if ( pTextObj && !pTextObj->IsEmptyPresObj() &&
 986                             pTextObj->GetOutlinerParaObject() )
 987                         pOutliner->AddText( *(pTextObj->GetOutlinerParaObject()) );
 988
 989                     if ( bSubTitle )
 990                     {
 991                         ULONG nParaCount2 = pOutliner->GetParagraphCount();
 992                         for (ULONG nPara = nParaCount1; nPara < nParaCount2; nPara++)
 993                         {
 994                             Paragraph* pP = pOutliner->GetParagraph(nPara);
 995                             if(pP && pOutliner->GetDepth( (USHORT) nPara ) > 0 )
 996                                 pOutliner->SetDepth(pP, 0);
 997                         }
 998                     }
 999
1000                     nH = pOutliner->GetTextHeight();
1001                 }
1002             }
1003             nPage++;
1004         }
1005
1006         if ( nH > nPageH && pPara )
1007         {
1008             ULONG nCnt = pOutliner->GetAbsPos( pOutliner->GetParagraph( pOutliner->GetParagraphCount() - 1 ) );
1009             ULONG nParaPos = pOutliner->GetAbsPos( pPara );
1010             nCnt -= nParaPos;
1011             pPara = pOutliner->GetParagraph( ++nParaPos );
1012             if ( nCnt && pPara )
1013             {
1014                 pOutliner->Remove(pPara, nCnt);
1015                 nPage--;
1016             }
1017         }
1018
1019         rInfo.mrPrinter.StartPage();
1020         pOutliner->Draw(&rInfo.mrPrinter, aOutRect);
1021
1022         if ( rInfo.mrTimeDateStr.Len() )
1023         {
1024             Font aOldFont = rInfo.mrPrinter.OutputDevice::GetFont();
1025             rInfo.mrPrinter.SetFont(rInfo.mrTimeDateFont);
1026             rInfo.mrPrinter.DrawText(aPageOfs, rInfo.mrTimeDateStr);
1027             rInfo.mrPrinter.SetFont(aOldFont);
1028         }
1029         rInfo.mrPrinter.EndPage();
1030     }
1031     pOutliner->SetUpdateMode(bOldUpdateMode);
1032     pOutliner->SetPaperSize(aPaperSize);
1033     pOutliner->Init( nOutlMode );
1034
1035     rInfo.mrPrinter.SetOrientation(eOldOrient);
1036     rInfo.mrPrinter.SetMapMode( aOldMap );
1037 }
1038
1039
1040
1041
1042 void PrintManager::PrintHandout( PrintInfo& rInfo, USHORT nPage )
1043 {
1044     SdPage* pPage = rInfo.mrViewShell.GetDoc()->GetSdPage(0, PK_HANDOUT);
1045     SdPage& rMaster = (SdPage&)pPage->TRG_GetMasterPage();
1046     SdDrawDocument* pDocument = rInfo.mrViewShell.GetDoc();
1047
1048     BOOL                bScalePage = TRUE;
1049     if ( rInfo.mpPrintOpts )
1050     {
1051         bScalePage = rInfo.mpPrintOpts->GetOptionsPrint().IsPagesize();
1052     }
1053
1054     // Papierschacht
1055     if( rInfo.mpPrintOpts && !rInfo.mpPrintOpts->GetOptionsPrint().IsPaperbin() ) // Drucken NICHT aus Druckereinstellung
1056     {
1057         USHORT nPaperBin = pPage->GetPaperBin();
1058         rInfo.mrPrinter.SetPaperBin( nPaperBin );
1059     }
1060
1061     // Hoch/Querformat aendern?
1062     Orientation eOrientation = rMaster.GetOrientation();
1063
1064     short nDlgResult = RET_OK;
1065
1066     if ( !rInfo.mrPrinter.SetOrientation(eOrientation) &&
1067         (!rInfo.mpPrintOpts || rInfo.mpPrintOpts->GetOptionsPrint().IsWarningOrientation()) )
1068     {
1069         // eine Warnung anzeigen
1070         WarningBox aWarnBox(rInfo.mrViewShell.GetActiveWindow(),(WinBits)(WB_OK_CANCEL | WB_DEF_CANCEL),
1071                             String(SdResId(STR_WARN_PRINTFORMAT_FAILURE)));
1072         nDlgResult = aWarnBox.Execute();
1073     }
1074
1075     if ( nDlgResult == RET_OK )
1076     {
1077         const MapMode   aOldMap( rInfo.mrPrinter.GetMapMode() );
1078         MapMode         aMap( aOldMap );
1079         Point           aPageOfs( rInfo.mrPrinter.GetPageOffset() );
1080         DrawView* pPrintView;
1081         BOOL            bPrintExcluded = TRUE;
1082
1083         aMap.SetOrigin(Point() - aPageOfs);
1084
1085         if ( bScalePage )
1086         {
1087             Size aPageSize(pPage->GetSize());
1088             Size aPrintSize( rInfo.mrPrinter.GetOutputSize() );
1089
1090             double fHorz = (double) aPrintSize.Width()  / aPageSize.Width();
1091             double fVert = (double) aPrintSize.Height() / aPageSize.Height();
1092
1093             Fraction    aFract;
1094             if ( fHorz < fVert )
1095                 aFract = Fraction(aPrintSize.Width(), aPageSize.Width());
1096             else
1097                 aFract = Fraction(aPrintSize.Height(), aPageSize.Height());
1098
1099             aMap.SetScaleX(aFract);
1100             aMap.SetScaleY(aFract);
1101             aMap.SetOrigin(Point());
1102         }
1103
1104         rInfo.mrPrinter.SetMapMode(aMap);
1105
1106         if (rInfo.mrViewShell.ISA(DrawViewShell))
1107             pPrintView = new DrawView (rInfo.mrViewShell.GetDocSh(), &rInfo.mrPrinter,
1108                 static_cast<DrawViewShell*>(&rInfo.mrViewShell));
1109         else
1110             pPrintView = new DrawView (rInfo.mrViewShell.GetDocSh(), &rInfo.mrPrinter, NULL);
1111
1112         USHORT  nPageCount = rInfo.mnProgressOffset;
1113
1114         rInfo.mrViewShell.WriteFrameViewData();
1115
1116         rInfo.mrViewShell.SetPrintedHandoutPageNum(0);
1117
1118         if ( rInfo.mpPrintOpts )
1119             bPrintExcluded = rInfo.mpPrintOpts->GetOptionsPrint().IsHiddenPages();
1120
1121         std::vector< SdPage* > aPagesVector;
1122         while ( nPage < rInfo.mnPageMax )
1123         {
1124             nPage++;
1125             if( rInfo.mrSelPages.IsSelected(nPage) )
1126             {
1127                 SdPage* pTemp = pDocument->GetSdPage(nPage-1, PK_STANDARD);
1128                 if( !pTemp->IsExcluded() || bPrintExcluded )
1129                     aPagesVector.push_back( pTemp );
1130             }
1131         }
1132
1133         std::vector< SdrPageObj* > aPageObjVector;
1134         SdrObjListIter aShapeIter( *pPage );
1135         while( aShapeIter.IsMore() )
1136         {
1137             SdrPageObj* pPageObj = dynamic_cast< SdrPageObj* >(aShapeIter.Next());
1138             if( pPageObj )
1139                 aPageObjVector.push_back( pPageObj );
1140         }
1141
1142         if( aPageObjVector.empty() )
1143             return;
1144
1145         rInfo.mrViewShell.SetPrintedHandoutPageCount( (USHORT)((aPagesVector.size() + aPageObjVector.size() - 1)  / aPageObjVector.size()) );
1146
1147 /*
1148         sal_Int32 nHandoutPageCount = aPagesVector.size() / aPageObjVector.size();
1149         sal_Int32 nHandoutPage = 0;
1150 */
1151         std::vector< SdPage* >::iterator aPageIter( aPagesVector.begin() );
1152         while( aPageIter != aPagesVector.end() )
1153         {
1154             std::vector< SdrPageObj* >::iterator aPageObjIter( aPageObjVector.begin() );
1155
1156             while( (aPageObjIter != aPageObjVector.end()) && (aPageIter != aPagesVector.end()) )
1157             {
1158                 SdrPageObj* pPageObj = (*aPageObjIter++);
1159                 pPageObj->SetReferencedPage( (*aPageIter++) );
1160             }
1161
1162             // if there are more page objects than pages left, set the rest to invisible
1163             int nHangoverCount = 0;
1164             while(aPageObjIter != aPageObjVector.end())
1165             {
1166                 (*aPageObjIter++)->SetReferencedPage(0L);
1167                 nHangoverCount++;
1168             }
1169
1170             if( nHangoverCount )
1171             {
1172                 int nSkip = aPageObjVector.size() - nHangoverCount;
1173                 aShapeIter.Reset();
1174                 while( aShapeIter.IsMore() )
1175                 {
1176                     SdrPathObj* pPathObj = dynamic_cast< SdrPathObj* >( aShapeIter.Next() );
1177                     if( pPathObj )
1178                     {
1179                         if( nSkip )
1180                         {
1181                             nSkip--;
1182                         }
1183                         else
1184                         {
1185                             pPathObj->SetMergedItem( XLineStyleItem(XLINE_NONE) );
1186                         }
1187                     }
1188                 }
1189             }
1190
1191             // todo progress
1192             String aTmp = UniString::CreateFromInt32( nPage );
1193             aTmp += String( SdResId( STR_PRINT_HANDOUT ) );
1194             rInfo.mrProgress.SetStateText( nPageCount, aTmp, rInfo.mnTotal );
1195
1196             rInfo.mrViewShell.SetPrintedHandoutPageNum(rInfo.mrViewShell.GetPrintedHandoutPageNum() + 1);
1197
1198             rInfo.mrPrinter.StartPage();
1199             pPrintView->ShowSdrPage(pPage); // , Point());
1200
1201             SdrPageView* pPageView = pPrintView->GetSdrPageView(); // pPage);
1202             pPageView->SetVisibleLayers(rInfo.mrViewShell.GetFrameView()->GetVisibleLayers() );
1203             pPageView->SetPrintableLayers(rInfo.mrViewShell.GetFrameView()->GetPrintableLayers() );
1204
1205             pPrintView->CompleteRedraw(&rInfo.mrPrinter, Rectangle(Point(0,0), pPage->GetSize()));
1206
1207             if ( rInfo.mrTimeDateStr.Len() )
1208             {
1209                 Font aOldFont = rInfo.mrPrinter.OutputDevice::GetFont();
1210                 rInfo.mrPrinter.SetFont(rInfo.mrTimeDateFont);
1211                 rInfo.mrPrinter.DrawText(aPageOfs, rInfo.mrTimeDateStr);
1212                 rInfo.mrPrinter.SetFont(aOldFont);
1213             }
1214             rInfo.mrPrinter.EndPage();
1215             pPrintView->HideSdrPage(); // pPrintView->GetPageView(pPage));
1216
1217             if( nHangoverCount )
1218             {
1219                 aShapeIter.Reset();
1220                 while( aShapeIter.IsMore() )
1221                 {
1222                     SdrPathObj* pPathObj = dynamic_cast< SdrPathObj* >( aShapeIter.Next() );
1223                     if( pPathObj )
1224                         pPathObj->SetMergedItem( XLineStyleItem(XLINE_SOLID) );
1225                 }
1226             }
1227
1228         }
1229
1230         rInfo.mrViewShell.SetPrintedHandoutPageNum(1);
1231         rInfo.mrViewShell.SetPrintedHandoutPageCount(0);
1232         delete pPrintView;
1233         rInfo.mrPrinter.SetMapMode(aOldMap);
1234     }
1235 }
1236
1237
1238
1239
1240 void PrintManager::PrintStdOrNotes (
1241     PrintInfo& rInfo,
1242     USHORT nPage,
1243     PageKind ePageKind,
1244     BOOL bPrintMarkedOnly)
1245 {
1246     Fraction    aFract;
1247     BOOL                bScalePage = TRUE;
1248     BOOL                bTilePage = FALSE;
1249     BOOL                bPrintExcluded = TRUE;
1250     BOOL                bPrintPageName = TRUE;
1251     BOOL                bPrintBooklet  = FALSE;
1252     BOOL                bPrintFrontPage = FALSE;
1253     BOOL                bPrintBackPage = FALSE;
1254     SdDrawDocument* pDocument = rInfo.mrViewShell.GetDoc();
1255
1256     SdPage* pRefPage = pDocument->GetSdPage(nPage, ePageKind);
1257
1258     if ( rInfo.mpPrintOpts )
1259     {
1260         bScalePage = rInfo.mpPrintOpts->GetOptionsPrint().IsPagesize();
1261         bTilePage = rInfo.mpPrintOpts->GetOptionsPrint().IsPagetile();
1262         bPrintPageName = rInfo.mpPrintOpts->GetOptionsPrint().IsPagename();
1263         bPrintExcluded = rInfo.mpPrintOpts->GetOptionsPrint().IsHiddenPages();
1264         bPrintBooklet = rInfo.mpPrintOpts->GetOptionsPrint().IsBooklet();
1265         bPrintFrontPage = rInfo.mpPrintOpts->GetOptionsPrint().IsFrontPage();
1266         bPrintBackPage = rInfo.mpPrintOpts->GetOptionsPrint().IsBackPage();
1267
1268         // Papierschacht
1269         if( !rInfo.mpPrintOpts->GetOptionsPrint().IsPaperbin() ) // Drucken NICHT aus Druckereinstellung
1270         {
1271             USHORT nPaperBin = pDocument->GetSdPage(nPage, ePageKind)->GetPaperBin();
1272             rInfo.mrPrinter.SetPaperBin( nPaperBin );
1273         }
1274
1275     }
1276
1277     // Hoch/Querformat aendern?
1278     Size aPageSize(pRefPage->GetSize());
1279     Orientation eOrientation = ORIENTATION_PORTRAIT;
1280
1281     short nDlgResult = RET_OK;
1282
1283     if( !bPrintBooklet )
1284     {
1285         eOrientation = pRefPage->GetOrientation();
1286     }
1287     else if( aPageSize.Width() < aPageSize.Height() )
1288         eOrientation = ORIENTATION_LANDSCAPE;
1289
1290     if ( !rInfo.mrPrinter.SetOrientation(eOrientation) &&
1291         (!rInfo.mpPrintOpts || rInfo.mpPrintOpts->GetOptionsPrint().IsWarningOrientation()) )
1292     {
1293         // eine Warnung anzeigen
1294         WarningBox aWarnBox(
1295             rInfo.mrViewShell.GetActiveWindow(),
1296             (WinBits)(WB_OK_CANCEL | WB_DEF_CANCEL),
1297             String(SdResId(STR_WARN_PRINTFORMAT_FAILURE)));
1298         nDlgResult = aWarnBox.Execute();
1299     }
1300
1301     if ( nDlgResult == RET_OK )
1302     {
1303         const MapMode   aOldMap( rInfo.mrPrinter.GetMapMode() );
1304         MapMode         aMap( aOldMap );
1305         Point           aPageOfs( rInfo.mrPrinter.GetPageOffset() );
1306         DrawView* pPrintView;
1307
1308         aMap.SetOrigin(Point() - aPageOfs);
1309         rInfo.mrPrinter.SetMapMode(aMap);
1310         Size aPrintSize( rInfo.mrPrinter.GetOutputSize() );
1311
1312         if (rInfo.mrViewShell.ISA(DrawViewShell))
1313             pPrintView = new DrawView (rInfo.mrViewShell.GetDocSh(), &rInfo.mrPrinter,
1314                 static_cast<DrawViewShell*>(&rInfo.mrViewShell));
1315         else
1316             pPrintView = new DrawView (rInfo.mrViewShell.GetDocSh(), &rInfo.mrPrinter, NULL);
1317
1318         USHORT nPageCount = rInfo.mnProgressOffset;
1319
1320         // Als Broschuere drucken ?
1321         if( bPrintBooklet )
1322         {
1323             MapMode                                                                                     aStdMap( rInfo.mrPrinter.GetMapMode() );
1324             ::std::vector< USHORT >                                                     aPageVector;
1325             ::std::vector< ::std::pair< USHORT, USHORT > >      aPairVector;
1326             Point                                           aOffset;
1327             Size                                            aPrintSize_2( aPrintSize );
1328             Size                                            aPageSize_2( aPageSize );
1329
1330             if( eOrientation == ORIENTATION_LANDSCAPE )
1331                 aPrintSize_2.Width() >>= 1;
1332             else
1333                 aPrintSize_2.Height() >>= 1;
1334
1335             const double fPageWH = (double) aPageSize_2.Width() / aPageSize_2.Height();
1336             const double fPrintWH = (double) aPrintSize_2.Width() / aPrintSize_2.Height();
1337
1338             if( fPageWH < fPrintWH )
1339             {
1340                 aPageSize_2.Width() = (long) ( aPrintSize_2.Height() * fPageWH );
1341                 aPageSize_2.Height()= aPrintSize_2.Height();
1342             }
1343             else
1344             {
1345                 aPageSize_2.Width() = aPrintSize_2.Width();
1346                 aPageSize_2.Height() = (long) ( aPrintSize_2.Width() / fPageWH );
1347             }
1348
1349             aMap.SetScaleX( Fraction( aPageSize_2.Width(), aPageSize.Width() ) );
1350             aMap.SetScaleY( Fraction( aPageSize_2.Height(), aPageSize.Height() ) );
1351
1352             // calculate adjusted print size
1353             aPrintSize = OutputDevice::LogicToLogic( aPrintSize, aStdMap, aMap );
1354
1355             if( eOrientation == ORIENTATION_LANDSCAPE )
1356             {
1357                 aOffset.X() = ( ( aPrintSize.Width() >> 1 ) - aPageSize.Width() ) >> 1;
1358                 aOffset.Y() = ( aPrintSize.Height() - aPageSize.Height() ) >> 1;
1359             }
1360             else
1361             {
1362                 aOffset.X() = ( aPrintSize.Width() - aPageSize.Width() ) >> 1;
1363                 aOffset.Y() = ( ( aPrintSize.Height() >> 1 ) - aPageSize.Height() ) >> 1;
1364             }
1365
1366             // create vector of pages to print
1367             while( nPage < rInfo.mnPageMax )
1368             {
1369                 if( rInfo.mrSelPages.IsSelected( nPage + 1 )  )
1370                 {
1371                     SdPage* pP = pDocument->GetSdPage( nPage, ePageKind );
1372
1373                     if( pP && ( !pP->IsExcluded() || bPrintExcluded ) )
1374                         aPageVector.push_back( nPage );
1375                 }
1376
1377                 nPage++;
1378             }
1379
1380             // create pairs of pages to print on each page
1381             if( aPageVector.size() )
1382             {
1383                 sal_uInt32 nFirstIndex = 0, nLastIndex = aPageVector.size() - 1;
1384
1385                 if( aPageVector.size() & 1 )
1386                     aPairVector.push_back( ::std::make_pair( (USHORT) 65535, aPageVector[ nFirstIndex++ ] ) );
1387                 else
1388                     aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) );
1389
1390                 while( nFirstIndex < nLastIndex )
1391                 {
1392                     if( nFirstIndex & 1 )
1393                         aPairVector.push_back( ::std::make_pair( aPageVector[ nFirstIndex++ ], aPageVector[ nLastIndex-- ] ) );
1394                     else
1395                         aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) );
1396                 }
1397             }
1398
1399             for( sal_uInt32 i = 0; i < aPairVector.size(); i++ )
1400             {
1401                 if( ( !( i & 1 ) && bPrintFrontPage ) || ( ( i & 1 ) && bPrintBackPage ) )
1402                 {
1403                     const ::std::pair< USHORT, USHORT > aPair( aPairVector[ i ] );
1404
1405                     rInfo.mrPrinter.StartPage();
1406
1407                     SdPage* pPageToPrint = pDocument->GetSdPage( aPair.first, ePageKind );
1408
1409                     if( pPageToPrint )
1410                     {
1411                         aMap.SetOrigin( aOffset );
1412                         rInfo.mrPrinter.SetMapMode( aMap );
1413                         PrintPage(rInfo, pPrintView, pPageToPrint, bPrintMarkedOnly );
1414                     }
1415
1416                     pPageToPrint = pDocument->GetSdPage( aPair.second, ePageKind );
1417
1418                     if( pPageToPrint )
1419                     {
1420                         Point aSecondOffset( aOffset );
1421
1422                         if( eOrientation == ORIENTATION_LANDSCAPE )
1423                             aSecondOffset.X() += ( aPrintSize.Width() >> 1 );
1424                         else
1425                             aSecondOffset.Y() += ( aPrintSize.Height() >> 1 );
1426
1427                         aMap.SetOrigin( aSecondOffset );
1428                         rInfo.mrPrinter.SetMapMode( aMap );
1429                         PrintPage(rInfo, pPrintView, pPageToPrint, bPrintMarkedOnly );
1430                     }
1431
1432                     rInfo.mrPrinter.EndPage();
1433                 }
1434             }
1435
1436             rInfo.mrPrinter.SetMapMode( aStdMap );
1437         }
1438         else
1439         {
1440             rInfo.mrViewShell.WriteFrameViewData();
1441             Point aPtZero;
1442
1443             while ( nPage < rInfo.mnPageMax )
1444             {
1445                 if (rInfo.mrSelPages.IsSelected(nPage+1) )
1446                 {
1447                     SdPage* pPage = pDocument->GetSdPage(nPage, ePageKind);
1448                     // Kann sich die Seitengroesse geaendert haben?
1449                     aPageSize = pPage->GetSize();
1450
1451                     rInfo.mrProgress.SetState( nPageCount, rInfo.mnTotal );
1452                     nPageCount = nPageCount + rInfo.mnCopies;
1453
1454                     if ( bScalePage )
1455                     {
1456                         double fHorz = (double) aPrintSize.Width()      / aPageSize.Width();
1457                         double fVert = (double) aPrintSize.Height() / aPageSize.Height();
1458
1459                         if ( fHorz < fVert )
1460                             aFract = Fraction(aPrintSize.Width(), aPageSize.Width());
1461                         else
1462                             aFract = Fraction(aPrintSize.Height(), aPageSize.Height());
1463
1464                         aMap.SetScaleX(aFract);
1465                         aMap.SetScaleY(aFract);
1466                         aMap.SetOrigin(Point());
1467                     }
1468
1469                     if ( !pPage->IsExcluded() || bPrintExcluded )
1470                     {
1471                         String aTmp = UniString::CreateFromInt32( nPage+1 );
1472
1473                         if(ePageKind == PK_NOTES)
1474                             aTmp += String( SdResId( STR_PRINT_NOTES ) );
1475                         else
1476                             aTmp += String( SdResId( STR_PRINT_DRAWING ) );
1477                         rInfo.mrProgress.SetStateText( nPageCount, aTmp, rInfo.mnTotal );
1478
1479                         String aPageStr;
1480                         if ( bPrintPageName )
1481                         {
1482                             aPageStr = pPage->GetName();
1483                             aPageStr += (sal_Unicode)' ';
1484                         }
1485                         aPageStr += rInfo.mrTimeDateStr;
1486
1487                         MapMode aStdMap = rInfo.mrPrinter.GetMapMode();
1488                         rInfo.mrPrinter.SetMapMode(aMap);
1489
1490                         //
1491                         BOOL    bPrint = TRUE;
1492                         Point   aPageOrigin;
1493                         long    aPageWidth   = aPageSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder();
1494                         long    aPageHeight  = aPageSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder();
1495                         long    aPrintWidth  = aPrintSize.Width();
1496                         long    aPrintHeight = aPrintSize.Height();
1497
1498                         // Bugfix zu 44530:
1499                         // Falls implizit umgestellt wurde (Landscape/Portrait)
1500                         // wird dies beim Kacheln, bzw. aufteilen (Poster) beruecksichtigt
1501                         BOOL bSwitchPageSize = FALSE;
1502                         if( ( aPrintWidth > aPrintHeight && aPageWidth < aPageHeight ) ||
1503                             ( aPrintWidth < aPrintHeight && aPageWidth > aPageHeight ) )
1504                         {
1505                             bSwitchPageSize = TRUE;
1506                             aPrintWidth  = aPrintSize.Height();
1507                             aPrintHeight = aPrintSize.Width();
1508                         }
1509
1510                         // Eine (kleine) Seite, die gekachelt ausgegeben werden soll
1511                         if( bTilePage &&
1512                             aPageWidth < aPrintWidth &&
1513                             aPageHeight < aPrintHeight )
1514                         {
1515                             aPageWidth  += 500;
1516                             aPageHeight += 500;
1517                             Point aPrintOrigin;
1518
1519                             rInfo.mrPrinter.StartPage();
1520                             pPrintView->ShowSdrPage( pPage );
1521
1522                             SdrPageView* pPageView = pPrintView->GetSdrPageView(); // pPage);
1523                             pPageView->SetVisibleLayers(rInfo.mrViewShell.GetFrameView()->GetVisibleLayers() );
1524                             pPageView->SetPrintableLayers(rInfo.mrViewShell.GetFrameView()->GetPrintableLayers() );
1525
1526                             long nPagesPrinted = 0; // Fuer Bedingung s.u.
1527                             BOOL bPrintPage;            // Fuer Bedingung s.u.
1528
1529                             while( bPrint )
1530                             {
1531                                 BOOL bWidth = aPageWidth < aPrintWidth;
1532                                 BOOL bHeight = aPageHeight < aPrintHeight;
1533                                 if( !bWidth && !bHeight )
1534                                     bPrint = FALSE;
1535
1536                                 // Etwas umstaendliche Abfrage, die ausdrueckt, ob eine Seite
1537                                 // beim Kacheln abgeschnitten oder gar nicht dargestellt werden
1538                                 // soll. Die Bedingung ist, dass eine 2. Seite (horz. oder vert.)
1539                                 // immer gedruck wird, waehrend eine dritte Seite (oder hoeher)
1540                                 // nur noch gedruckt wird, wenn diese auch noch vollstaendig
1541                                 // aufs Papier passt.
1542                                 if( nPagesPrinted < 4 && !( !bWidth && nPagesPrinted == 2 ) )
1543                                     bPrintPage = TRUE;
1544                                 else
1545                                     bPrintPage = FALSE;
1546                                 nPagesPrinted++;
1547
1548                                 if( ( bWidth && bHeight ) || bPrintPage )
1549                                 {
1550                                     aStdMap.SetOrigin( aPrintOrigin );
1551                                     rInfo.mrPrinter.SetMapMode( aStdMap );
1552
1553                                     if (rInfo.mrViewShell.ISA(DrawViewShell) && bPrintMarkedOnly )
1554                                     {
1555                                         rInfo.mrViewShell.GetView()->DrawMarkedObj(rInfo.mrPrinter);
1556                                     }
1557                                     else
1558                                         pPrintView->CompleteRedraw( &rInfo.mrPrinter, Rectangle( aPtZero, aPageSize ) );
1559                                 }
1560                                 if( bWidth )
1561                                 {
1562                                     aPrintOrigin.X() += aPageWidth;
1563                                     aPrintWidth          -= aPageWidth;
1564                                 }
1565                                 else if( bHeight )
1566                                 {
1567                                     aPrintOrigin.X()  = 0;
1568                                     aPrintWidth           = bSwitchPageSize ? aPrintSize.Height() : aPrintSize.Width();
1569                                     aPrintOrigin.Y() += aPageHeight;
1570                                     aPrintHeight         -= aPageHeight;
1571                                 }
1572                             }
1573
1574                             if ( aPageStr.Len() )
1575                             {
1576                                 Font aOldFont = rInfo.mrPrinter.OutputDevice::GetFont();
1577                                 rInfo.mrPrinter.SetFont(rInfo.mrTimeDateFont);
1578                                 rInfo.mrPrinter.DrawText(aPageOfs, aPageStr);
1579                                 rInfo.mrPrinter.SetFont(aOldFont);
1580                             }
1581                             rInfo.mrPrinter.EndPage();
1582                             pPrintView->HideSdrPage(); // pPrintView->GetPageView(pPage));
1583
1584                             bPrint = FALSE;
1585                         }
1586
1587                         // For pages larger then the printable area there
1588                         // are three options:
1589                         // 1. Scale down to the page to the printable area.
1590                         // 2. Print only the upper left part of the page
1591                         //    (without the unprintable borders).
1592                         // 3. Split the page into parts of the size of the
1593                         // printable area.
1594                         if (bPrint)
1595                         {
1596                             const bool bCutPage (rInfo.mpPrintOpts && rInfo.mpPrintOpts->GetOptionsPrint().IsCutPage());
1597                             if (bScalePage || bCutPage)
1598                             {
1599                                 // Handle 1 and 2.
1600
1601                                 // if CutPage is set then do not move
1602                                 // it, otherwise move the scaled page
1603                                 // to printable area
1604
1605                                 PrintPagePart(
1606                                     rInfo,
1607                                     pPage,
1608                                     *pPrintView,
1609                                     bCutPage ? Point(-aPageOfs.X(), -aPageOfs.Y()) : Point(0,0),
1610                                     bPrintMarkedOnly,
1611                                     aPageStr,
1612                                     aPageOfs);
1613                             }
1614                             else
1615                             {
1616                                 Point aOrigin;
1617
1618                                 // if the printable area is bigger than page size, center the page
1619                                 if( aPageSize.Width() < aPrintWidth )
1620                                     aOrigin.X() = ( aPrintWidth - aPageSize.Width() )/2;
1621                                 if( aPageSize.Height() < aPrintHeight )
1622                                     aOrigin.Y() = ( aPrintHeight - aPageSize.Height() )/2;
1623
1624                                 // Handle 3.  Print parts of the page in the
1625                                 // size of the printable area until the
1626                                 // whole page is covered.
1627
1628                                 for (aPageOrigin = aOrigin;
1629                                      -aPageOrigin.Y()<aPageHeight;
1630                                          aPageOrigin.Y() -= aPrintHeight)
1631                                 {
1632                                     for (aPageOrigin.X()=aOrigin.X();
1633                                          -aPageOrigin.X()<aPageWidth;
1634                                              aPageOrigin.X() -= aPrintWidth)
1635                                     {
1636                                         PrintPagePart(
1637                                             rInfo,
1638                                             pPage,
1639                                             *pPrintView,
1640                                             aPageOrigin,
1641                                             bPrintMarkedOnly,
1642                                             aPageStr,
1643                                             aPageOfs);
1644                                     }
1645                                 }
1646                             }
1647                         }
1648                     }
1649                 }
1650                 nPage++;
1651             }
1652         }
1653
1654         delete pPrintView;
1655         rInfo.mrPrinter.SetMapMode( aOldMap );
1656     }
1657 }
1658
1659
1660
1661
1662 void PrintManager::PrintPagePart (
1663     PrintInfo& rInfo,
1664     SdPage* pPage,
1665     DrawView& rPrintView,
1666     const Point& rPageOrigin,
1667     BOOL bPrintMarkedOnly,
1668     const String& rsPageString,
1669     const Point& rStringOffset)
1670 {
1671     rInfo.mrPrinter.StartPage();
1672     rPrintView.ShowSdrPage(pPage); // , Point(0,0));
1673
1674     // Set origin of the map mode so that the next part of the page is
1675     // printed.
1676     MapMode aOriginalMapMode = rInfo.mrPrinter.GetMapMode();
1677     MapMode aMapMode = rInfo.mrPrinter.GetMapMode();
1678     aMapMode.SetOrigin(rPageOrigin);
1679     rInfo.mrPrinter.SetMapMode(aMapMode);
1680
1681     SdrPageView* pPageView = rPrintView.GetSdrPageView(); // pPage);
1682     pPageView->SetVisibleLayers(rInfo.mrViewShell.GetFrameView()->GetVisibleLayers() );
1683     pPageView->SetPrintableLayers(rInfo.mrViewShell.GetFrameView()->GetPrintableLayers() );
1684
1685     if (rInfo.mrViewShell.ISA(DrawViewShell) && bPrintMarkedOnly)
1686         rInfo.mrViewShell.GetView()->DrawMarkedObj(rInfo.mrPrinter);
1687     else
1688         rPrintView.CompleteRedraw(&rInfo.mrPrinter, Rectangle(Point(0,0), pPage->GetSize()));
1689     rInfo.mrPrinter.SetMapMode(aOriginalMapMode);
1690
1691     if (rsPageString.Len())
1692     {
1693         Font aOldFont = rInfo.mrPrinter.OutputDevice::GetFont();
1694         rInfo.mrPrinter.SetFont(rInfo.mrTimeDateFont);
1695         rInfo.mrPrinter.DrawText(rStringOffset, rsPageString);
1696         rInfo.mrPrinter.SetFont(aOldFont);
1697     }
1698     rInfo.mrPrinter.EndPage();
1699     rPrintView.HideSdrPage(); // rPrintView.GetPageView(pPage));
1700 }
1701
1702
1703
1704
1705
1706 void PrintManager::PrintPage (
1707     PrintInfo& rInfo,
1708     ::sd::View* pPrintView,
1709     SdPage* pPage,
1710     BOOL bPrintMarkedOnly)
1711 {
1712     Point aPtZero;
1713     pPrintView->ShowSdrPage( pPage ); // , aPtZero );
1714
1715     SdrPageView* pPageView = pPrintView->GetSdrPageView(); // pPage );
1716     pPageView->SetVisibleLayers(rInfo.mrViewShell.GetFrameView()->GetVisibleLayers() );
1717     pPageView->SetPrintableLayers(rInfo.mrViewShell.GetFrameView()->GetPrintableLayers() );
1718
1719     if (rInfo.mrViewShell.ISA(DrawViewShell) && bPrintMarkedOnly)
1720         rInfo.mrViewShell.GetView()->DrawMarkedObj(rInfo.mrPrinter);
1721     else
1722         pPrintView->CompleteRedraw(&rInfo.mrPrinter, Rectangle(Point(0,0), pPage->GetSize()));
1723
1724     pPrintView->HideSdrPage(); //  pPrintView->GetPageView( pPage ) );
1725 }
1726
1727
1728
1729
1730 bool PrintManager::IsScreenFormat (void)
1731 {
1732     // Determine the page size.
1733     SdPage* pPage = mrBase.GetDocument()->GetSdPage(0, PK_STANDARD);
1734     Size aPaperSize (pPage->GetSize());
1735
1736     // Take Orientation into account.
1737     if (pPage->GetOrientation() == ORIENTATION_LANDSCAPE)
1738         Swap(aPaperSize);
1739
1740     // Check whether paper size is 'Screen'
1741     Paper ePaper(SvxPaperInfo::GetSvxPaper(aPaperSize, MAP_100TH_MM, TRUE));
1742     return (ePaper == PAPER_SCREEN);
1743 }
1744
1745
1746 void PrintManager::InitHandoutTemplate( PrintInfo& /*rInfo*/, USHORT nSlidesPerHandout, BOOL bHandoutHorizontal )
1747 {
1748     AutoLayout eLayout = AUTOLAYOUT_HANDOUT6;
1749     switch( nSlidesPerHandout )
1750     {
1751     case 1: eLayout = AUTOLAYOUT_HANDOUT1; break;
1752     case 2: eLayout = AUTOLAYOUT_HANDOUT2; break;
1753     case 3: eLayout = AUTOLAYOUT_HANDOUT3; break;
1754     case 4: eLayout = AUTOLAYOUT_HANDOUT4; break;
1755     case 9: eLayout = AUTOLAYOUT_HANDOUT9; break;
1756     }
1757
1758     if( !mrBase.GetDocument() )
1759         return;
1760
1761     SdDrawDocument& rModel = *mrBase.GetDocument();
1762
1763     // first, prepare handout page (not handout master)
1764
1765     SdPage* pHandout = rModel.GetSdPage(0, PK_HANDOUT);
1766     if( !pHandout )
1767         return;
1768
1769     // delete all previous shapes from handout page
1770     while( pHandout->GetObjCount() )
1771     {
1772         SdrObject* pObj = pHandout->NbcRemoveObject(0);
1773         if( pObj )
1774             SdrObject::Free( pObj  );
1775     }
1776
1777     const bool bDrawLines = eLayout == AUTOLAYOUT_HANDOUT3;
1778
1779     std::vector< Rectangle > aAreas;
1780     SdPage::CalculateHandoutAreas( rModel, eLayout, bHandoutHorizontal, aAreas );
1781
1782     std::vector< Rectangle >::iterator iter( aAreas.begin() );
1783     while( iter != aAreas.end() )
1784     {
1785         pHandout->NbcInsertObject( new SdrPageObj((*iter++)) );
1786
1787         if( bDrawLines && (iter != aAreas.end())  )
1788         {
1789             Rectangle aRect( (*iter++) );
1790
1791             basegfx::B2DPolygon aPoly;
1792             aPoly.insert(0, basegfx::B2DPoint( aRect.Left(), aRect.Top() ) );
1793             aPoly.insert(1, basegfx::B2DPoint( aRect.Right(), aRect.Top() ) );
1794
1795             basegfx::B2DHomMatrix aMatrix;
1796             aMatrix.translate( 0.0, static_cast< double >( aRect.GetHeight() / 7 ) );
1797
1798             basegfx::B2DPolyPolygon aPathPoly;
1799             for( sal_uInt16 nLine = 0; nLine < 7; nLine++ )
1800             {
1801                 aPoly.transform( aMatrix );
1802                 aPathPoly.append( aPoly );
1803             }
1804
1805             SdrPathObj* pPathObj = new SdrPathObj(OBJ_PATHLINE, aPathPoly );
1806             pPathObj->SetMergedItem( XLineStyleItem(XLINE_SOLID) );
1807             pPathObj->SetMergedItem( XLineColorItem(String(), Color(COL_BLACK)));
1808
1809             pHandout->NbcInsertObject( pPathObj );
1810         }
1811     }
1812 }
1813
1814 } // end of namespace sd