LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/view - DocumentRenderer.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 868 0.1 %
Date: 2012-12-27 Functions: 2 93 2.2 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      21             : #include <com/sun/star/beans/XPropertySet.hpp>
      22             : 
      23             : #include "DocumentRenderer.hxx"
      24             : #include "DocumentRenderer.hrc"
      25             : 
      26             : #include "drawdoc.hxx"
      27             : #include "optsitem.hxx"
      28             : #include "sdresid.hxx"
      29             : #include "strings.hrc"
      30             : #include "sdattr.hxx"
      31             : #include "Window.hxx"
      32             : #include "drawview.hxx"
      33             : #include "DrawViewShell.hxx"
      34             : #include "FrameView.hxx"
      35             : #include "Outliner.hxx"
      36             : #include "OutlineViewShell.hxx"
      37             : 
      38             : #include <basegfx/polygon/b2dpolygon.hxx>
      39             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      40             : #include <basegfx/matrix/b2dhommatrix.hxx>
      41             : #include <sfx2/printer.hxx>
      42             : #include <editeng/editstat.hxx>
      43             : #include <editeng/outlobj.hxx>
      44             : #include <svx/svdetc.hxx>
      45             : #include <svx/svditer.hxx>
      46             : #include <svx/svdopage.hxx>
      47             : #include <svx/svdopath.hxx>
      48             : #include <svx/xlnclit.hxx>
      49             : #include <toolkit/awt/vclxdevice.hxx>
      50             : #include <tools/resary.hxx>
      51             : #include <unotools/localedatawrapper.hxx>
      52             : #include <vcl/msgbox.hxx>
      53             : #include <unotools/moduleoptions.hxx>
      54             : 
      55             : #include <vector>
      56             : 
      57             : using namespace ::com::sun::star;
      58             : using namespace ::com::sun::star::uno;
      59             : using ::rtl::OUString;
      60             : 
      61             : 
      62             : namespace sd {
      63             : 
      64             : namespace {
      65             : 
      66             : 
      67             :     /** Convenience class to extract values from the sequence of properties
      68             :         given to one of the XRenderable methods.
      69             :     */
      70           0 :     class PrintOptions
      71             :     {
      72             :     public:
      73           0 :         PrintOptions (
      74             :             const vcl::PrinterOptionsHelper& rHelper,
      75             :             const ::std::vector<sal_Int32>& rSlidesPerPage)
      76             :             : mrProperties(rHelper),
      77           0 :               maSlidesPerPage(rSlidesPerPage)
      78             :         {
      79           0 :         }
      80             : 
      81           0 :         bool IsWarningOrientation() const
      82             :         {
      83           0 :             return GetBoolValue(NULL, true);
      84             :         }
      85             : 
      86           0 :         bool IsPrintPageName() const
      87             :         {
      88           0 :             return GetBoolValue("IsPrintName");
      89             :         }
      90             : 
      91           0 :         bool IsDate() const
      92             :         {
      93           0 :             return GetBoolValue("IsPrintDateTime");
      94             :         }
      95             : 
      96           0 :         bool IsTime() const
      97             :         {
      98           0 :             return GetBoolValue("IsPrintDateTime");
      99             :         }
     100             : 
     101           0 :         bool IsHiddenPages() const
     102             :         {
     103           0 :             return GetBoolValue("IsPrintHidden");
     104             :         }
     105             : 
     106           0 :         bool IsHandoutHorizontal() const
     107             :         {
     108           0 :             return GetBoolValue("SlidesPerPageOrder", sal_Int32(0));
     109             :         }
     110             : 
     111           0 :         sal_Int32 GetHandoutPageCount() const
     112             :         {
     113           0 :             sal_uInt32 nIndex = static_cast<sal_Int32>(mrProperties.getIntValue("SlidesPerPage", sal_Int32(0)));
     114           0 :             if (nIndex<maSlidesPerPage.size())
     115           0 :                 return maSlidesPerPage[nIndex];
     116           0 :             else if ( ! maSlidesPerPage.empty())
     117           0 :                 return maSlidesPerPage[0];
     118             :             else
     119           0 :                 return 0;
     120             :         }
     121             : 
     122           0 :         bool IsDraw() const
     123             :         {
     124           0 :             return GetBoolValue("PageContentType", sal_Int32(0));
     125             :         }
     126             : 
     127           0 :         bool IsHandout() const
     128             :         {
     129           0 :             return GetBoolValue("PageContentType", sal_Int32(1));
     130             :         }
     131             : 
     132           0 :         bool IsNotes() const
     133             :         {
     134           0 :             return GetBoolValue("PageContentType", sal_Int32(2));
     135             :         }
     136             : 
     137           0 :         bool IsOutline() const
     138             :         {
     139           0 :             return GetBoolValue("PageContentType", sal_Int32(3));
     140             :         }
     141             : 
     142           0 :         sal_uLong GetOutputQuality() const
     143             :         {
     144           0 :             sal_Int32 nQuality = static_cast<sal_Int32>(mrProperties.getIntValue( "Quality", sal_Int32(0) ));
     145           0 :             return nQuality;
     146             :         }
     147             : 
     148           0 :         bool IsPageSize() const
     149             :         {
     150           0 :             return GetBoolValue("PageOptions", sal_Int32(1));
     151             :         }
     152             : 
     153           0 :         bool IsTilePage() const
     154             :         {
     155           0 :             return GetBoolValue("PageOptions", sal_Int32(2)) || GetBoolValue("PageOptions", sal_Int32(3));
     156             :         }
     157             : 
     158           0 :         bool IsCutPage() const
     159             :         {
     160           0 :             return GetBoolValue("PageOptions", sal_Int32(0));
     161             :         }
     162             : 
     163           0 :         bool IsBooklet() const
     164             :         {
     165           0 :             return GetBoolValue("PrintProspect", false);
     166             :         }
     167             : 
     168           0 :         bool IsPrintExcluded() const
     169             :         {
     170           0 :             return (IsNotes() || IsDraw() || IsHandout()) &&  IsHiddenPages();
     171             :         }
     172             : 
     173           0 :         bool IsPrintFrontPage() const
     174             :         {
     175           0 :             sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintProspectInclude", 0 ));
     176           0 :             return nInclude == 0 || nInclude == 1;
     177             :         }
     178             : 
     179           0 :         bool IsPrintBackPage() const
     180             :         {
     181           0 :             sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintProspectInclude", 0 ));
     182           0 :             return nInclude == 0 || nInclude == 2;
     183             :         }
     184             : 
     185           0 :         bool IsPaperBin() const
     186             :         {
     187           0 :             return GetBoolValue("PrintPaperFromSetup", false);
     188             :         }
     189             : 
     190           0 :         bool IsPrintMarkedOnly() const
     191             :         {
     192           0 :             return GetBoolValue("PrintContent", sal_Int32(2));
     193             :         }
     194             : 
     195           0 :         OUString GetPrinterSelection (sal_Int32 nPageCount, sal_Int32 nCurrentPageIndex) const
     196             :         {
     197           0 :             sal_Int32 nContent = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintContent", 0 ));
     198             :             OUString sFullRange = ::rtl::OUStringBuffer()
     199           0 :                  .append(static_cast<sal_Int32>(1))
     200           0 :                  .append(static_cast<sal_Unicode>('-'))
     201           0 :                  .append(nPageCount).makeStringAndClear();
     202             : 
     203           0 :             if (nContent == 0) // all pages/slides
     204             :             {
     205           0 :                 return sFullRange;
     206             :             }
     207             : 
     208           0 :             if (nContent == 1) // range
     209             :             {
     210           0 :                 OUString sValue = mrProperties.getStringValue("PageRange");
     211           0 :                 return sValue.isEmpty() ? sFullRange : sValue;
     212             :             }
     213             : 
     214           0 :             if (nContent == 2 && // selection
     215             :                 nCurrentPageIndex >= 0)
     216             :             {
     217           0 :                 return OUString::valueOf(nCurrentPageIndex + 1);
     218             :             }
     219             : 
     220           0 :             return OUString();
     221             :         }
     222             : 
     223             :     private:
     224             :         const vcl::PrinterOptionsHelper& mrProperties;
     225             :         const ::std::vector<sal_Int32> maSlidesPerPage;
     226             : 
     227             :         /** When the value of the property with name pName is a boolean then
     228             :             return its value. When the property is unknown then
     229             :             bDefaultValue is returned.  Otherwise <FALSE/> is returned.
     230             :         */
     231           0 :         bool GetBoolValue (
     232             :             const sal_Char* pName,
     233             :             const bool bDefaultValue = false) const
     234             :         {
     235           0 :             sal_Bool bValue = mrProperties.getBoolValue( pName, bDefaultValue );
     236           0 :             return bValue;
     237             :         }
     238             : 
     239             :         /** Return <TRUE/> when the value of the property with name pName is
     240             :             a string and its value equals pValue. When the property is
     241             :             unknown then bDefaultValue is returned.  Otherwise <FALSE/> is
     242             :             returned.
     243             :         */
     244             :         bool GetBoolValue (
     245             :             const sal_Char* pName,
     246             :             const sal_Char* pValue,
     247             :             const bool bDefaultValue = false) const
     248             :         {
     249             :             OUString sValue( mrProperties.getStringValue( pName ) );
     250             :             if (!sValue.isEmpty())
     251             :                 return sValue.equalsAscii(pValue);
     252             :             else
     253             :                 return bDefaultValue;
     254             :         }
     255             : 
     256             :         /** Return <TRUE/> when the value of the property with name pName is
     257             :             an integer and its value is nTriggerValue. Otherwise <FALSE/> is
     258             :             returned.
     259             :         */
     260           0 :         bool GetBoolValue (
     261             :             const sal_Char* pName,
     262             :             const sal_Int32 nTriggerValue) const
     263             :         {
     264           0 :             sal_Int32 nValue = static_cast<sal_Int32>(mrProperties.getIntValue( pName ));
     265           0 :             return nValue == nTriggerValue;
     266             :         }
     267             :     };
     268             : 
     269             : 
     270             : 
     271             :     /** A collection of values that helps to reduce the number of arguments
     272             :         given to some functions.  Note that not all values are set at the
     273             :         same time.
     274             :     */
     275           0 :     class PrintInfo
     276             :     {
     277             :     public:
     278           0 :         PrintInfo (
     279             :             const Printer* pPrinter,
     280             :             const bool bPrintMarkedOnly)
     281             :             : mpPrinter(pPrinter),
     282             :               mnDrawMode(DRAWMODE_DEFAULT),
     283             :               msTimeDate(),
     284             :               msPageString(),
     285             :               maPrintSize(0,0),
     286             :               maPageSize(0,0),
     287             :               meOrientation(ORIENTATION_PORTRAIT),
     288             :               maMap(),
     289           0 :               mbPrintMarkedOnly(bPrintMarkedOnly)
     290           0 :         {}
     291             : 
     292             :         const Printer* mpPrinter;
     293             :         sal_uLong mnDrawMode;
     294             :         ::rtl::OUString msTimeDate;
     295             :         ::rtl::OUString msPageString;
     296             :         Size maPrintSize;
     297             :         Size maPageSize;
     298             :         Orientation meOrientation;
     299             :         MapMode maMap;
     300             :         const bool mbPrintMarkedOnly;
     301             :     };
     302             : 
     303             : 
     304             : 
     305             :     /** Output one page of the document to the given printer.  Note that
     306             :         more than one document page may be output to one printer page.
     307             :     */
     308           0 :     void PrintPage (
     309             :         Printer& rPrinter,
     310             :         ::sd::View& rPrintView,
     311             :         SdPage& rPage,
     312             :         View* pView,
     313             :         const bool bPrintMarkedOnly,
     314             :         const SetOfByte& rVisibleLayers,
     315             :         const SetOfByte& rPrintableLayers)
     316             :     {
     317           0 :         rPrintView.ShowSdrPage(&rPage);
     318             : 
     319           0 :         const MapMode aOriginalMapMode (rPrinter.GetMapMode());
     320             : 
     321             :         // Set the visible layers
     322           0 :         SdrPageView* pPageView = rPrintView.GetSdrPageView();
     323             :         OSL_ASSERT(pPageView!=NULL);
     324           0 :         pPageView->SetVisibleLayers(rVisibleLayers);
     325           0 :         pPageView->SetPrintableLayers(rPrintableLayers);
     326             : 
     327           0 :         if (pView!=NULL && bPrintMarkedOnly)
     328           0 :             pView->DrawMarkedObj(rPrinter);
     329             :         else
     330           0 :             rPrintView.CompleteRedraw(&rPrinter, Rectangle(Point(0,0), rPage.GetSize()));
     331             : 
     332           0 :         rPrinter.SetMapMode(aOriginalMapMode);
     333             : 
     334           0 :         rPrintView.HideSdrPage();
     335           0 :     }
     336             : 
     337             : 
     338             : 
     339             : 
     340             :     /** Output a string (that typically is not part of a document page) to
     341             :         the given printer.
     342             :     */
     343           0 :     void PrintMessage (
     344             :         Printer& rPrinter,
     345             :         const ::rtl::OUString& rsPageString,
     346             :         const Point& rPageStringOffset)
     347             :     {
     348           0 :         const Font aOriginalFont (rPrinter.OutputDevice::GetFont());
     349           0 :         rPrinter.SetFont(Font(FAMILY_SWISS, Size(0, 423)));
     350           0 :         rPrinter.DrawText(rPageStringOffset, rsPageString);
     351           0 :         rPrinter.SetFont(aOriginalFont);
     352           0 :     }
     353             : 
     354             : 
     355             : 
     356             : 
     357             :     /** Read the resource file and process it into a sequence of properties
     358             :         that can be passed to the printing dialog.
     359             :     */
     360           0 :     class DialogCreator : Resource
     361             :     {
     362             :     public:
     363           0 :         DialogCreator (bool bImpress, sal_Int32 nCurPage)
     364             :             : Resource(SdResId(_STR_IMPRESS_PRINT_UI_OPTIONS))
     365             :             , mbImpress(bImpress)
     366           0 :             , mnCurPage(nCurPage)
     367             :         {
     368           0 :             ProcessResource();
     369           0 :         }
     370             : 
     371           0 :         Sequence< beans::PropertyValue > GetDialogControls() const
     372             :         {
     373           0 :             if (maProperties.empty())
     374           0 :                 return Sequence< beans::PropertyValue >();
     375             :             else
     376             :             {
     377             :                 return Sequence<beans::PropertyValue>(
     378           0 :                         &maProperties.front(),
     379           0 :                         maProperties.size());
     380             :             }
     381             :         }
     382             : 
     383           0 :         ::std::vector<sal_Int32> GetSlidesPerPage() const
     384             :         {
     385           0 :             return maSlidesPerPage;
     386             :         }
     387             : 
     388             :     private:
     389             :         Any maDialog;
     390             :         ::std::vector<beans::PropertyValue> maProperties;
     391             :         ::std::vector<sal_Int32> maSlidesPerPage;
     392             :         bool mbImpress;
     393             :         sal_Int32 mnCurPage;
     394             : 
     395           0 :         void ProcessResource()
     396             :         {
     397             :             // load the writer PrinterOptions into the custom tab
     398           0 :             beans::PropertyValue aOptionsUIFile;
     399           0 :             aOptionsUIFile.Name = rtl::OUString("OptionsUIFile");
     400           0 :             if( mbImpress )
     401           0 :                 aOptionsUIFile.Value <<= rtl::OUString("modules/simpress/ui/printeroptions.ui");
     402             :             else
     403           0 :                 aOptionsUIFile.Value <<= rtl::OUString("modules/sdraw/ui/printeroptions.ui");
     404           0 :             maProperties.push_back(aOptionsUIFile);
     405             : 
     406           0 :             SvtModuleOptions aOpt;
     407           0 :             String aAppGroupname( String( SdResId( _STR_IMPRESS_PRINT_UI_GROUP_NAME ) ) );
     408             :             aAppGroupname.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "%s" ) ),
     409           0 :                                            aOpt.GetModuleName( mbImpress ? SvtModuleOptions::E_SIMPRESS : SvtModuleOptions::E_SDRAW ) );
     410           0 :             AddDialogControl(vcl::PrinterOptionsHelper::setGroupControlOpt("tabcontrol-page2", aAppGroupname, ".HelpID:vcl:PrintDialog:TabPage:AppPage"));
     411             : 
     412           0 :             uno::Sequence< rtl::OUString > aHelpIds, aWidgetIds;
     413           0 :             if( mbImpress )
     414             :             {
     415           0 :                 vcl::PrinterOptionsHelper::UIControlOptions aPrintOpt;
     416           0 :                 aPrintOpt.maGroupHint = "JobPage" ;
     417             :                 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("extraimpressprintoptions",
     418             :                                     String( SdResId(_STR_IMPRESS_PRINT_UI_PRINT_GROUP) ),
     419             :                                     "",
     420           0 :                                     aPrintOpt ));
     421             : 
     422           0 :                 aHelpIds.realloc( 1 );
     423           0 :                 aHelpIds[0] = ".HelpID:vcl:PrintDialog:PageContentType:ListBox" ;
     424             :                 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
     425             :                                     "impressdocument",
     426             :                                     String( SdResId( _STR_IMPRESS_PRINT_UI_CONTENT ) ),
     427             :                                     aHelpIds,
     428             :                                     "PageContentType" ,
     429             :                                     CreateChoice(_STR_IMPRESS_PRINT_UI_CONTENT_CHOICES),
     430             :                                     0)
     431           0 :                                 );
     432             : 
     433           0 :                 aHelpIds[0] = ".HelpID:vcl:PrintDialog:SlidesPerPage:ListBox" ;
     434           0 :                 vcl::PrinterOptionsHelper::UIControlOptions aContentOpt( "PageContentType" , 1 );
     435             :                 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
     436             :                                     "slidesperpage",
     437             :                                     String( SdResId( _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE ) ),
     438             :                                     aHelpIds,
     439             :                                     "SlidesPerPage" ,
     440             :                                     GetSlidesPerPageSequence(),
     441             :                                     0,
     442             :                                     Sequence< sal_Bool >(),
     443             :                                     aContentOpt
     444             :                                     )
     445           0 :                                 );
     446             : 
     447           0 :                 aHelpIds[0] = ".HelpID:vcl:PrintDialog:SlidesPerPageOrder:ListBox" ;
     448           0 :                 vcl::PrinterOptionsHelper::UIControlOptions aSlidesPerPageOpt( "SlidesPerPage" , -1, sal_True );
     449             :                 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
     450             :                                     "slidesperpageorder",
     451             :                                     String( SdResId( _STR_IMPRESS_PRINT_UI_ORDER ) ),
     452             :                                     aHelpIds,
     453             :                                     "SlidesPerPageOrder" ,
     454             :                                     CreateChoice(_STR_IMPRESS_PRINT_UI_ORDER_CHOICES),
     455             :                                     0,
     456             :                                     Sequence< sal_Bool >(),
     457             :                                     aSlidesPerPageOpt )
     458           0 :                                 );
     459             :             }
     460             : 
     461             :             AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("contents",
     462           0 :                                String( SdResId(_STR_IMPRESS_PRINT_UI_INCLUDE_CONTENT) ), "" ) );
     463             : 
     464             : 
     465           0 :             if( mbImpress )
     466             :             {
     467             :                 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("printname",
     468             :                                     String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_NAME) ),
     469             :                                     ".HelpID:vcl:PrintDialog:IsPrintName:CheckBox" ,
     470             :                                     "IsPrintName" ,
     471             :                                     sal_False
     472             :                                     )
     473           0 :                                 );
     474             :             }
     475             :             else
     476             :             {
     477             :                 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("printname",
     478             :                                     String( SdResId(_STR_DRAW_PRINT_UI_IS_PRINT_NAME) ),
     479             :                                     ".HelpID:vcl:PrintDialog:IsPrintName:CheckBox" ,
     480             :                                     "IsPrintName" ,
     481             :                                     sal_False
     482             :                                     )
     483           0 :                                 );
     484             :             }
     485             : 
     486             :             AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("printdatetime",
     487             :                                 String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_DATE) ),
     488             :                                 ".HelpID:vcl:PrintDialog:IsPrintDateTime:CheckBox" ,
     489             :                                 "IsPrintDateTime" ,
     490             :                                 sal_False
     491             :                                 )
     492           0 :                             );
     493             : 
     494           0 :             if( mbImpress )
     495             :             {
     496             :                 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("printhidden",
     497             :                                     String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN) ),
     498             :                                     ".HelpID:vcl:PrintDialog:IsPrintHidden:CheckBox" ,
     499             :                                     "IsPrintHidden" ,
     500             :                                     sal_False
     501             :                                     )
     502           0 :                                 );
     503             :             }
     504             : 
     505             :             AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("color",
     506           0 :                                String( SdResId(_STR_IMPRESS_PRINT_UI_QUALITY) ), "" ) );
     507             : 
     508           0 :             aHelpIds.realloc( 3 );
     509           0 :             aHelpIds[0] = ".HelpID:vcl:PrintDialog:Quality:RadioButton:0" ;
     510           0 :             aHelpIds[1] = ".HelpID:vcl:PrintDialog:Quality:RadioButton:1" ;
     511           0 :             aHelpIds[2] = ".HelpID:vcl:PrintDialog:Quality:RadioButton:2" ;
     512           0 :             aWidgetIds.realloc( 3 );
     513           0 :             aWidgetIds[0] = "originalcolors";
     514           0 :             aWidgetIds[1] = "grayscale";
     515           0 :             aWidgetIds[2] = "blackandwhite";
     516             :             AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(
     517             :                                 aWidgetIds,
     518             :                                 "",
     519             :                                 aHelpIds,
     520             :                                 "Quality" ,
     521             :                                 CreateChoice(_STR_IMPRESS_PRINT_UI_QUALITY_CHOICES),
     522             :                                 0)
     523           0 :                             );
     524             : 
     525             :             AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("pagesizes",
     526           0 :                                String( SdResId(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS) ), "" ) );
     527             : 
     528           0 :             aHelpIds.realloc( 4 );
     529           0 :             aHelpIds[0] = ".HelpID:vcl:PrintDialog:PageOptions:RadioButton:0" ;
     530           0 :             aHelpIds[1] = ".HelpID:vcl:PrintDialog:PageOptions:RadioButton:1" ;
     531           0 :             aHelpIds[2] = ".HelpID:vcl:PrintDialog:PageOptions:RadioButton:2" ;
     532           0 :             aHelpIds[3] = ".HelpID:vcl:PrintDialog:PageOptions:RadioButton:3" ;
     533           0 :             aWidgetIds.realloc( 4 );
     534           0 :             aWidgetIds[0] = "originalsize";
     535           0 :             aWidgetIds[1] = "fittoprintable";
     536           0 :             aWidgetIds[2] = "distributeonmultiple";
     537           0 :             aWidgetIds[3] = "tilesheet";
     538           0 :             if( mbImpress )
     539             :             {
     540             :                 // FIXME: additional dependency on PrintProspect = false
     541           0 :                 vcl::PrinterOptionsHelper::UIControlOptions aPageOptionsOpt( "PageContentType" , 0 );
     542             :                 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(
     543             :                                     aWidgetIds,
     544             :                                     "",
     545             :                                     aHelpIds,
     546             :                                     "PageOptions" ,
     547             :                                     CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES),
     548             :                                     0,
     549             :                                     Sequence< sal_Bool >(),
     550             :                                     aPageOptionsOpt
     551             :                                     )
     552           0 :                                 );
     553             :             }
     554             :             else
     555             :             {
     556           0 :                 vcl::PrinterOptionsHelper::UIControlOptions aPageOptionsOpt( "PrintProspect" , sal_False );
     557             :                 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(
     558             :                                     aWidgetIds,
     559             :                                     "",
     560             :                                     aHelpIds,
     561             :                                     "PageOptions" ,
     562             :                                     CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW),
     563             :                                     0,
     564             :                                     Sequence< sal_Bool >(),
     565             :                                     aPageOptionsOpt
     566             :                                     )
     567           0 :                                 );
     568             :             }
     569             : 
     570           0 :             vcl::PrinterOptionsHelper::UIControlOptions aBrochureOpt;
     571           0 :             aBrochureOpt.maGroupHint = "LayoutPage" ;
     572             :             AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("pagesides",
     573             :                                String( SdResId(_STR_IMPRESS_PRINT_UI_PAGE_SIDES) ), "",
     574           0 :                                aBrochureOpt ) );
     575             : 
     576             :             // brochure printing
     577             :             AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("brochure",
     578             :                                 String( SdResId(_STR_IMPRESS_PRINT_UI_BROCHURE) ),
     579             :                                 ".HelpID:vcl:PrintDialog:PrintProspect:CheckBox" ,
     580             :                                 "PrintProspect" ,
     581             :                                 sal_False,
     582             :                                 aBrochureOpt
     583             :                                 )
     584           0 :                             );
     585             : 
     586             :             vcl::PrinterOptionsHelper::UIControlOptions
     587           0 :                 aIncludeOpt( "PrintProspect" , -1, sal_False );
     588           0 :             aIncludeOpt.maGroupHint =  "LayoutPage" ;
     589           0 :             aHelpIds.realloc( 1 );
     590           0 :             aHelpIds[0] = ".HelpID:vcl:PrintDialog:PrintProspectInclude:ListBox" ;
     591             :             AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
     592             :                                 "brochureinclude",
     593             :                                 String( SdResId(_STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE) ),
     594             :                                 aHelpIds,
     595             :                                 "PrintProspectInclude" ,
     596             :                                 CreateChoice(_STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST),
     597             :                                 0,
     598             :                                 Sequence< sal_Bool >(),
     599             :                                 aIncludeOpt
     600             :                                 )
     601           0 :                             );
     602             : 
     603             :             // paper tray (on options page)
     604           0 :             vcl::PrinterOptionsHelper::UIControlOptions aPaperTrayOpt;
     605           0 :             aPaperTrayOpt.maGroupHint = "OptionsPageOptGroup" ;
     606             :             AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt("printpaperfromsetup",
     607             :                                 String( SdResId(_STR_IMPRESS_PRINT_UI_PAPER_TRAY) ),
     608             :                                 ".HelpID:vcl:PrintDialog:PrintPaperFromSetup:CheckBox" ,
     609             :                                 "PrintPaperFromSetup" ,
     610             :                                 sal_False,
     611             :                                 aPaperTrayOpt
     612             :                                 )
     613           0 :                             );
     614             :             // print range selection
     615           0 :             vcl::PrinterOptionsHelper::UIControlOptions aPrintRangeOpt;
     616           0 :             aPrintRangeOpt.mbInternalOnly = sal_True;
     617           0 :             aPrintRangeOpt.maGroupHint = "PrintRange" ;
     618             :             AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt("printrange",
     619             :                                 String( SdResId( _STR_IMPRESS_PRINT_UI_PAGE_RANGE ) ),
     620             :                                 "",
     621             :                                 aPrintRangeOpt )
     622           0 :                              );
     623             : 
     624             :             // create a choice for the content to create
     625           0 :             rtl::OUString aPrintRangeName( "PrintContent" );
     626           0 :             aHelpIds.realloc( 3 );
     627           0 :             aHelpIds[0] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:0" ;
     628           0 :             aHelpIds[1] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:1" ;
     629           0 :             aHelpIds[2] = ".HelpID:vcl:PrintDialog:PrintContent:RadioButton:2" ;
     630           0 :             aWidgetIds.realloc( 3 );
     631           0 :             aWidgetIds[0] = "printallpages";
     632           0 :             aWidgetIds[1] = "printpages";
     633           0 :             aWidgetIds[2] = "printselection";
     634             :             AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(aWidgetIds, "",
     635             :                                 aHelpIds,
     636             :                                 aPrintRangeName,
     637             :                                 CreateChoice(mbImpress
     638             :                                              ? _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE
     639             :                                              : _STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE),
     640             :                                 0 )
     641           0 :                             );
     642             :             // create a an Edit dependent on "Pages" selected
     643           0 :             vcl::PrinterOptionsHelper::UIControlOptions aPageRangeOpt( aPrintRangeName, 1, sal_True );
     644             :             AddDialogControl(vcl::PrinterOptionsHelper::setEditControlOpt("pagerange", "",
     645             :                                 ".HelpID:vcl:PrintDialog:PageRange:Edit", "PageRange",
     646           0 :                                 OUString::valueOf(mnCurPage + 1), aPageRangeOpt));
     647             : 
     648           0 :             FreeResource();
     649           0 :         }
     650             : 
     651           0 :         void AddDialogControl( const Any& i_rCtrl )
     652             :         {
     653           0 :             beans::PropertyValue aVal;
     654           0 :             aVal.Value = i_rCtrl;
     655           0 :             maProperties.push_back( aVal );
     656           0 :         }
     657             : 
     658           0 :         Sequence<rtl::OUString> CreateChoice (const sal_uInt16 nResourceId) const
     659             :         {
     660           0 :             SdResId aResourceId (nResourceId);
     661           0 :             ResStringArray aChoiceStrings (aResourceId);
     662             : 
     663           0 :             const sal_uInt32 nCount (aChoiceStrings.Count());
     664           0 :             Sequence<rtl::OUString> aChoices (nCount);
     665           0 :             for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)
     666           0 :                 aChoices[nIndex] = aChoiceStrings.GetString(nIndex);
     667             : 
     668           0 :             return aChoices;
     669             :         }
     670             : 
     671           0 :         Sequence<rtl::OUString> GetSlidesPerPageSequence()
     672             :         {
     673             :             const Sequence<rtl::OUString> aChoice (
     674           0 :                 CreateChoice(_STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES));
     675           0 :             maSlidesPerPage.clear();
     676           0 :             maSlidesPerPage.push_back(0); // first is using the default
     677           0 :             for (sal_Int32 nIndex=1,nCount=aChoice.getLength(); nIndex<nCount; ++nIndex)
     678           0 :                 maSlidesPerPage.push_back(aChoice[nIndex].toInt32());
     679           0 :             return aChoice;
     680             :         }
     681             :     };
     682             : 
     683             : 
     684             : 
     685             : 
     686             :     /** The Prepare... methods of the DocumentRenderer::Implementation class
     687             :         create a set of PrinterPage objects that contain all necessary
     688             :         information to do the actual printing.  There is one PrinterPage
     689             :         object per printed page.  Derived classes implement the actual, mode
     690             :         specific printing.
     691             : 
     692             :         This and all derived classes support the asynchronous printing
     693             :         process by not storing pointers to any data with lifetime shorter
     694             :         than the PrinterPage objects, i.e. slides, shapes, (one of) the
     695             :         outliner (of the document).
     696             :     */
     697             :     class PrinterPage
     698             :     {
     699             :     public:
     700           0 :         PrinterPage (
     701             :             const PageKind ePageKind,
     702             :             const MapMode& rMapMode,
     703             :             const bool bPrintMarkedOnly,
     704             :             const ::rtl::OUString& rsPageString,
     705             :             const Point& rPageStringOffset,
     706             :             const sal_uLong nDrawMode,
     707             :             const Orientation eOrientation,
     708             :             const sal_uInt16 nPaperTray)
     709             :             : mePageKind(ePageKind),
     710             :               maMap(rMapMode),
     711             :               mbPrintMarkedOnly(bPrintMarkedOnly),
     712             :               msPageString(rsPageString),
     713             :               maPageStringOffset(rPageStringOffset),
     714             :               mnDrawMode(nDrawMode),
     715             :               meOrientation(eOrientation),
     716           0 :               mnPaperTray(nPaperTray)
     717             :         {
     718           0 :         }
     719             : 
     720           0 :         virtual ~PrinterPage() {}
     721             : 
     722             :         virtual void Print (
     723             :             Printer& rPrinter,
     724             :             SdDrawDocument& rDocument,
     725             :             ViewShell& rViewShell,
     726             :             View* pView,
     727             :             DrawView& rPrintView,
     728             :             const SetOfByte& rVisibleLayers,
     729             :             const SetOfByte& rPrintableLayers) const = 0;
     730             : 
     731           0 :         sal_uLong GetDrawMode() const { return mnDrawMode; }
     732           0 :         Orientation GetOrientation() const { return meOrientation; }
     733           0 :         sal_uInt16 GetPaperTray() const { return mnPaperTray; }
     734             : 
     735             :     protected:
     736             :         const PageKind mePageKind;
     737             :         const MapMode maMap;
     738             :         const bool mbPrintMarkedOnly;
     739             :         const ::rtl::OUString msPageString;
     740             :         const Point maPageStringOffset;
     741             :         const sal_uLong mnDrawMode;
     742             :         const Orientation meOrientation;
     743             :         const sal_uInt16 mnPaperTray;
     744             :     };
     745             : 
     746             : 
     747             : 
     748             : 
     749             :     /** The RegularPrinterPage is used for printing one regular slide (no
     750             :         notes, handout, or outline) to one printer page.
     751             :     */
     752             :     class RegularPrinterPage : public PrinterPage
     753             :     {
     754             :     public:
     755           0 :         RegularPrinterPage (
     756             :             const sal_uInt16 nPageIndex,
     757             :             const PageKind ePageKind,
     758             :             const MapMode& rMapMode,
     759             :             const bool bPrintMarkedOnly,
     760             :             const ::rtl::OUString& rsPageString,
     761             :             const Point& rPageStringOffset,
     762             :             const sal_uLong nDrawMode,
     763             :             const Orientation eOrientation,
     764             :             const sal_uInt16 nPaperTray)
     765             :             : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, rsPageString,
     766             :                 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
     767           0 :               mnPageIndex(nPageIndex)
     768             :         {
     769           0 :         }
     770             : 
     771           0 :         virtual ~RegularPrinterPage() {}
     772             : 
     773           0 :         virtual void Print (
     774             :             Printer& rPrinter,
     775             :             SdDrawDocument& rDocument,
     776             :             ViewShell& rViewShell,
     777             :             View* pView,
     778             :             DrawView& rPrintView,
     779             :             const SetOfByte& rVisibleLayers,
     780             :             const SetOfByte& rPrintableLayers) const
     781             :         {
     782             :             (void)rViewShell;
     783           0 :             SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind);
     784           0 :             rPrinter.SetMapMode(maMap);
     785             :             PrintPage(
     786             :                 rPrinter,
     787             :                 rPrintView,
     788             :                 *pPageToPrint,
     789             :                 pView,
     790             :                 mbPrintMarkedOnly,
     791             :                 rVisibleLayers,
     792           0 :                 rPrintableLayers);
     793             :             PrintMessage(
     794             :                 rPrinter,
     795             :                 msPageString,
     796           0 :                 maPageStringOffset);
     797           0 :         }
     798             : 
     799             :     private:
     800             :         const sal_uInt16 mnPageIndex;
     801             :     };
     802             : 
     803             : 
     804             : 
     805             : 
     806             :     /** Print one slide multiple times on a printer page so that the whole
     807             :         printer page is covered.
     808             :     */
     809             :     class TiledPrinterPage : public PrinterPage
     810             :     {
     811             :     public:
     812           0 :         TiledPrinterPage (
     813             :             const sal_uInt16 nPageIndex,
     814             :             const PageKind ePageKind,
     815             :             const sal_Int32 nGap,
     816             :             const bool bPrintMarkedOnly,
     817             :             const ::rtl::OUString& rsPageString,
     818             :             const Point& rPageStringOffset,
     819             :             const sal_uLong nDrawMode,
     820             :             const Orientation eOrientation,
     821             :             const sal_uInt16 nPaperTray)
     822             :             : PrinterPage(ePageKind, MapMode(), bPrintMarkedOnly, rsPageString,
     823             :                 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
     824             :               mnPageIndex(nPageIndex),
     825           0 :               mnGap(nGap)
     826             :         {
     827           0 :         }
     828             : 
     829           0 :         virtual ~TiledPrinterPage() {}
     830             : 
     831           0 :         virtual void Print (
     832             :             Printer& rPrinter,
     833             :             SdDrawDocument& rDocument,
     834             :             ViewShell& rViewShell,
     835             :             View* pView,
     836             :             DrawView& rPrintView,
     837             :             const SetOfByte& rVisibleLayers,
     838             :             const SetOfByte& rPrintableLayers) const
     839             :         {
     840             :             (void)rViewShell;
     841           0 :             SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind);
     842           0 :             if (pPageToPrint==NULL)
     843             :                 return;
     844           0 :             MapMode aMap (rPrinter.GetMapMode());
     845             : 
     846           0 :             const Size aPageSize (pPageToPrint->GetSize());
     847           0 :             const Size aPrintSize (rPrinter.GetOutputSize());
     848             : 
     849           0 :             const sal_Int32 nPageWidth (aPageSize.Width() + mnGap
     850           0 :                 - pPageToPrint->GetLftBorder() - pPageToPrint->GetRgtBorder());
     851           0 :             const sal_Int32 nPageHeight (aPageSize.Height() + mnGap
     852           0 :                 - pPageToPrint->GetUppBorder() - pPageToPrint->GetLwrBorder());
     853           0 :             if (nPageWidth<=0 || nPageHeight<=0)
     854             :                 return;
     855             : 
     856             :             // Print at least two rows and columns.  More if the document
     857             :             // page fits completely onto the printer page.
     858             :             const sal_Int32 nColumnCount (::std::max(sal_Int32(2),
     859           0 :                     sal_Int32(aPrintSize.Width() / nPageWidth)));
     860             :             const sal_Int32 nRowCount (::std::max(sal_Int32(2),
     861           0 :                     sal_Int32(aPrintSize.Height() / nPageHeight)));
     862           0 :             Point aPrintOrigin;
     863           0 :             for (sal_Int32 nRow=0; nRow<nRowCount; ++nRow)
     864           0 :                 for (sal_Int32 nColumn=0; nColumn<nColumnCount; ++nColumn)
     865             :                 {
     866           0 :                     aMap.SetOrigin(Point(nColumn*nPageWidth,nRow*nPageHeight));
     867           0 :                     rPrinter.SetMapMode(aMap);
     868             :                     PrintPage(
     869             :                         rPrinter,
     870             :                         rPrintView,
     871             :                         *pPageToPrint,
     872             :                         pView,
     873             :                         mbPrintMarkedOnly,
     874             :                         rVisibleLayers,
     875           0 :                         rPrintableLayers);
     876             :                 }
     877             : 
     878             :             PrintMessage(
     879             :                 rPrinter,
     880             :                 msPageString,
     881           0 :                 maPageStringOffset);
     882             :         }
     883             : 
     884             :     private:
     885             :         const sal_uInt16 mnPageIndex;
     886             :         const sal_Int32 mnGap;
     887             :     };
     888             : 
     889             :     /** Print two slides to one printer page so that the resulting pages
     890             :         form a booklet.
     891             :     */
     892             :     class BookletPrinterPage : public PrinterPage
     893             :     {
     894             :     public:
     895           0 :         BookletPrinterPage (
     896             :             const sal_uInt16 nFirstPageIndex,
     897             :             const sal_uInt16 nSecondPageIndex,
     898             :             const Point& rFirstOffset,
     899             :             const Point& rSecondOffset,
     900             :             const PageKind ePageKind,
     901             :             const MapMode& rMapMode,
     902             :             const bool bPrintMarkedOnly,
     903             :             const sal_uLong nDrawMode,
     904             :             const Orientation eOrientation,
     905             :             const sal_uInt16 nPaperTray)
     906             :             : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, "",
     907             :                 Point(), nDrawMode, eOrientation, nPaperTray),
     908             :               mnFirstPageIndex(nFirstPageIndex),
     909             :               mnSecondPageIndex(nSecondPageIndex),
     910             :               maFirstOffset(rFirstOffset),
     911           0 :               maSecondOffset(rSecondOffset)
     912             :         {
     913           0 :         }
     914             : 
     915           0 :         virtual ~BookletPrinterPage() {}
     916             : 
     917           0 :         virtual void Print (
     918             :             Printer& rPrinter,
     919             :             SdDrawDocument& rDocument,
     920             :             ViewShell& rViewShell,
     921             :             View* pView,
     922             :             DrawView& rPrintView,
     923             :             const SetOfByte& rVisibleLayers,
     924             :             const SetOfByte& rPrintableLayers) const
     925             :         {
     926             :             (void)rViewShell;
     927           0 :             MapMode aMap (maMap);
     928           0 :             SdPage* pPageToPrint = rDocument.GetSdPage(mnFirstPageIndex, mePageKind);
     929           0 :             if (pPageToPrint)
     930             :             {
     931           0 :                 aMap.SetOrigin(maFirstOffset);
     932           0 :                 rPrinter.SetMapMode(aMap);
     933             :                 PrintPage(
     934             :                     rPrinter,
     935             :                     rPrintView,
     936             :                     *pPageToPrint,
     937             :                     pView,
     938             :                     mbPrintMarkedOnly,
     939             :                     rVisibleLayers,
     940           0 :                     rPrintableLayers);
     941             :             }
     942             : 
     943           0 :             pPageToPrint = rDocument.GetSdPage(mnSecondPageIndex, mePageKind);
     944           0 :             if( pPageToPrint )
     945             :             {
     946           0 :                 aMap.SetOrigin(maSecondOffset);
     947           0 :                 rPrinter.SetMapMode(aMap);
     948             :                 PrintPage(
     949             :                     rPrinter,
     950             :                     rPrintView,
     951             :                     *pPageToPrint,
     952             :                     pView,
     953             :                     mbPrintMarkedOnly,
     954             :                     rVisibleLayers,
     955           0 :                     rPrintableLayers);
     956           0 :             }
     957           0 :         }
     958             : 
     959             :     private:
     960             :         const sal_uInt16 mnFirstPageIndex;
     961             :         const sal_uInt16 mnSecondPageIndex;
     962             :         const Point maFirstOffset;
     963             :         const Point maSecondOffset;
     964             :     };
     965             : 
     966             : 
     967             : 
     968             : 
     969             :     /** One handout page displays one to nine slides.
     970             :     */
     971           0 :     class HandoutPrinterPage : public PrinterPage
     972             :     {
     973             :     public:
     974           0 :         HandoutPrinterPage (
     975             :             const sal_uInt16 nHandoutPageIndex,
     976             :             const ::std::vector<sal_uInt16>& rPageIndices,
     977             :             const MapMode& rMapMode,
     978             :             const ::rtl::OUString& rsPageString,
     979             :             const Point& rPageStringOffset,
     980             :             const sal_uLong nDrawMode,
     981             :             const Orientation eOrientation,
     982             :             const sal_uInt16 nPaperTray)
     983             :             : PrinterPage(PK_HANDOUT, rMapMode, false, rsPageString,
     984             :                 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
     985             :               mnHandoutPageIndex(nHandoutPageIndex),
     986           0 :               maPageIndices(rPageIndices)
     987             :         {
     988           0 :         }
     989             : 
     990           0 :         virtual void Print (
     991             :             Printer& rPrinter,
     992             :             SdDrawDocument& rDocument,
     993             :             ViewShell& rViewShell,
     994             :             View* pView,
     995             :             DrawView& rPrintView,
     996             :             const SetOfByte& rVisibleLayers,
     997             :             const SetOfByte& rPrintableLayers) const
     998             :         {
     999           0 :             SdPage& rHandoutPage (*rDocument.GetSdPage(0, PK_HANDOUT));
    1000             : 
    1001           0 :             Reference< com::sun::star::beans::XPropertySet > xHandoutPage( rHandoutPage.getUnoPage(), UNO_QUERY );
    1002           0 :             const rtl::OUString sPageNumber( "Number" );
    1003             : 
    1004             :             // Collect the page objects of the handout master.
    1005           0 :             std::vector<SdrPageObj*> aHandoutPageObjects;
    1006           0 :             SdrObjListIter aShapeIter (rHandoutPage);
    1007           0 :             while (aShapeIter.IsMore())
    1008             :             {
    1009           0 :                 SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next());
    1010           0 :                 if (pPageObj)
    1011           0 :                     aHandoutPageObjects.push_back(pPageObj);
    1012             :             }
    1013           0 :             if (aHandoutPageObjects.empty())
    1014           0 :                 return;
    1015             : 
    1016             :             // Connect page objects with pages.
    1017           0 :             std::vector<SdrPageObj*>::iterator aPageObjIter (aHandoutPageObjects.begin());
    1018           0 :             for (std::vector<sal_uInt16>::const_iterator
    1019           0 :                      iPageIndex(maPageIndices.begin()),
    1020           0 :                      iEnd(maPageIndices.end());
    1021           0 :                  iPageIndex!=iEnd && aPageObjIter!=aHandoutPageObjects.end();
    1022             :                  ++iPageIndex)
    1023             :             {
    1024             :                 // Check if the page still exists.
    1025           0 :                 if (*iPageIndex >= rDocument.GetSdPageCount(PK_STANDARD))
    1026           0 :                     continue;
    1027             : 
    1028           0 :                 SdrPageObj* pPageObj = (*aPageObjIter++);
    1029           0 :                 pPageObj->SetReferencedPage(rDocument.GetSdPage(*iPageIndex, PK_STANDARD));
    1030             :             }
    1031             : 
    1032             :             // if there are more page objects than pages left, set the rest to invisible
    1033           0 :             int nHangoverCount = 0;
    1034           0 :             while (aPageObjIter != aHandoutPageObjects.end())
    1035             :             {
    1036           0 :                 (*aPageObjIter++)->SetReferencedPage(0L);
    1037           0 :                 nHangoverCount++;
    1038             :             }
    1039             : 
    1040             :             // Hide outlines for objects that have pages attached.
    1041           0 :             if (nHangoverCount > 0)
    1042             :             {
    1043           0 :                 int nSkip = aHandoutPageObjects.size() - nHangoverCount;
    1044           0 :                 aShapeIter.Reset();
    1045           0 :                 while (aShapeIter.IsMore())
    1046             :                 {
    1047           0 :                     SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next());
    1048           0 :                     if (pPathObj)
    1049             :                     {
    1050           0 :                         if (nSkip > 0)
    1051           0 :                             --nSkip;
    1052             :                         else
    1053           0 :                             pPathObj->SetMergedItem(XLineStyleItem(XLINE_NONE));
    1054             :                     }
    1055             :                 }
    1056             :             }
    1057             : 
    1058           0 :             if( xHandoutPage.is() ) try
    1059             :             {
    1060           0 :                 xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(mnHandoutPageIndex) ) );
    1061             :             }
    1062           0 :             catch( Exception& )
    1063             :             {
    1064             :             }
    1065           0 :             rViewShell.SetPrintedHandoutPageNum( mnHandoutPageIndex + 1 );
    1066             : 
    1067           0 :             MapMode aMap (rPrinter.GetMapMode());
    1068           0 :             rPrinter.SetMapMode(maMap);
    1069             : 
    1070             :             PrintPage(
    1071             :                 rPrinter,
    1072             :                 rPrintView,
    1073             :                 rHandoutPage,
    1074             :                 pView,
    1075             :                 false,
    1076             :                 rVisibleLayers,
    1077           0 :                 rPrintableLayers);
    1078             :             PrintMessage(
    1079             :                 rPrinter,
    1080             :                 msPageString,
    1081           0 :                 maPageStringOffset);
    1082             : 
    1083           0 :             if( xHandoutPage.is() ) try
    1084             :             {
    1085           0 :                 xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(0) ) );
    1086             :             }
    1087           0 :             catch( Exception& )
    1088             :             {
    1089             :             }
    1090           0 :             rViewShell.SetPrintedHandoutPageNum(1);
    1091             : 
    1092             :             // Restore outlines.
    1093           0 :             if (nHangoverCount > 0)
    1094             :             {
    1095           0 :                 aShapeIter.Reset();
    1096           0 :                 while (aShapeIter.IsMore())
    1097             :                 {
    1098           0 :                     SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next());
    1099           0 :                     if (pPathObj != NULL)
    1100           0 :                         pPathObj->SetMergedItem(XLineStyleItem(XLINE_SOLID));
    1101             :                 }
    1102           0 :             }
    1103             : 
    1104             :        }
    1105             : 
    1106             :     private:
    1107             :         const sal_uInt16 mnHandoutPageIndex;
    1108             :         const ::std::vector<sal_uInt16> maPageIndices;
    1109             :     };
    1110             : 
    1111             : 
    1112             : 
    1113             : 
    1114             :     /** The outline information (title, subtitle, outline objects) of the
    1115             :         document.  There is no fixed mapping of slides to printer pages.
    1116             :     */
    1117             :     class OutlinerPrinterPage : public PrinterPage
    1118             :     {
    1119             :     public:
    1120           0 :         OutlinerPrinterPage (
    1121             :             OutlinerParaObject* pParaObject,
    1122             :             const MapMode& rMapMode,
    1123             :             const ::rtl::OUString& rsPageString,
    1124             :             const Point& rPageStringOffset,
    1125             :             const sal_uLong nDrawMode,
    1126             :             const Orientation eOrientation,
    1127             :             const sal_uInt16 nPaperTray)
    1128             :             : PrinterPage(PK_HANDOUT, rMapMode, false, rsPageString,
    1129             :                 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
    1130           0 :               mpParaObject(pParaObject)
    1131             :         {
    1132           0 :         }
    1133             : 
    1134           0 :         ~OutlinerPrinterPage()
    1135           0 :         {
    1136           0 :             mpParaObject.reset();
    1137           0 :         }
    1138             : 
    1139           0 :         virtual void Print (
    1140             :             Printer& rPrinter,
    1141             :             SdDrawDocument& rDocument,
    1142             :             ViewShell& rViewShell,
    1143             :             View* pView,
    1144             :             DrawView& rPrintView,
    1145             :             const SetOfByte& rVisibleLayers,
    1146             :             const SetOfByte& rPrintableLayers) const
    1147             :         {
    1148             :             (void)rViewShell;
    1149             :             (void)pView;
    1150             :             (void)rPrintView;
    1151             :             (void)rVisibleLayers;
    1152             :             (void)rPrintableLayers;
    1153             : 
    1154             :             // Set up the printer.
    1155           0 :             rPrinter.SetMapMode(maMap);
    1156             : 
    1157             :             // Get and set up the outliner.
    1158           0 :             const Rectangle aOutRect (rPrinter.GetPageOffset(), rPrinter.GetOutputSize());
    1159           0 :             Outliner* pOutliner = rDocument.GetInternalOutliner();
    1160           0 :             const sal_uInt16 nSavedOutlMode (pOutliner->GetMode());
    1161           0 :             const sal_Bool bSavedUpdateMode (pOutliner->GetUpdateMode());
    1162           0 :             const Size aSavedPaperSize (pOutliner->GetPaperSize());
    1163             : 
    1164           0 :             pOutliner->Init(OUTLINERMODE_OUTLINEVIEW);
    1165           0 :             pOutliner->SetPaperSize(aOutRect.GetSize());
    1166           0 :             pOutliner->SetUpdateMode(sal_True);
    1167           0 :             pOutliner->Clear();
    1168           0 :             pOutliner->SetText(*mpParaObject);
    1169             : 
    1170           0 :             pOutliner->Draw(&rPrinter, aOutRect);
    1171             : 
    1172             :             PrintMessage(
    1173             :                 rPrinter,
    1174             :                 msPageString,
    1175           0 :                 maPageStringOffset);
    1176             : 
    1177             :             // Restore outliner and printer.
    1178           0 :             pOutliner->Clear();
    1179           0 :             pOutliner->SetUpdateMode(bSavedUpdateMode);
    1180           0 :             pOutliner->SetPaperSize(aSavedPaperSize);
    1181           0 :             pOutliner->Init(nSavedOutlMode);
    1182           0 :         }
    1183             : 
    1184             :     private:
    1185             :         ::boost::scoped_ptr<OutlinerParaObject> mpParaObject;
    1186             :     };
    1187             : }
    1188             : 
    1189             : 
    1190             : //===== DocumentRenderer::Implementation ======================================
    1191             : 
    1192             : class DocumentRenderer::Implementation
    1193             :     : public SfxListener,
    1194             :       public vcl::PrinterOptionsHelper
    1195             : {
    1196             : public:
    1197           0 :     Implementation (ViewShellBase& rBase)
    1198           0 :         : mxObjectShell(rBase.GetDocShell())
    1199             :         , mrBase(rBase)
    1200             :         , mbIsDisposed(false)
    1201             :         , mpPrinter(NULL)
    1202             :         , mpOptions()
    1203             :         , maPrinterPages()
    1204             :         , mpPrintView()
    1205           0 :         , mbHasOrientationWarningBeenShown(false)
    1206             :     {
    1207           0 :         DialogCreator aCreator( mrBase.GetDocShell()->GetDocumentType() == DOCUMENT_TYPE_IMPRESS, GetCurrentPageIndex() );
    1208           0 :         m_aUIProperties = aCreator.GetDialogControls();
    1209           0 :         maSlidesPerPage = aCreator.GetSlidesPerPage();
    1210             : 
    1211           0 :         StartListening(mrBase);
    1212           0 :     }
    1213             : 
    1214             : 
    1215             : 
    1216             : 
    1217           0 :     virtual ~Implementation()
    1218           0 :     {
    1219           0 :         EndListening(mrBase);
    1220           0 :     }
    1221             : 
    1222             : 
    1223             : 
    1224             : 
    1225           0 :     virtual void Notify (SfxBroadcaster& rBroadcaster, const SfxHint& rHint)
    1226             :     {
    1227           0 :         const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
    1228           0 :         if (pSimpleHint != NULL
    1229           0 :             && pSimpleHint->GetId() == SFX_HINT_DYING
    1230             :             && &rBroadcaster == &static_cast<SfxBroadcaster&>(mrBase))
    1231             :         {
    1232           0 :             Dispose();
    1233             :         }
    1234           0 :     }
    1235             : 
    1236             : 
    1237             : 
    1238             :     /** Process the sequence of properties given to one of the XRenderable
    1239             :         methods.
    1240             :     */
    1241           0 :     void ProcessProperties (const css::uno::Sequence<css::beans::PropertyValue >& rOptions)
    1242             :     {
    1243             :         OSL_ASSERT(!mbIsDisposed);
    1244           0 :         if (mbIsDisposed)
    1245           0 :             return;
    1246             : 
    1247           0 :         bool bIsValueChanged = processProperties( rOptions );
    1248           0 :         bool bIsPaperChanged = false;
    1249             : 
    1250             :         // The RenderDevice property is handled specially: its value is
    1251             :         // stored in mpPrinter instead of being retrieved on demand.
    1252           0 :         Any aDev( getValue( "RenderDevice" ) );
    1253           0 :         Reference<awt::XDevice> xRenderDevice;
    1254             : 
    1255           0 :         if (aDev >>= xRenderDevice)
    1256             :         {
    1257           0 :             VCLXDevice* pDevice = VCLXDevice::GetImplementation(xRenderDevice);
    1258           0 :             OutputDevice* pOut = pDevice ? pDevice->GetOutputDevice() : NULL;
    1259           0 :             mpPrinter = dynamic_cast<Printer*>(pOut);
    1260           0 :             Size aPageSizePixel = mpPrinter ? mpPrinter->GetPaperSizePixel() : Size();
    1261           0 :             if( aPageSizePixel != maPrinterPageSizePixel )
    1262             :             {
    1263           0 :                 bIsPaperChanged = true;
    1264           0 :                 maPrinterPageSizePixel = aPageSizePixel;
    1265             :             }
    1266             :         }
    1267             : 
    1268           0 :         if (bIsValueChanged)
    1269             :         {
    1270           0 :             if ( ! mpOptions )
    1271           0 :                 mpOptions.reset(new PrintOptions(*this, maSlidesPerPage));
    1272             :         }
    1273           0 :         if( bIsValueChanged || bIsPaperChanged )
    1274           0 :             PreparePages();
    1275             :     }
    1276             : 
    1277             : 
    1278             : 
    1279             :     /** Return the number of pages that are to be printed.
    1280             :     */
    1281           0 :     sal_Int32 GetPrintPageCount()
    1282             :     {
    1283             :         OSL_ASSERT(!mbIsDisposed);
    1284           0 :         if (mbIsDisposed)
    1285           0 :             return 0;
    1286             :         else
    1287           0 :             return maPrinterPages.size();
    1288             :     }
    1289             : 
    1290             : 
    1291             : 
    1292             :     /** Return a sequence of properties that can be returned by the
    1293             :         XRenderable::getRenderer() method.
    1294             :     */
    1295           0 :     css::uno::Sequence<css::beans::PropertyValue> GetProperties (
    1296             :         const css::uno::Sequence<css::beans::PropertyValue>& rOptions)
    1297             :     {
    1298             :         (void)rOptions;
    1299             : 
    1300           0 :         css::uno::Sequence<css::beans::PropertyValue> aProperties (3);
    1301             : 
    1302           0 :         aProperties[0].Name = "ExtraPrintUIOptions";
    1303           0 :         aProperties[0].Value <<= m_aUIProperties;
    1304             : 
    1305           0 :         aProperties[1].Name = "PageSize";
    1306           0 :         aProperties[1].Value <<= maPrintSize;
    1307             : 
    1308             :         // FIXME: is this always true ?
    1309           0 :         aProperties[2].Name = "PageIncludesNonprintableArea";
    1310           0 :         aProperties[2].Value = makeAny( sal_True );
    1311             : 
    1312           0 :         return aProperties;
    1313             :     }
    1314             : 
    1315             : 
    1316             : 
    1317             : 
    1318             :     /** Print one of the prepared pages.
    1319             :     */
    1320           0 :     void PrintPage (const sal_Int32 nIndex)
    1321             :     {
    1322             :         OSL_ASSERT(!mbIsDisposed);
    1323           0 :         if (mbIsDisposed)
    1324             :             return;
    1325             : 
    1326           0 :         Printer& rPrinter (*mpPrinter);
    1327             : 
    1328           0 :         ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
    1329           0 :         if ( ! pViewShell)
    1330             :             return;
    1331             : 
    1332           0 :         SdDrawDocument* pDocument = pViewShell->GetDoc();
    1333             :         OSL_ASSERT(pDocument!=NULL);
    1334             : 
    1335             :         ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
    1336           0 :             ::boost::dynamic_pointer_cast<DrawViewShell>(mrBase.GetMainViewShell()));
    1337             : 
    1338           0 :         if ( ! mpPrintView)
    1339           0 :             mpPrintView.reset(new DrawView(mrBase.GetDocShell(), &rPrinter, NULL));
    1340             : 
    1341           0 :         if (nIndex<0 || sal::static_int_cast<sal_uInt32>(nIndex)>=maPrinterPages.size())
    1342             :             return;
    1343             : 
    1344           0 :         const ::boost::shared_ptr<PrinterPage> pPage (maPrinterPages[nIndex]);
    1345             :         OSL_ASSERT(pPage);
    1346           0 :         if ( ! pPage)
    1347             :             return;
    1348             : 
    1349           0 :         const Orientation eSavedOrientation (rPrinter.GetOrientation());
    1350           0 :         const sal_uLong nSavedDrawMode (rPrinter.GetDrawMode());
    1351           0 :         const MapMode aSavedMapMode (rPrinter.GetMapMode());
    1352           0 :         const sal_uInt16 nSavedPaperBin (rPrinter.GetPaperBin());
    1353             : 
    1354             : 
    1355             :         // Set page orientation.
    1356           0 :         if ( ! rPrinter.SetOrientation(pPage->GetOrientation()))
    1357             :         {
    1358           0 :             if ( ! mbHasOrientationWarningBeenShown
    1359           0 :                 && mpOptions->IsWarningOrientation())
    1360             :             {
    1361           0 :                 mbHasOrientationWarningBeenShown = true;
    1362             :                 // Show warning that the orientation could not be set.
    1363           0 :                 if (pViewShell)
    1364             :                 {
    1365             :                     WarningBox aWarnBox(
    1366           0 :                         pViewShell->GetActiveWindow(),
    1367             :                         (WinBits)(WB_OK_CANCEL | WB_DEF_CANCEL),
    1368           0 :                         String(SdResId(STR_WARN_PRINTFORMAT_FAILURE)));
    1369           0 :                     if (aWarnBox.Execute() != RET_OK)
    1370           0 :                         return;
    1371             :                 }
    1372             :             }
    1373             :         }
    1374             : 
    1375             :         // Set the draw mode.
    1376           0 :         rPrinter.SetDrawMode(pPage->GetDrawMode());
    1377             : 
    1378             :         // Set paper tray.
    1379           0 :         rPrinter.SetPaperBin(pPage->GetPaperTray());
    1380             : 
    1381             :         // Print the actual page.
    1382           0 :         pPage->Print(
    1383             :             rPrinter,
    1384             :             *pDocument,
    1385           0 :             *pViewShell,
    1386           0 :             pDrawViewShell ? pDrawViewShell->GetView() : NULL,
    1387           0 :             *mpPrintView,
    1388           0 :             pViewShell->GetFrameView()->GetVisibleLayers(),
    1389           0 :             pViewShell->GetFrameView()->GetPrintableLayers());
    1390             : 
    1391           0 :         rPrinter.SetOrientation(eSavedOrientation);
    1392           0 :         rPrinter.SetDrawMode(nSavedDrawMode);
    1393           0 :         rPrinter.SetMapMode(aSavedMapMode);
    1394           0 :         rPrinter.SetPaperBin(nSavedPaperBin);
    1395             :     }
    1396             : 
    1397             : 
    1398             : 
    1399             : 
    1400             : private:
    1401             :     // rhbz#657394: keep the document alive: prevents crash when
    1402             :     SfxObjectShellRef mxObjectShell; // destroying mpPrintView
    1403             :     ViewShellBase& mrBase;
    1404             :     bool mbIsDisposed;
    1405             :     Printer* mpPrinter;
    1406             :     Size maPrinterPageSizePixel;
    1407             :     ::boost::scoped_ptr<PrintOptions> mpOptions;
    1408             :     ::std::vector< ::boost::shared_ptr< ::sd::PrinterPage> > maPrinterPages;
    1409             :     ::boost::scoped_ptr<DrawView> mpPrintView;
    1410             :     bool mbHasOrientationWarningBeenShown;
    1411             :     ::std::vector<sal_Int32> maSlidesPerPage;
    1412             :     awt::Size maPrintSize;
    1413             : 
    1414           0 :     void Dispose()
    1415             :     {
    1416           0 :         mbIsDisposed = true;
    1417           0 :     }
    1418             : 
    1419           0 :     sal_Int32 GetCurrentPageIndex() const
    1420             :     {
    1421           0 :         const ViewShell *pShell = mrBase.GetMainViewShell().get();
    1422           0 :         const SdPage *pCurrentPage = pShell ? pShell->getCurrentPage() : NULL;
    1423           0 :         return pCurrentPage ? (pCurrentPage->GetPageNum()-1)/2 : -1;
    1424             :     }
    1425             : 
    1426             :     /** Determine and set the paper orientation.
    1427             :     */
    1428           0 :     bool SetupPaperOrientation (
    1429             :         const PageKind ePageKind,
    1430             :         PrintInfo& rInfo)
    1431             :     {
    1432           0 :         SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc();
    1433           0 :         rInfo.meOrientation = ORIENTATION_PORTRAIT;
    1434             : 
    1435           0 :         if( ! mpOptions->IsBooklet())
    1436             :         {
    1437           0 :             rInfo.meOrientation = pDocument->GetSdPage(0, ePageKind)->GetOrientation();
    1438             :         }
    1439           0 :         else if (rInfo.maPageSize.Width() < rInfo.maPageSize.Height())
    1440           0 :             rInfo.meOrientation = ORIENTATION_LANDSCAPE;
    1441             : 
    1442           0 :         const Size aPaperSize (rInfo.mpPrinter->GetPaperSize());
    1443           0 :         if( (rInfo.meOrientation == ORIENTATION_LANDSCAPE &&
    1444           0 :               (aPaperSize.Width() < aPaperSize.Height()))
    1445             :            ||
    1446             :             (rInfo.meOrientation == ORIENTATION_PORTRAIT &&
    1447           0 :               (aPaperSize.Width() > aPaperSize.Height()))
    1448             :           )
    1449             :         {
    1450           0 :             maPrintSize = awt::Size(aPaperSize.Height(), aPaperSize.Width());
    1451             :         }
    1452             :         else
    1453             :         {
    1454           0 :             maPrintSize = awt::Size(aPaperSize.Width(), aPaperSize.Height());
    1455             :         }
    1456             : 
    1457           0 :         return true;
    1458             :     }
    1459             : 
    1460             : 
    1461             : 
    1462             :     /** Top most method for preparing printer pages.  In this and the other
    1463             :         Prepare... methods the various special cases are detected and
    1464             :         handled.
    1465             :         For every page that is to be printed (that may contain several
    1466             :         slides) one PrinterPage object is created and inserted into
    1467             :         maPrinterPages.
    1468             :     */
    1469           0 :     void PreparePages()
    1470             :     {
    1471           0 :         mpPrintView.reset();
    1472           0 :         maPrinterPages.clear();
    1473           0 :         mbHasOrientationWarningBeenShown = false;
    1474             : 
    1475           0 :         ViewShell* pShell = mrBase.GetMainViewShell().get();
    1476             : 
    1477           0 :         PrintInfo aInfo (mpPrinter, mpOptions->IsPrintMarkedOnly());
    1478             : 
    1479           0 :         if (aInfo.mpPrinter!=NULL && pShell!=NULL)
    1480             :         {
    1481             : 
    1482           0 :             MapMode aMap (aInfo.mpPrinter->GetMapMode());
    1483           0 :             aMap.SetMapUnit(MAP_100TH_MM);
    1484           0 :             aInfo.maMap = aMap;
    1485           0 :             mpPrinter->SetMapMode(aMap);
    1486             : 
    1487           0 :             ::Outliner& rOutliner = mrBase.GetDocument()->GetDrawOutliner();
    1488           0 :             const sal_uLong nSavedControlWord (rOutliner.GetControlWord());
    1489           0 :             sal_uLong nCntrl = nSavedControlWord;
    1490           0 :             nCntrl &= ~EE_CNTRL_MARKFIELDS;
    1491           0 :             nCntrl &= ~EE_CNTRL_ONLINESPELLING;
    1492           0 :             rOutliner.SetControlWord( nCntrl );
    1493             : 
    1494             :             // When in outline view then apply all pending changes to the model.
    1495           0 :             if (pShell->ISA(OutlineViewShell))
    1496           0 :                 static_cast<OutlineViewShell*>(pShell)->PrepareClose (sal_False, sal_False);
    1497             : 
    1498             :             // Collect some frequently used data.
    1499           0 :             if (mpOptions->IsDate())
    1500             :             {
    1501           0 :                 aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData()->getDate( Date( Date::SYSTEM ) );
    1502           0 :                 aInfo.msTimeDate += ::rtl::OUString((sal_Unicode)' ');
    1503             :             }
    1504             : 
    1505           0 :             if (mpOptions->IsTime())
    1506           0 :                 aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData()->getTime( Time( Time::SYSTEM ), sal_False, sal_False );
    1507           0 :             aInfo.maPrintSize = aInfo.mpPrinter->GetOutputSize();
    1508             :             maPrintSize = awt::Size(
    1509           0 :                 aInfo.mpPrinter->GetPaperSize().Width(),
    1510           0 :                 aInfo.mpPrinter->GetPaperSize().Height());
    1511             : 
    1512           0 :             switch (mpOptions->GetOutputQuality())
    1513             :             {
    1514             :                 case 1:
    1515             :                     aInfo.mnDrawMode = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL
    1516             :                         | DRAWMODE_GRAYTEXT | DRAWMODE_GRAYBITMAP
    1517           0 :                         | DRAWMODE_GRAYGRADIENT;
    1518           0 :                     break;
    1519             : 
    1520             :                 case 2:
    1521             :                     aInfo.mnDrawMode = DRAWMODE_BLACKLINE | DRAWMODE_WHITEFILL
    1522             :                         | DRAWMODE_BLACKTEXT | DRAWMODE_WHITEBITMAP
    1523           0 :                         | DRAWMODE_WHITEGRADIENT;
    1524           0 :                     break;
    1525             : 
    1526             :                 default:
    1527           0 :                     aInfo.mnDrawMode = DRAWMODE_DEFAULT;
    1528             :             }
    1529             : 
    1530           0 :             if (mpOptions->IsDraw())
    1531           0 :                 PrepareStdOrNotes(PK_STANDARD, aInfo);
    1532           0 :             if (mpOptions->IsNotes())
    1533           0 :                 PrepareStdOrNotes(PK_NOTES, aInfo);
    1534           0 :             if (mpOptions->IsHandout())
    1535             :             {
    1536           0 :                 InitHandoutTemplate();
    1537           0 :                 PrepareHandout(aInfo);
    1538             :             }
    1539           0 :             if (mpOptions->IsOutline())
    1540           0 :                 PrepareOutline(aInfo);
    1541             : 
    1542           0 :             rOutliner.SetControlWord(nSavedControlWord);
    1543           0 :         }
    1544           0 :     }
    1545             : 
    1546             : 
    1547             : 
    1548             : 
    1549             :     /** Create the page objects of the handout template.  When the actual
    1550             :         printing takes place then the page objects are assigned different
    1551             :         sets of slides for each printed page (see HandoutPrinterPage::Print).
    1552             :     */
    1553           0 :     void InitHandoutTemplate()
    1554             :     {
    1555           0 :         const sal_Int32 nSlidesPerHandout (mpOptions->GetHandoutPageCount());
    1556           0 :         const bool bHandoutHorizontal (mpOptions->IsHandoutHorizontal());
    1557             : 
    1558           0 :         AutoLayout eLayout = AUTOLAYOUT_HANDOUT6;
    1559           0 :         switch (nSlidesPerHandout)
    1560             :         {
    1561           0 :             case 0: eLayout = AUTOLAYOUT_NONE; break; // AUTOLAYOUT_HANDOUT1; break;
    1562           0 :             case 1: eLayout = AUTOLAYOUT_HANDOUT1; break;
    1563           0 :             case 2: eLayout = AUTOLAYOUT_HANDOUT2; break;
    1564           0 :             case 3: eLayout = AUTOLAYOUT_HANDOUT3; break;
    1565           0 :             case 4: eLayout = AUTOLAYOUT_HANDOUT4; break;
    1566             :             default:
    1567           0 :             case 6: eLayout = AUTOLAYOUT_HANDOUT6; break;
    1568           0 :             case 9: eLayout = AUTOLAYOUT_HANDOUT9; break;
    1569             :         }
    1570             : 
    1571           0 :         if( !mrBase.GetDocument() )
    1572             :             return;
    1573             : 
    1574           0 :         SdDrawDocument& rModel = *mrBase.GetDocument();
    1575             : 
    1576             :         // first, prepare handout page (not handout master)
    1577             : 
    1578           0 :         SdPage* pHandout = rModel.GetSdPage(0, PK_HANDOUT);
    1579           0 :         if( !pHandout )
    1580             :             return;
    1581             : 
    1582             :         // delete all previous shapes from handout page
    1583           0 :         while( pHandout->GetObjCount() )
    1584             :         {
    1585           0 :             SdrObject* pObj = pHandout->NbcRemoveObject(0);
    1586           0 :             if( pObj )
    1587           0 :                 SdrObject::Free( pObj  );
    1588             :         }
    1589             : 
    1590           0 :         const bool bDrawLines (eLayout == AUTOLAYOUT_HANDOUT3);
    1591             : 
    1592           0 :         std::vector< Rectangle > aAreas;
    1593           0 :         SdPage::CalculateHandoutAreas( rModel, eLayout, bHandoutHorizontal, aAreas );
    1594             : 
    1595           0 :         std::vector< Rectangle >::iterator iter( aAreas.begin() );
    1596           0 :         while( iter != aAreas.end() )
    1597             :         {
    1598           0 :             pHandout->NbcInsertObject( new SdrPageObj((*iter++)) );
    1599             : 
    1600           0 :             if( bDrawLines && (iter != aAreas.end())  )
    1601             :             {
    1602           0 :                 Rectangle aRect( (*iter++) );
    1603             : 
    1604           0 :                 basegfx::B2DPolygon aPoly;
    1605           0 :                 aPoly.insert(0, basegfx::B2DPoint( aRect.Left(), aRect.Top() ) );
    1606           0 :                 aPoly.insert(1, basegfx::B2DPoint( aRect.Right(), aRect.Top() ) );
    1607             : 
    1608           0 :                 basegfx::B2DHomMatrix aMatrix;
    1609           0 :                 aMatrix.translate( 0.0, static_cast< double >( aRect.GetHeight() / 7 ) );
    1610             : 
    1611           0 :                 basegfx::B2DPolyPolygon aPathPoly;
    1612           0 :                 for( sal_uInt16 nLine = 0; nLine < 7; nLine++ )
    1613             :                 {
    1614           0 :                     aPoly.transform( aMatrix );
    1615           0 :                     aPathPoly.append( aPoly );
    1616             :                 }
    1617             : 
    1618           0 :                 SdrPathObj* pPathObj = new SdrPathObj(OBJ_PATHLINE, aPathPoly );
    1619           0 :                 pPathObj->SetMergedItem(XLineStyleItem(XLINE_SOLID));
    1620           0 :                 pPathObj->SetMergedItem(XLineColorItem(String(), Color(COL_BLACK)));
    1621             : 
    1622           0 :                 pHandout->NbcInsertObject( pPathObj );
    1623             :             }
    1624           0 :         }
    1625             :     }
    1626             : 
    1627             : 
    1628             : 
    1629             : 
    1630             :     /** Detect whether the specified slide is to be printed.
    1631             :         @return
    1632             :             When the slide is not to be printed then <NULL/> is returned.
    1633             :             Otherwise a pointer to the slide is returned.
    1634             :     */
    1635           0 :     SdPage* GetFilteredPage (
    1636             :         const sal_Int32 nPageIndex,
    1637             :         const PageKind ePageKind) const
    1638             :     {
    1639             :         OSL_ASSERT(mrBase.GetDocument() != NULL);
    1640             :         OSL_ASSERT(nPageIndex>=0);
    1641             :         SdPage* pPage = mrBase.GetDocument()->GetSdPage(
    1642           0 :             sal::static_int_cast<sal_uInt16>(nPageIndex),
    1643           0 :             ePageKind);
    1644           0 :         if (pPage == NULL)
    1645           0 :             return NULL;
    1646           0 :         if ( ! pPage->IsExcluded() || mpOptions->IsPrintExcluded())
    1647           0 :             return pPage;
    1648             :         else
    1649           0 :             return NULL;
    1650             :     }
    1651             : 
    1652             : 
    1653             : 
    1654             : 
    1655             :     /** Prepare the outline of the document for printing.  There is no fixed
    1656             :         number of slides whose outline data is put onto one printer page.
    1657             :         If the current printer page has enough room for the outline of the
    1658             :         current slide then that is added.  Otherwise a new printer page is
    1659             :         started.
    1660             :     */
    1661           0 :     void PrepareOutline (PrintInfo& rInfo)
    1662             :     {
    1663           0 :         MapMode aMap (rInfo.maMap);
    1664           0 :         Point aPageOfs (rInfo.mpPrinter->GetPageOffset() );
    1665           0 :         aMap.SetScaleX(Fraction(1,2));
    1666           0 :         aMap.SetScaleY(Fraction(1,2));
    1667           0 :         mpPrinter->SetMapMode(aMap);
    1668             : 
    1669           0 :         Rectangle aOutRect(aPageOfs, rInfo.mpPrinter->GetOutputSize());
    1670           0 :         if( aOutRect.GetWidth() > aOutRect.GetHeight() )
    1671             :         {
    1672           0 :             Size aPaperSize( rInfo.mpPrinter->PixelToLogic( rInfo.mpPrinter->GetPaperSizePixel(), MapMode( MAP_100TH_MM ) ) );
    1673           0 :             maPrintSize.Width  = aPaperSize.Height();
    1674           0 :             maPrintSize.Height = aPaperSize.Width();
    1675           0 :             aOutRect = Rectangle( Point( aPageOfs.Y(), aPageOfs.X() ),
    1676           0 :                                   Size( aOutRect.GetHeight(), aOutRect.GetWidth() ) );
    1677             :         }
    1678             : 
    1679           0 :         Link aOldLink;
    1680           0 :         Outliner* pOutliner = mrBase.GetDocument()->GetInternalOutliner();
    1681           0 :         pOutliner->Init(OUTLINERMODE_OUTLINEVIEW);
    1682           0 :         const sal_uInt16 nSavedOutlMode (pOutliner->GetMode());
    1683           0 :         const sal_Bool bSavedUpdateMode (pOutliner->GetUpdateMode());
    1684           0 :         const Size aSavedPaperSize (pOutliner->GetPaperSize());
    1685           0 :         const MapMode aSavedMapMode (pOutliner->GetRefMapMode());
    1686           0 :         pOutliner->SetPaperSize(aOutRect.GetSize());
    1687           0 :         pOutliner->SetUpdateMode(sal_True);
    1688             : 
    1689           0 :         long nPageH = aOutRect.GetHeight();
    1690             : 
    1691           0 :         ::std::vector< sal_Int32 > aPages;
    1692           0 :         sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(PK_STANDARD);
    1693             :         StringRangeEnumerator::getRangesFromString(
    1694             :             mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
    1695           0 :             aPages, 0, nPageCount-1);
    1696             : 
    1697           0 :         for (size_t nIndex = 0, nCount = aPages.size(); nIndex < nCount;)
    1698             :         {
    1699           0 :             pOutliner->Clear();
    1700           0 :             pOutliner->SetFirstPageNumber(aPages[nIndex]+1);
    1701             : 
    1702           0 :             Paragraph* pPara = NULL;
    1703           0 :             sal_Int32 nH (0);
    1704           0 :             while (nH < nPageH && nIndex<nCount)
    1705             :             {
    1706           0 :                 SdPage* pPage = GetFilteredPage(aPages[nIndex], PK_STANDARD);
    1707           0 :                 ++nIndex;
    1708           0 :                 if (pPage == NULL)
    1709           0 :                     continue;
    1710             : 
    1711           0 :                 SdrTextObj* pTextObj = NULL;
    1712           0 :                 sal_uInt32 nObj (0);
    1713             : 
    1714           0 :                 while (pTextObj==NULL && nObj < pPage->GetObjCount())
    1715             :                 {
    1716           0 :                     SdrObject* pObj = pPage->GetObj(nObj++);
    1717           0 :                     if (pObj->GetObjInventor() == SdrInventor
    1718           0 :                         && pObj->GetObjIdentifier() == OBJ_TITLETEXT)
    1719             :                     {
    1720           0 :                         pTextObj = dynamic_cast<SdrTextObj*>(pObj);
    1721             :                     }
    1722             :                 }
    1723             : 
    1724           0 :                 pPara = pOutliner->GetParagraph(pOutliner->GetParagraphCount() - 1);
    1725             : 
    1726           0 :                 if (pTextObj!=NULL
    1727           0 :                     && !pTextObj->IsEmptyPresObj()
    1728           0 :                     && pTextObj->GetOutlinerParaObject())
    1729             :                 {
    1730           0 :                     pOutliner->AddText(*(pTextObj->GetOutlinerParaObject()));
    1731             :                 }
    1732             :                 else
    1733           0 :                     pOutliner->Insert(String());
    1734             : 
    1735           0 :                 pTextObj = NULL;
    1736           0 :                 nObj = 0;
    1737             : 
    1738           0 :                 while (pTextObj==NULL && nObj<pPage->GetObjCount())
    1739             :                 {
    1740           0 :                     SdrObject* pObj = pPage->GetObj(nObj++);
    1741           0 :                     if (pObj->GetObjInventor() == SdrInventor
    1742           0 :                         && pObj->GetObjIdentifier() == OBJ_OUTLINETEXT)
    1743             :                     {
    1744           0 :                         pTextObj = dynamic_cast<SdrTextObj*>(pObj);
    1745             :                     }
    1746             :                 }
    1747             : 
    1748           0 :                 bool bSubTitle (false);
    1749           0 :                 if (!pTextObj)
    1750             :                 {
    1751           0 :                     bSubTitle = true;
    1752           0 :                     pTextObj = dynamic_cast<SdrTextObj*>(pPage->GetPresObj(PRESOBJ_TEXT));  // Untertitel vorhanden?
    1753             :                 }
    1754             : 
    1755           0 :                 sal_uLong nParaCount1 = pOutliner->GetParagraphCount();
    1756             : 
    1757           0 :                 if (pTextObj!=NULL
    1758           0 :                     && !pTextObj->IsEmptyPresObj()
    1759           0 :                     && pTextObj->GetOutlinerParaObject())
    1760             :                 {
    1761           0 :                     pOutliner->AddText(*(pTextObj->GetOutlinerParaObject()));
    1762             :                 }
    1763             : 
    1764           0 :                 if (bSubTitle )
    1765             :                 {
    1766           0 :                     const sal_Int32 nParaCount2 (pOutliner->GetParagraphCount());
    1767           0 :                     for (sal_Int32 nPara=nParaCount1; nPara<nParaCount2; ++nPara)
    1768             :                     {
    1769           0 :                         Paragraph* pP = pOutliner->GetParagraph(nPara);
    1770           0 :                         if (pP!=NULL && pOutliner->GetDepth((sal_uInt16)nPara) > 0)
    1771           0 :                             pOutliner->SetDepth(pP, 0);
    1772             :                     }
    1773             :                 }
    1774             : 
    1775           0 :                 nH = pOutliner->GetTextHeight();
    1776             :             }
    1777             : 
    1778             :             // Remove the last paragraph when that does not fit completely on
    1779             :             // the current page.
    1780           0 :             if (nH > nPageH && pPara!=NULL)
    1781             :             {
    1782             :                 sal_uLong nCnt = pOutliner->GetAbsPos(
    1783           0 :                     pOutliner->GetParagraph( pOutliner->GetParagraphCount() - 1 ) );
    1784           0 :                 sal_uLong nParaPos = pOutliner->GetAbsPos( pPara );
    1785           0 :                 nCnt -= nParaPos;
    1786           0 :                 pPara = pOutliner->GetParagraph( ++nParaPos );
    1787           0 :                 if ( nCnt && pPara )
    1788             :                 {
    1789           0 :                     pOutliner->Remove(pPara, nCnt);
    1790           0 :                     --nIndex;
    1791             :                 }
    1792             :             }
    1793             : 
    1794             :             maPrinterPages.push_back(
    1795             :                 ::boost::shared_ptr<PrinterPage>(
    1796             :                     new OutlinerPrinterPage(
    1797           0 :                         pOutliner->CreateParaObject(),
    1798             :                         aMap,
    1799             :                         rInfo.msTimeDate,
    1800             :                         aPageOfs,
    1801             :                         rInfo.mnDrawMode,
    1802             :                         rInfo.meOrientation,
    1803           0 :                         rInfo.mpPrinter->GetPaperBin())));
    1804             :         }
    1805             : 
    1806           0 :         pOutliner->SetRefMapMode(aSavedMapMode);
    1807           0 :         pOutliner->SetUpdateMode(bSavedUpdateMode);
    1808           0 :         pOutliner->SetPaperSize(aSavedPaperSize);
    1809           0 :         pOutliner->Init(nSavedOutlMode);
    1810           0 :     }
    1811             : 
    1812             : 
    1813             : 
    1814             : 
    1815             :     /** Prepare handout pages for slides that are to be printed.
    1816             :     */
    1817           0 :     void PrepareHandout (PrintInfo& rInfo)
    1818             :     {
    1819           0 :         SdDrawDocument* pDocument = mrBase.GetDocument();
    1820             :         OSL_ASSERT(pDocument != NULL);
    1821           0 :         SdPage& rHandoutPage (*pDocument->GetSdPage(0, PK_HANDOUT));
    1822             : 
    1823           0 :         const bool bScalePage (mpOptions->IsPageSize());
    1824             : 
    1825             :         sal_uInt16 nPaperBin;
    1826           0 :         if ( ! mpOptions->IsPaperBin())
    1827           0 :             nPaperBin = rHandoutPage.GetPaperBin();
    1828             :         else
    1829           0 :             nPaperBin = rInfo.mpPrinter->GetPaperBin();
    1830             : 
    1831             :         // Change orientation?
    1832           0 :         SdPage& rMaster (dynamic_cast<SdPage&>(rHandoutPage.TRG_GetMasterPage()));
    1833           0 :         rInfo.meOrientation = rMaster.GetOrientation();
    1834             : 
    1835           0 :         const Size aPaperSize (rInfo.mpPrinter->GetPaperSize());
    1836           0 :         if( (rInfo.meOrientation == ORIENTATION_LANDSCAPE &&
    1837           0 :               (aPaperSize.Width() < aPaperSize.Height()))
    1838             :            ||
    1839             :             (rInfo.meOrientation == ORIENTATION_PORTRAIT &&
    1840           0 :               (aPaperSize.Width() > aPaperSize.Height()))
    1841             :           )
    1842             :         {
    1843           0 :             maPrintSize = awt::Size(aPaperSize.Height(), aPaperSize.Width());
    1844             :         }
    1845             :         else
    1846             :         {
    1847           0 :             maPrintSize = awt::Size(aPaperSize.Width(), aPaperSize.Height());
    1848             :         }
    1849             : 
    1850           0 :         MapMode aMap (rInfo.maMap);
    1851           0 :         const Point aPageOfs (rInfo.mpPrinter->GetPageOffset());
    1852             : 
    1853           0 :         if ( bScalePage )
    1854             :         {
    1855           0 :             const Size aPageSize (rHandoutPage.GetSize());
    1856           0 :             const Size aPrintSize (rInfo.mpPrinter->GetOutputSize());
    1857             : 
    1858           0 :             const double fHorz = (double) aPrintSize.Width()    / aPageSize.Width();
    1859           0 :             const double fVert = (double) aPrintSize.Height() / aPageSize.Height();
    1860             : 
    1861           0 :             Fraction    aFract;
    1862           0 :             if ( fHorz < fVert )
    1863           0 :                 aFract = Fraction(aPrintSize.Width(), aPageSize.Width());
    1864             :             else
    1865           0 :                 aFract = Fraction(aPrintSize.Height(), aPageSize.Height());
    1866             : 
    1867           0 :             aMap.SetScaleX(aFract);
    1868           0 :             aMap.SetScaleY(aFract);
    1869           0 :             aMap.SetOrigin(Point());
    1870             :         }
    1871             : 
    1872           0 :         ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
    1873           0 :         pViewShell->WriteFrameViewData();
    1874             : 
    1875             :         // Count page shapes.
    1876           0 :         sal_uInt32 nShapeCount (0);
    1877           0 :         SdrObjListIter aShapeIter (rHandoutPage);
    1878           0 :         while (aShapeIter.IsMore())
    1879             :         {
    1880           0 :             SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next());
    1881           0 :             if (pPageObj)
    1882           0 :                 ++nShapeCount;
    1883             :         }
    1884             : 
    1885           0 :         const sal_uInt16 nPageCount = mrBase.GetDocument()->GetSdPageCount(PK_STANDARD);
    1886           0 :         const sal_uInt16 nHandoutPageCount = nShapeCount ? (nPageCount + nShapeCount - 1) / nShapeCount : 0;
    1887           0 :         pViewShell->SetPrintedHandoutPageCount( nHandoutPageCount );
    1888           0 :         mrBase.GetDocument()->setHandoutPageCount( nHandoutPageCount );
    1889             : 
    1890             :         // Distribute pages to handout pages.
    1891             :         StringRangeEnumerator aRangeEnum(
    1892             :             mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
    1893           0 :             0, nPageCount-1);
    1894           0 :         ::std::vector<sal_uInt16> aPageIndices;
    1895           0 :         sal_uInt16 nPrinterPageIndex = 0;
    1896           0 :         StringRangeEnumerator::Iterator it = aRangeEnum.begin(), itEnd = aRangeEnum.end();
    1897           0 :         bool bLastLoop = (it == itEnd);
    1898           0 :         while (!bLastLoop)
    1899             :         {
    1900           0 :             sal_Int32 nPageIndex = *it;
    1901           0 :             ++it;
    1902           0 :             bLastLoop = (it == itEnd);
    1903             : 
    1904           0 :             if (GetFilteredPage(nPageIndex, PK_STANDARD))
    1905           0 :                 aPageIndices.push_back(nPageIndex);
    1906           0 :             else if (!bLastLoop)
    1907           0 :                 continue;
    1908             : 
    1909             :             // Create a printer page when we have found one page for each
    1910             :             // placeholder or when this is the last (and special) loop.
    1911           0 :             if (!aPageIndices.empty() && (aPageIndices.size() == nShapeCount || bLastLoop))
    1912             :             {
    1913             :                 maPrinterPages.push_back(
    1914             :                     ::boost::shared_ptr<PrinterPage>(
    1915             :                         new HandoutPrinterPage(
    1916             :                             nPrinterPageIndex++,
    1917             :                             aPageIndices,
    1918             :                             aMap,
    1919             :                             rInfo.msTimeDate,
    1920             :                             aPageOfs,
    1921             :                             rInfo.mnDrawMode,
    1922             :                             rInfo.meOrientation,
    1923           0 :                             nPaperBin)));
    1924           0 :                 aPageIndices.clear();
    1925             :             }
    1926           0 :         }
    1927           0 :     }
    1928             : 
    1929             : 
    1930             : 
    1931             : 
    1932             :     /** Prepare the notes pages or regular slides.
    1933             :     */
    1934           0 :     void PrepareStdOrNotes (
    1935             :         const PageKind ePageKind,
    1936             :         PrintInfo& rInfo)
    1937             :     {
    1938             :         OSL_ASSERT(rInfo.mpPrinter != NULL);
    1939             : 
    1940             :         // Fill in page kind specific data.
    1941           0 :         SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc();
    1942           0 :         if (pDocument->GetSdPageCount(ePageKind) == 0)
    1943             :             return;
    1944           0 :         SdPage* pRefPage = pDocument->GetSdPage(0, ePageKind);
    1945           0 :         rInfo.maPageSize = pRefPage->GetSize();
    1946             : 
    1947           0 :         if ( ! SetupPaperOrientation(ePageKind, rInfo))
    1948             :             return;
    1949             : 
    1950           0 :         MapMode aMap (rInfo.maMap);
    1951           0 :         rInfo.maMap = aMap;
    1952             : 
    1953           0 :         if (mpOptions->IsBooklet())
    1954           0 :             PrepareBooklet(ePageKind, rInfo);
    1955             :         else
    1956           0 :             PrepareRegularPages(ePageKind, rInfo);
    1957             :     }
    1958             : 
    1959             : 
    1960             : 
    1961             : 
    1962             :     /** Prepare slides in a non-booklet way: one slide per one to many
    1963             :         printer pages.
    1964             :     */
    1965           0 :     void PrepareRegularPages (
    1966             :         const PageKind ePageKind,
    1967             :         PrintInfo& rInfo)
    1968             :     {
    1969           0 :         ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
    1970           0 :         pViewShell->WriteFrameViewData();
    1971           0 :         Point aPtZero;
    1972             : 
    1973           0 :         sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(PK_STANDARD);
    1974             :         StringRangeEnumerator aRangeEnum(
    1975             :             mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
    1976           0 :             0, nPageCount-1);
    1977           0 :         for (StringRangeEnumerator::Iterator
    1978           0 :                  it = aRangeEnum.begin(),
    1979           0 :                  itEnd = aRangeEnum.end();
    1980             :              it != itEnd;
    1981             :              ++it)
    1982             :         {
    1983           0 :             SdPage* pPage = GetFilteredPage(*it, ePageKind);
    1984           0 :             if (pPage == NULL)
    1985           0 :                 continue;
    1986             : 
    1987           0 :             MapMode aMap (rInfo.maMap);
    1988             :             // Kann sich die Seitengroesse geaendert haben?
    1989           0 :             const Size aPageSize = pPage->GetSize();
    1990             : 
    1991           0 :             if (mpOptions->IsPageSize())
    1992             :             {
    1993           0 :                 const double fHorz ((double) rInfo.maPrintSize.Width()  / aPageSize.Width());
    1994           0 :                 const double fVert ((double) rInfo.maPrintSize.Height() / aPageSize.Height());
    1995             : 
    1996           0 :                 Fraction aFract;
    1997           0 :                 if (fHorz < fVert)
    1998           0 :                     aFract = Fraction(rInfo.maPrintSize.Width(), aPageSize.Width());
    1999             :                 else
    2000           0 :                     aFract = Fraction(rInfo.maPrintSize.Height(), aPageSize.Height());
    2001             : 
    2002           0 :                 aMap.SetScaleX(aFract);
    2003           0 :                 aMap.SetScaleY(aFract);
    2004           0 :                 aMap.SetOrigin(Point());
    2005             :             }
    2006             : 
    2007           0 :             if (mpOptions->IsPrintPageName())
    2008             :             {
    2009           0 :                 rInfo.msPageString = pPage->GetName();
    2010           0 :                 rInfo.msPageString += rtl::OUString(sal_Unicode(' '));
    2011             :             }
    2012             :             else
    2013           0 :                 rInfo.msPageString = "";
    2014           0 :             rInfo.msPageString += rInfo.msTimeDate;
    2015             : 
    2016           0 :             long aPageWidth   = aPageSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder();
    2017           0 :             long aPageHeight  = aPageSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder();
    2018             :             // Bugfix zu 44530:
    2019             :             // Falls implizit umgestellt wurde (Landscape/Portrait)
    2020             :             // wird dies beim Kacheln, bzw. aufteilen (Poster) beruecksichtigt
    2021           0 :             if( ( rInfo.maPrintSize.Width() > rInfo.maPrintSize.Height()
    2022             :                     && aPageWidth < aPageHeight )
    2023           0 :                 || ( rInfo.maPrintSize.Width() < rInfo.maPrintSize.Height()
    2024             :                     && aPageWidth > aPageHeight ) )
    2025             :             {
    2026           0 :                 const sal_Int32 nTmp (rInfo.maPrintSize.Width());
    2027           0 :                 rInfo.maPrintSize.Width() = rInfo.maPrintSize.Height();
    2028           0 :                 rInfo.maPrintSize.Height() = nTmp;
    2029             :             }
    2030             : 
    2031           0 :             if (mpOptions->IsTilePage()
    2032           0 :                 && aPageWidth < rInfo.maPrintSize.Width()
    2033           0 :                 && aPageHeight < rInfo.maPrintSize.Height())
    2034             :             {
    2035             :                 // Put multiple slides on one printer page.
    2036           0 :                 PrepareTiledPage(*it, *pPage, ePageKind, rInfo);
    2037             :             }
    2038             :             else
    2039             :             {
    2040           0 :                 rInfo.maMap = aMap;
    2041           0 :                 PrepareScaledPage(*it, *pPage, ePageKind, rInfo);
    2042             :             }
    2043           0 :         }
    2044           0 :     }
    2045             : 
    2046             : 
    2047             : 
    2048             : 
    2049             :     /** Put two slides on one printer page.
    2050             :     */
    2051           0 :     void PrepareBooklet (
    2052             :         const PageKind ePageKind,
    2053             :         const PrintInfo& rInfo)
    2054             :     {
    2055           0 :         MapMode aStdMap (rInfo.maMap);
    2056           0 :         Point aOffset;
    2057           0 :         Size aPrintSize_2 (rInfo.maPrintSize);
    2058           0 :         Size aPageSize_2 (rInfo.maPageSize);
    2059             : 
    2060           0 :         if (rInfo.meOrientation == ORIENTATION_LANDSCAPE)
    2061           0 :             aPrintSize_2.Width() >>= 1;
    2062             :         else
    2063           0 :             aPrintSize_2.Height() >>= 1;
    2064             : 
    2065           0 :         const double fPageWH = (double) aPageSize_2.Width() / aPageSize_2.Height();
    2066           0 :         const double fPrintWH = (double) aPrintSize_2.Width() / aPrintSize_2.Height();
    2067             : 
    2068           0 :         if( fPageWH < fPrintWH )
    2069             :         {
    2070           0 :             aPageSize_2.Width() = (long) ( aPrintSize_2.Height() * fPageWH );
    2071           0 :             aPageSize_2.Height()= aPrintSize_2.Height();
    2072             :         }
    2073             :         else
    2074             :         {
    2075           0 :             aPageSize_2.Width() = aPrintSize_2.Width();
    2076           0 :             aPageSize_2.Height() = (long) ( aPrintSize_2.Width() / fPageWH );
    2077             :         }
    2078             : 
    2079           0 :         MapMode aMap (rInfo.maMap);
    2080           0 :         aMap.SetScaleX( Fraction( aPageSize_2.Width(), rInfo.maPageSize.Width() ) );
    2081           0 :         aMap.SetScaleY( Fraction( aPageSize_2.Height(), rInfo.maPageSize.Height() ) );
    2082             : 
    2083             :         // calculate adjusted print size
    2084             :         const Size aAdjustedPrintSize (OutputDevice::LogicToLogic(
    2085             :             rInfo.maPrintSize,
    2086             :             aStdMap,
    2087           0 :             aMap));
    2088             : 
    2089           0 :         if (rInfo.meOrientation == ORIENTATION_LANDSCAPE)
    2090             :         {
    2091           0 :             aOffset.X() = ( ( aAdjustedPrintSize.Width() >> 1 ) - rInfo.maPageSize.Width() ) >> 1;
    2092           0 :             aOffset.Y() = ( aAdjustedPrintSize.Height() - rInfo.maPageSize.Height() ) >> 1;
    2093             :         }
    2094             :         else
    2095             :         {
    2096           0 :             aOffset.X() = ( aAdjustedPrintSize.Width() - rInfo.maPageSize.Width() ) >> 1;
    2097           0 :             aOffset.Y() = ( ( aAdjustedPrintSize.Height() >> 1 ) - rInfo.maPageSize.Height() ) >> 1;
    2098             :         }
    2099             : 
    2100             :         // create vector of pages to print
    2101           0 :         sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(ePageKind);
    2102             :         StringRangeEnumerator aRangeEnum(
    2103             :             mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
    2104           0 :             0, nPageCount-1);
    2105           0 :         ::std::vector< sal_uInt16 > aPageVector;
    2106           0 :         for (StringRangeEnumerator::Iterator
    2107           0 :                  it = aRangeEnum.begin(),
    2108           0 :                  itEnd = aRangeEnum.end();
    2109             :              it != itEnd;
    2110             :              ++it)
    2111             :         {
    2112           0 :             SdPage* pPage = GetFilteredPage(*it, ePageKind);
    2113           0 :             if (pPage != NULL)
    2114           0 :                 aPageVector.push_back(*it);
    2115             :         }
    2116             : 
    2117             :         // create pairs of pages to print on each page
    2118             :         typedef ::std::vector< ::std::pair< sal_uInt16, sal_uInt16 > > PairVector;
    2119           0 :         PairVector aPairVector;
    2120           0 :         if ( ! aPageVector.empty())
    2121             :         {
    2122           0 :             sal_uInt32 nFirstIndex = 0, nLastIndex = aPageVector.size() - 1;
    2123             : 
    2124           0 :             if( aPageVector.size() & 1 )
    2125           0 :                 aPairVector.push_back( ::std::make_pair( (sal_uInt16) 65535, aPageVector[ nFirstIndex++ ] ) );
    2126             :             else
    2127           0 :                 aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) );
    2128             : 
    2129           0 :             while( nFirstIndex < nLastIndex )
    2130             :             {
    2131           0 :                 if( nFirstIndex & 1 )
    2132           0 :                     aPairVector.push_back( ::std::make_pair( aPageVector[ nFirstIndex++ ], aPageVector[ nLastIndex-- ] ) );
    2133             :                 else
    2134           0 :                     aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) );
    2135             :             }
    2136             :         }
    2137             : 
    2138           0 :         for (sal_uInt32
    2139           0 :                  nIndex=0,
    2140           0 :                  nCount=aPairVector.size();
    2141             :              nIndex < nCount;
    2142             :              ++nIndex)
    2143             :         {
    2144           0 :             const bool bIsIndexOdd (nIndex & 1);
    2145           0 :             if ((!bIsIndexOdd && mpOptions->IsPrintFrontPage())
    2146           0 :                 || (bIsIndexOdd && mpOptions->IsPrintBackPage()))
    2147             :             {
    2148           0 :                 const ::std::pair<sal_uInt16, sal_uInt16> aPair (aPairVector[nIndex]);
    2149           0 :                 Point aSecondOffset (aOffset);
    2150           0 :                 if (rInfo.meOrientation == ORIENTATION_LANDSCAPE)
    2151           0 :                     aSecondOffset.X() += aAdjustedPrintSize.Width() / 2;
    2152             :                 else
    2153           0 :                     aSecondOffset.Y() += aAdjustedPrintSize.Height() / 2;
    2154             :                 maPrinterPages.push_back(
    2155             :                     ::boost::shared_ptr<PrinterPage>(
    2156             :                         new BookletPrinterPage(
    2157             :                             aPair.first,
    2158             :                             aPair.second,
    2159             :                             aOffset,
    2160             :                             aSecondOffset,
    2161             :                             ePageKind,
    2162             :                             aMap,
    2163             :                             rInfo.mbPrintMarkedOnly,
    2164             :                             rInfo.mnDrawMode,
    2165             :                             rInfo.meOrientation,
    2166           0 :                             rInfo.mpPrinter->GetPaperBin())));
    2167             : 
    2168             :             }
    2169           0 :         }
    2170           0 :     }
    2171             : 
    2172             : 
    2173             : 
    2174             : 
    2175             :     /** Print one slide multiple times on one printer page so that the whole
    2176             :         printer page is covered.
    2177             :     */
    2178           0 :     void PrepareTiledPage (
    2179             :         const sal_Int32 nPageIndex,
    2180             :         const SdPage& rPage,
    2181             :         const PageKind ePageKind,
    2182             :         const PrintInfo& rInfo)
    2183             :     {
    2184             :         sal_uInt16 nPaperBin;
    2185           0 :         if ( ! mpOptions->IsPaperBin())
    2186           0 :             nPaperBin = rPage.GetPaperBin();
    2187             :         else
    2188           0 :             nPaperBin = rInfo.mpPrinter->GetPaperBin();
    2189             : 
    2190             :         maPrinterPages.push_back(
    2191             :             ::boost::shared_ptr<PrinterPage>(
    2192             :                 new TiledPrinterPage(
    2193           0 :                     sal::static_int_cast<sal_uInt16>(nPageIndex),
    2194             :                     ePageKind,
    2195             :                     500,
    2196             :                     rInfo.mbPrintMarkedOnly,
    2197             :                     rInfo.msPageString,
    2198           0 :                     rInfo.mpPrinter->GetPageOffset(),
    2199             :                     rInfo.mnDrawMode,
    2200             :                     rInfo.meOrientation,
    2201           0 :                     nPaperBin)));
    2202           0 :     }
    2203             : 
    2204             : 
    2205             : 
    2206             :     /** Print one standard slide or notes page on one to many printer
    2207             :         pages.  More than on printer page is used when the slide is larger
    2208             :         than the printable area.
    2209             :     */
    2210           0 :     void PrepareScaledPage (
    2211             :         const sal_Int32 nPageIndex,
    2212             :         const SdPage& rPage,
    2213             :         const PageKind ePageKind,
    2214             :         const PrintInfo& rInfo)
    2215             :     {
    2216           0 :         const Point aPageOffset (rInfo.mpPrinter->GetPageOffset());
    2217             : 
    2218             :         sal_uInt16 nPaperBin;
    2219           0 :         if ( ! mpOptions->IsPaperBin())
    2220           0 :             nPaperBin = rPage.GetPaperBin();
    2221             :         else
    2222           0 :             nPaperBin = rInfo.mpPrinter->GetPaperBin();
    2223             : 
    2224             :         // For pages larger then the printable area there
    2225             :         // are three options:
    2226             :         // 1. Scale down to the page to the printable area.
    2227             :         // 2. Print only the upper left part of the page
    2228             :         //    (without the unprintable borders).
    2229             :         // 3. Split the page into parts of the size of the
    2230             :         // printable area.
    2231           0 :         const bool bScalePage (mpOptions->IsPageSize());
    2232           0 :         const bool bCutPage (mpOptions->IsCutPage());
    2233           0 :         MapMode aMap (rInfo.maMap);
    2234           0 :         if (bScalePage || bCutPage)
    2235             :         {
    2236             :             // Handle 1 and 2.
    2237             : 
    2238             :             // if CutPage is set then do not move it, otherwise move the
    2239             :             // scaled page to printable area
    2240             :             maPrinterPages.push_back(
    2241             :                 ::boost::shared_ptr<PrinterPage>(
    2242             :                     new RegularPrinterPage(
    2243           0 :                         sal::static_int_cast<sal_uInt16>(nPageIndex),
    2244             :                         ePageKind,
    2245             :                         aMap,
    2246             :                         rInfo.mbPrintMarkedOnly,
    2247             :                         rInfo.msPageString,
    2248             :                         aPageOffset,
    2249             :                         rInfo.mnDrawMode,
    2250             :                         rInfo.meOrientation,
    2251           0 :                         nPaperBin)));
    2252             :         }
    2253             :         else
    2254             :         {
    2255             :             // Handle 3.  Print parts of the page in the size of the
    2256             :             // printable area until the whole page is covered.
    2257             : 
    2258             :             // keep the page content at its position if it fits, otherwise
    2259             :             // move it to the printable area
    2260             :             const long nPageWidth (
    2261           0 :                 rInfo.maPageSize.Width() - rPage.GetLftBorder() - rPage.GetRgtBorder());
    2262             :             const long nPageHeight (
    2263           0 :                 rInfo.maPageSize.Height() - rPage.GetUppBorder() - rPage.GetLwrBorder());
    2264             : 
    2265           0 :             Point aOrigin ( 0, 0 );
    2266             : 
    2267           0 :             for (Point aPageOrigin = aOrigin;
    2268           0 :                  -aPageOrigin.Y()<nPageHeight;
    2269           0 :                  aPageOrigin.Y() -= rInfo.maPrintSize.Height())
    2270             :             {
    2271           0 :                 for (aPageOrigin.X()=aOrigin.X();
    2272           0 :                      -aPageOrigin.X()<nPageWidth;
    2273           0 :                      aPageOrigin.X() -= rInfo.maPrintSize.Width())
    2274             :                 {
    2275           0 :                     aMap.SetOrigin(aPageOrigin);
    2276             :                     maPrinterPages.push_back(
    2277             :                         ::boost::shared_ptr<PrinterPage>(
    2278             :                             new RegularPrinterPage(
    2279           0 :                                 sal::static_int_cast<sal_uInt16>(nPageIndex),
    2280             :                                 ePageKind,
    2281             :                                 aMap,
    2282             :                                 rInfo.mbPrintMarkedOnly,
    2283             :                                 rInfo.msPageString,
    2284             :                                 aPageOffset,
    2285             :                                 rInfo.mnDrawMode,
    2286             :                                 rInfo.meOrientation,
    2287           0 :                                 nPaperBin)));
    2288             :                 }
    2289             :             }
    2290           0 :         }
    2291           0 :     }
    2292             : };
    2293             : 
    2294             : 
    2295             : 
    2296             : 
    2297             : //===== DocumentRenderer ======================================================
    2298             : 
    2299           0 : DocumentRenderer::DocumentRenderer (ViewShellBase& rBase)
    2300             :     : DocumentRendererInterfaceBase(m_aMutex),
    2301           0 :       mpImpl(new Implementation(rBase))
    2302             : {
    2303           0 : }
    2304             : 
    2305             : 
    2306             : 
    2307             : 
    2308           0 : DocumentRenderer::~DocumentRenderer()
    2309             : {
    2310           0 : }
    2311             : 
    2312             : 
    2313             : 
    2314             : 
    2315             : //----- XRenderable -----------------------------------------------------------
    2316             : 
    2317           0 : sal_Int32 SAL_CALL DocumentRenderer::getRendererCount (
    2318             :     const css::uno::Any& aSelection,
    2319             :     const css::uno::Sequence<css::beans::PropertyValue >& rOptions)
    2320             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException)
    2321             : {
    2322             :     (void)aSelection;
    2323           0 :     mpImpl->ProcessProperties(rOptions);
    2324           0 :     return mpImpl->GetPrintPageCount();
    2325             : }
    2326             : 
    2327             : 
    2328             : 
    2329             : 
    2330           0 : Sequence<beans::PropertyValue> SAL_CALL DocumentRenderer::getRenderer (
    2331             :     sal_Int32 nRenderer,
    2332             :     const css::uno::Any& rSelection,
    2333             :     const css::uno::Sequence<css::beans::PropertyValue>& rOptions)
    2334             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException)
    2335             : {
    2336             :     (void)nRenderer;
    2337             :     (void)rSelection;
    2338           0 :     mpImpl->ProcessProperties(rOptions);
    2339           0 :     return mpImpl->GetProperties(rOptions);
    2340             : }
    2341             : 
    2342             : 
    2343             : 
    2344             : 
    2345           0 : void SAL_CALL DocumentRenderer::render (
    2346             :     sal_Int32 nRenderer,
    2347             :     const css::uno::Any& rSelection,
    2348             :     const css::uno::Sequence<css::beans::PropertyValue>& rOptions)
    2349             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException)
    2350             : {
    2351             :     (void)rSelection;
    2352           0 :     mpImpl->ProcessProperties(rOptions);
    2353           0 :     mpImpl->PrintPage(nRenderer);
    2354           0 : }
    2355             : 
    2356             : 
    2357             : 
    2358           9 : } // end of namespace sd
    2359             : 
    2360             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10