?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#154285 Check upper bound of arguments in SbRtl_Minute function
[LibreOffice.git] / sd / source / ui / view / DocumentRenderer.cxx
blob2b666dbc2b896a079c8a29ad3b6568c44d9f3f9d
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <com/sun/star/beans/XPropertySet.hpp>
21
22 #include <DocumentRenderer.hxx>
23 #include <DocumentRenderer.hrc>
24 #include <ViewShellBase.hxx>
25
26 #include <drawdoc.hxx>
27 #include <sdpage.hxx>
28 #include <sdresid.hxx>
29 #include <strings.hrc>
30 #include <drawview.hxx>
31 #include <DrawViewShell.hxx>
32 #include <FrameView.hxx>
33 #include <Outliner.hxx>
34 #include <OutlineViewShell.hxx>
35 #include <SlideSorterViewShell.hxx>
36 #include <DrawDocShell.hxx>
37
38 #include <tools/multisel.hxx>
39 #include <basegfx/polygon/b2dpolygon.hxx>
40 #include <basegfx/polygon/b2dpolypolygon.hxx>
41 #include <basegfx/matrix/b2dhommatrix.hxx>
42 #include <comphelper/propertyvalue.hxx>
43 #include <comphelper/sequence.hxx>
44 #include <rtl/ustrbuf.hxx>
45 #include <editeng/editstat.hxx>
46 #include <editeng/eeitem.hxx>
47 #include <editeng/outlobj.hxx>
48 #include <editeng/ulspitem.hxx>
49 #include <svx/sdtfsitm.hxx>
50 #include <svx/sdooitm.hxx>
51 #include <svx/svdetc.hxx>
52 #include <svx/svditer.hxx>
53 #include <svx/svdopage.hxx>
54 #include <svx/svdopath.hxx>
55 #include <svx/svdpagv.hxx>
56 #include <svx/xlineit0.hxx>
57 #include <svx/xlnclit.hxx>
58 #include <toolkit/awt/vclxdevice.hxx>
59 #include <unotools/localedatawrapper.hxx>
60 #include <utility>
61 #include <vcl/print.hxx>
62 #include <vcl/svapp.hxx>
63 #include <vcl/weld.hxx>
64 #include <unotools/moduleoptions.hxx>
65 #include <xmloff/autolayout.hxx>
66 #include <sfx2/objsh.hxx>
67
68 #include <officecfg/Office/Draw.hxx>
69 #include <officecfg/Office/Impress.hxx>
70
71 #include <algorithm>
72 #include <memory>
73 #include <vector>
74
75 using namespace ::com::sun::star;
76 using namespace ::com::sun::star::uno;
77
78 namespace sd {
79
80 namespace {
81
82 void lcl_AdjustPageSize(Size& rPageSize, const Size& rPrintPageSize)
83 {
84 bool bOrientationDiff = (rPageSize.Width() < rPageSize.Height()
85 && rPrintPageSize.Width() > rPrintPageSize.Height())
86 || (rPageSize.Width() > rPageSize.Height()
87 && rPrintPageSize.Width() < rPrintPageSize.Height());
88 if (bOrientationDiff)
89 {
90 ::tools::Long nTmp = rPageSize.Width();
91 rPageSize.setWidth(rPageSize.Height());
92 rPageSize.setHeight(nTmp);
93 }
94 }
95
96 /** Convenience class to extract values from the sequence of properties
97 given to one of the XRenderable methods.
98 */
99 class PrintOptions
100 {
101 public:
102 PrintOptions (
103 const vcl::PrinterOptionsHelper& rHelper,
104 std::vector<sal_Int32>&& rSlidesPerPage)
105 : mrProperties(rHelper),
106 maSlidesPerPage(std::move(rSlidesPerPage))
107 {
108 }
109
110 bool IsWarningOrientation() const
111 {
112 return GetBoolValue(nullptr, true);
113 }
114
115 bool IsPrintPageName() const
116 {
117 return GetBoolValue("IsPrintName", false);
118 }
119
120 bool IsDate() const
121 {
122 return GetBoolValue("IsPrintDateTime", false);
123 }
124
125 bool IsTime() const
126 {
127 return GetBoolValue("IsPrintDateTime", false);
128 }
129
130 bool IsHiddenPages() const
131 {
132 return GetBoolValue("IsPrintHidden", false);
133 }
134
135 bool IsHandoutHorizontal() const
136 {
137 return GetBoolValue("SlidesPerPageOrder", sal_Int32(0));
138 }
139
140 sal_Int32 GetHandoutPageCount() const
141 {
142 sal_uInt32 nIndex = static_cast<sal_Int32>(mrProperties.getIntValue("SlidesPerPage", sal_Int32(0)));
143 if (nIndex<maSlidesPerPage.size())
144 return maSlidesPerPage[nIndex];
145 else if ( ! maSlidesPerPage.empty())
146 return maSlidesPerPage[0];
147 else
148 return 0;
149 }
150
151 bool IsDraw() const
152 {
153 return GetBoolValue("PageContentType", sal_Int32(0));
154 }
155
156 bool IsHandout() const
157 {
158 return GetBoolValue("PageContentType", sal_Int32(1));
159 }
160
161 bool IsNotes() const
162 {
163 return GetBoolValue("PageContentType", sal_Int32(2));
164 }
165
166 bool IsOutline() const
167 {
168 return GetBoolValue("PageContentType", sal_Int32(3));
169 }
170
171 sal_uLong GetOutputQuality() const
172 {
173 sal_Int32 nQuality = static_cast<sal_Int32>(mrProperties.getIntValue( "Quality", sal_Int32(0) ));
174 return nQuality;
175 }
176
177 bool IsPageSize() const
178 {
179 return GetBoolValue("PageOptions", sal_Int32(1));
180 }
181
182 bool IsTilePage() const
183 {
184 return GetBoolValue("PageOptions", sal_Int32(2)) || GetBoolValue("PageOptions", sal_Int32(3));
185 }
186
187 bool IsCutPage() const
188 {
189 return GetBoolValue("PageOptions", sal_Int32(0));
190 }
191
192 bool IsBooklet() const
193 {
194 return GetBoolValue("PrintProspect", false);
195 }
196
197 bool IsPrinterPreferred(DocumentType eDocType) const
198 {
199 bool bIsDraw = eDocType == DocumentType::Draw;
200 return IsTilePage() || IsPageSize() || IsBooklet() || (!bIsDraw && !IsNotes());
201 }
202
203 bool IsPrintExcluded() const
204 {
205 return (IsNotes() || IsDraw() || IsHandout()) && IsHiddenPages();
206 }
207
208 bool IsPrintFrontPage() const
209 {
210 sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "EvenOdd", 0 ));
211 return nInclude != 2;
212 }
213
214 bool IsPrintBackPage() const
215 {
216 sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "EvenOdd", 0 ));
217 return nInclude != 1;
218 }
219
220 bool IsPaperBin() const
221 {
222 return GetBoolValue("PrintPaperFromSetup", false);
223 }
224
225 bool IsPrintMarkedOnly() const
226 {
227 return GetBoolValue("PrintContent", sal_Int32(4));
228 }
229
230 OUString GetPrinterSelection (sal_Int32 nPageCount, sal_Int32 nCurrentPageIndex) const
231 {
232 sal_Int32 nContent = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintContent", 0 ));
233 OUString sFullRange = "1-" + OUString::number(nPageCount);
234
235 if (nContent == 0) // all pages/slides
236 {
237 return sFullRange;
238 }
239
240 if (nContent == 1) // range
241 {
242 OUString sValue = mrProperties.getStringValue("PageRange");
243 return sValue.isEmpty() ? sFullRange : sValue;
244 }
245
246 if (nContent == 2 && // selection
247 nCurrentPageIndex >= 0)
248 {
249 return OUString::number(nCurrentPageIndex + 1);
250 }
251
252 return OUString();
253 }
254
255 private:
256 const vcl::PrinterOptionsHelper& mrProperties;
257 const std::vector<sal_Int32> maSlidesPerPage;
258
259 /** When the value of the property with name pName is a boolean then
260 return its value. When the property is unknown then
261 bDefaultValue is returned. Otherwise <FALSE/> is returned.
262 */
263 bool GetBoolValue (
264 const char* pName,
265 const bool bDefaultValue) const
266 {
267 bool bValue = mrProperties.getBoolValue( pName, bDefaultValue );
268 return bValue;
269 }
270
271 /** Return <TRUE/> when the value of the property with name pName is
272 an integer and its value is nTriggerValue. Otherwise <FALSE/> is
273 returned.
274 */
275 bool GetBoolValue (
276 const char* pName,
277 const sal_Int32 nTriggerValue) const
278 {
279 sal_Int32 nValue = static_cast<sal_Int32>(mrProperties.getIntValue( pName, 0 ));
280 return nValue == nTriggerValue;
281 }
282 };
283
284 /** A collection of values that helps to reduce the number of arguments
285 given to some functions. Note that not all values are set at the
286 same time.
287 */
288 class PrintInfo
289 {
290 public:
291 PrintInfo (
292 Printer* pPrinter,
293 const bool bPrintMarkedOnly)
294 : mpPrinter(pPrinter),
295 mnDrawMode(DrawModeFlags::Default),
296 maPrintSize(0,0),
297 maPageSize(0,0),
298 meOrientation(Orientation::Portrait),
299 mbPrintMarkedOnly(bPrintMarkedOnly)
300 {}
301
302 const VclPtr<Printer> mpPrinter;
303 DrawModeFlags mnDrawMode;
304 OUString msTimeDate;
305 OUString msPageString;
306 Size maPrintSize;
307 Size maPageSize;
308 Orientation meOrientation;
309 MapMode maMap;
310 const bool mbPrintMarkedOnly;
311 };
312
313 /** Output one page of the document to the given printer. Note that
314 more than one document page may be output to one printer page.
315 */
316 void PrintPage (
317 Printer& rPrinter,
318 ::sd::View& rPrintView,
319 SdPage& rPage,
320 View const * pView,
321 const bool bPrintMarkedOnly,
322 const SdrLayerIDSet& rVisibleLayers,
323 const SdrLayerIDSet& rPrintableLayers)
324 {
325 rPrintView.ShowSdrPage(&rPage);
326
327 const MapMode aOriginalMapMode (rPrinter.GetMapMode());
328
329 // Set the visible layers
330 SdrPageView* pPageView = rPrintView.GetSdrPageView();
331 OSL_ASSERT(pPageView!=nullptr);
332 pPageView->SetVisibleLayers(rVisibleLayers);
333 pPageView->SetPrintableLayers(rPrintableLayers);
334
335 if (pView!=nullptr && bPrintMarkedOnly)
336 pView->DrawMarkedObj(rPrinter);
337 else
338 rPrintView.CompleteRedraw(&rPrinter,
339 vcl::Region(::tools::Rectangle(Point(0,0), rPage.GetSize())));
340
341 rPrinter.SetMapMode(aOriginalMapMode);
342
343 rPrintView.HideSdrPage();
344 }
345
346 /** Output a string (that typically is not part of a document page) to
347 the given printer.
348 */
349 void PrintMessage (
350 Printer& rPrinter,
351 const OUString& rsPageString,
352 const Point& rPageStringOffset)
353 {
354 const vcl::Font aOriginalFont (rPrinter.OutputDevice::GetFont());
355 rPrinter.SetFont(vcl::Font(FAMILY_SWISS, Size(0, 423)));
356 rPrinter.DrawText(rPageStringOffset, rsPageString);
357 rPrinter.SetFont(aOriginalFont);
358 }
359
360 /** Read the resources and process then into a sequence of properties
361 that can be passed to the printing dialog.
362 */
363 class DialogCreator
364 {
365 public:
366 DialogCreator (ViewShellBase &rBase, bool bImpress, sal_Int32 nCurPage)
367 : mrBase(rBase)
368 , mbImpress(bImpress)
369 , mnCurPage(nCurPage)
370 {
371 ProcessResource();
372 }
373
374 const std::vector< beans::PropertyValue >& GetDialogControls() const
375 {
376 return maProperties;
377 }
378
379 const std::vector<sal_Int32>& GetSlidesPerPage() const
380 {
381 return maSlidesPerPage;
382 }
383
384 private:
385 ViewShellBase &mrBase;
386 std::vector<beans::PropertyValue> maProperties;
387 std::vector<sal_Int32> maSlidesPerPage;
388 bool mbImpress;
389 sal_Int32 mnCurPage;
390
391 void ProcessResource()
392 {
393 // load the writer PrinterOptions into the custom tab
394 beans::PropertyValue aOptionsUIFile;
395 aOptionsUIFile.Name = "OptionsUIFile";
396 if( mbImpress )
397 aOptionsUIFile.Value <<= u"modules/simpress/ui/impressprinteroptions.ui"_ustr;
398 else
399 aOptionsUIFile.Value <<= u"modules/sdraw/ui/drawprinteroptions.ui"_ustr;
400 maProperties.push_back(aOptionsUIFile);
401
402 SvtModuleOptions aOpt;
403 OUString aAppGroupname(SdResId(STR_IMPRESS_PRINT_UI_GROUP_NAME));
404 aAppGroupname = aAppGroupname.replaceFirst("%s", aOpt.GetModuleName(
405 mbImpress ? SvtModuleOptions::EModule::IMPRESS : SvtModuleOptions::EModule::DRAW));
406 AddDialogControl(vcl::PrinterOptionsHelper::setGroupControlOpt(u"tabcontrol-page2"_ustr, aAppGroupname, u".HelpID:vcl:PrintDialog:TabPage:AppPage"_ustr));
407
408 uno::Sequence< OUString > aHelpIds, aWidgetIds;
409 if( mbImpress )
410 {
411 aHelpIds = { u".HelpID:vcl:PrintDialog:PageContentType:ListBox"_ustr };
412 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
413 u"impressdocument"_ustr,
414 SdResId(STR_IMPRESS_PRINT_UI_CONTENT),
415 aHelpIds,
416 u"PageContentType"_ustr ,
417 CreateChoice(STR_IMPRESS_PRINT_UI_CONTENT_CHOICES, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_CONTENT_CHOICES)),
418 0)
419 );
420
421 aHelpIds = { u".HelpID:vcl:PrintDialog:SlidesPerPage:ListBox"_ustr };
422 vcl::PrinterOptionsHelper::UIControlOptions aContentOpt( u"PageContentType"_ustr , 1 );
423 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
424 u"slidesperpage"_ustr,
425 SdResId(STR_IMPRESS_PRINT_UI_SLIDESPERPAGE),
426 aHelpIds,
427 u"SlidesPerPage"_ustr ,
428 GetSlidesPerPageSequence(),
429 0,
430 Sequence< sal_Bool >(),
431 aContentOpt
432 )
433 );
434
435 aHelpIds = { u".HelpID:vcl:PrintDialog:SlidesPerPageOrder:ListBox"_ustr };
436 vcl::PrinterOptionsHelper::UIControlOptions aSlidesPerPageOpt( u"SlidesPerPage"_ustr , -1, true );
437 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
438 u"slidesperpageorder"_ustr,
439 SdResId(STR_IMPRESS_PRINT_UI_ORDER),
440 aHelpIds,
441 u"SlidesPerPageOrder"_ustr ,
442 CreateChoice(STR_IMPRESS_PRINT_UI_ORDER_CHOICES, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_ORDER_CHOICES)),
443 0,
444 Sequence< sal_Bool >(),
445 aSlidesPerPageOpt )
446 );
447 }
448
449 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt(u"contents"_ustr,
450 SdResId(STR_IMPRESS_PRINT_UI_INCLUDE_CONTENT), u""_ustr ) );
451
452 if( mbImpress )
453 {
454 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"printname"_ustr,
455 SdResId(STR_IMPRESS_PRINT_UI_IS_PRINT_NAME),
456 u".HelpID:vcl:PrintDialog:IsPrintName:CheckBox"_ustr ,
457 u"IsPrintName"_ustr ,
458 officecfg::Office::Impress::Print::Other::PageName::get()
459 )
460 );
461 }
462 else
463 {
464 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"printname"_ustr,
465 SdResId(STR_DRAW_PRINT_UI_IS_PRINT_NAME),
466 u".HelpID:vcl:PrintDialog:IsPrintName:CheckBox"_ustr ,
467 u"IsPrintName"_ustr ,
468 officecfg::Office::Draw::Print::Other::PageName::get()
469 )
470 );
471 }
472
473 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"printdatetime"_ustr,
474 SdResId(STR_IMPRESS_PRINT_UI_IS_PRINT_DATE),
475 u".HelpID:vcl:PrintDialog:IsPrintDateTime:CheckBox"_ustr ,
476 u"IsPrintDateTime"_ustr ,
477 // Separate settings for time and date in Impress/Draw -> Print page, check that both are set
478 mbImpress ?
479 officecfg::Office::Impress::Print::Other::Date::get() &&
480 officecfg::Office::Impress::Print::Other::Time::get() :
481 officecfg::Office::Draw::Print::Other::Date::get() &&
482 officecfg::Office::Draw::Print::Other::Time::get()
483 )
484 );
485
486 if( mbImpress )
487 {
488 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"printhidden"_ustr,
489 SdResId(STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN),
490 u".HelpID:vcl:PrintDialog:IsPrintHidden:CheckBox"_ustr ,
491 u"IsPrintHidden"_ustr ,
492 officecfg::Office::Impress::Print::Other::HiddenPage::get()
493 )
494 );
495 }
496
497 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt(u"color"_ustr,
498 SdResId(STR_IMPRESS_PRINT_UI_QUALITY), u""_ustr ) );
499
500 aHelpIds = { u".HelpID:vcl:PrintDialog:Quality:RadioButton:0"_ustr,
501 u".HelpID:vcl:PrintDialog:Quality:RadioButton:1"_ustr,
502 u".HelpID:vcl:PrintDialog:Quality:RadioButton:2"_ustr };
503 aWidgetIds = { u"originalcolors"_ustr, u"grayscale"_ustr, u"blackandwhite"_ustr };
504 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(
505 aWidgetIds,
506 u""_ustr,
507 aHelpIds,
508 u"Quality"_ustr ,
509 CreateChoice(STR_IMPRESS_PRINT_UI_QUALITY_CHOICES, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_QUALITY_CHOICES)),
510 mbImpress ? officecfg::Office::Impress::Print::Other::Quality::get() :
511 officecfg::Office::Draw::Print::Other::Quality::get() )
512
513 );
514
515 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt(u"pagesizes"_ustr,
516 SdResId(STR_IMPRESS_PRINT_UI_PAGE_OPTIONS), u""_ustr ) );
517
518 aHelpIds = { u".HelpID:vcl:PrintDialog:PageOptions:RadioButton:0"_ustr,
519 u".HelpID:vcl:PrintDialog:PageOptions:RadioButton:1"_ustr,
520 u".HelpID:vcl:PrintDialog:PageOptions:RadioButton:2"_ustr,
521 u".HelpID:vcl:PrintDialog:PageOptions:RadioButton:3"_ustr };
522 aWidgetIds = { u"originalsize"_ustr, u"fittoprintable"_ustr, u"distributeonmultiple"_ustr, u"tilesheet"_ustr };
523
524 // Mutually exclusive page options settings are stored in separate config keys...
525 // TODO: There is no config key to set the distributeonmultiple option as default
526 sal_Int32 nDefaultChoice = 0;
527 if ( mbImpress ? officecfg::Office::Impress::Print::Page::PageSize::get() :
528 officecfg::Office::Draw::Print::Page::PageSize::get() )
529 {
530 nDefaultChoice = 1;
531 }
532 else if ( mbImpress ? officecfg::Office::Impress::Print::Page::PageTile::get() :
533 officecfg::Office::Draw::Print::Page::PageTile::get() )
534 {
535 nDefaultChoice = 3;
536 }
537 vcl::PrinterOptionsHelper::UIControlOptions aPageOptionsOpt(u"PrintProspect"_ustr, 0);
538 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(
539 aWidgetIds,
540 u""_ustr,
541 aHelpIds,
542 u"PageOptions"_ustr ,
543 mbImpress ? CreateChoice(STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES)) :
544 CreateChoice(STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW)),
545 nDefaultChoice,
546 Sequence< sal_Bool >(),
547 aPageOptionsOpt
548 )
549 );
550
551 vcl::PrinterOptionsHelper::UIControlOptions aBrochureOpt;
552 aBrochureOpt.maGroupHint = "LayoutPage" ;
553 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt(u"pagesides"_ustr,
554 SdResId(STR_IMPRESS_PRINT_UI_PAGE_SIDES), u""_ustr,
555 aBrochureOpt ) );
556
557 // brochure printing
558 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"brochure"_ustr,
559 SdResId(STR_IMPRESS_PRINT_UI_BROCHURE),
560 u".HelpID:vcl:PrintDialog:PrintProspect:CheckBox"_ustr ,
561 u"PrintProspect"_ustr ,
562 mbImpress ? officecfg::Office::Impress::Print::Page::Booklet::get() :
563 officecfg::Office::Draw::Print::Page::Booklet::get(),
564 aBrochureOpt
565 )
566 );
567
568 vcl::PrinterOptionsHelper::UIControlOptions
569 aIncludeOpt( u"PrintProspect"_ustr , -1, false );
570 aIncludeOpt.maGroupHint = "LayoutPage" ;
571 aHelpIds = { u".HelpID:vcl:PrintDialog:PrintProspectInclude:ListBox"_ustr };
572 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt(
573 u"brochureinclude"_ustr,
574 SdResId(STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE),
575 aHelpIds,
576 u"PrintProspectInclude"_ustr ,
577 CreateChoice(STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST)),
578 0,
579 Sequence< sal_Bool >(),
580 aIncludeOpt
581 )
582 );
583
584 // paper tray (on options page)
585 vcl::PrinterOptionsHelper::UIControlOptions aPaperTrayOpt;
586 aPaperTrayOpt.maGroupHint = "OptionsPageOptGroup" ;
587 AddDialogControl( vcl::PrinterOptionsHelper::setBoolControlOpt(u"printpaperfromsetup"_ustr,
588 SdResId(STR_IMPRESS_PRINT_UI_PAPER_TRAY),
589 u".HelpID:vcl:PrintDialog:PrintPaperFromSetup:CheckBox"_ustr ,
590 u"PrintPaperFromSetup"_ustr ,
591 false,
592 aPaperTrayOpt
593 )
594 );
595 // print range selection
596 vcl::PrinterOptionsHelper::UIControlOptions aPrintRangeOpt;
597 aPrintRangeOpt.mbInternalOnly = true;
598 aPrintRangeOpt.maGroupHint = "PrintRange" ;
599 AddDialogControl( vcl::PrinterOptionsHelper::setSubgroupControlOpt(u"printrange"_ustr,
600 mbImpress ? SdResId(STR_IMPRESS_PRINT_UI_SLIDE_RANGE) : SdResId(STR_IMPRESS_PRINT_UI_PAGE_RANGE),
601 u""_ustr,
602 aPrintRangeOpt )
603 );
604
605 // check if there is a selection of slides
606 OUString aPageRange(OUString::number(mnCurPage + 1));
607 int nPrintRange(0);
608 using sd::slidesorter::SlideSorterViewShell;
609 SlideSorterViewShell* const pSSViewSh(SlideSorterViewShell::GetSlideSorter(mrBase));
610 if (pSSViewSh)
611 {
612 const std::shared_ptr<SlideSorterViewShell::PageSelection> pPageSelection(pSSViewSh->GetPageSelection());
613 if (bool(pPageSelection) && pPageSelection->size() > 1)
614 {
615 OUStringBuffer aBuf;
616 // TODO: this could be improved by writing ranges instead of consecutive page
617 // numbers if appropriate. Do we have a helper function for that somewhere?
618 bool bFirst(true);
619 for (auto pPage: *pPageSelection)
620 {
621 if (bFirst)
622 bFirst = false;
623 else
624 aBuf.append(',');
625 aBuf.append(static_cast<sal_Int32>(pPage->GetPageNum() / 2 + 1));
626 }
627 aPageRange = aBuf.makeStringAndClear();
628 nPrintRange = 1;
629 }
630 }
631 /*
632 OUString aPrintRangeName( "PrintContent" );
633 aHelpIds.realloc( 1 );
634 aHelpIds[0] = ".HelpID:vcl:PrintDialog:PageContentType:ListBox";
635 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceListControlOpt( "printpagesbox", OUString(),
636 aHelpIds, aPrintRangeName,
637 mbImpress ? CreateChoice( STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE ) ) :
638 CreateChoice( STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE, SAL_N_ELEMENTS(STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE ) ),
639 nPrintRange ) );
640 */
641 OUString aPrintRangeName( u"PrintContent"_ustr );
642 aHelpIds = { u".HelpID:vcl:PrintDialog:PrintContent:RadioButton:0"_ustr,
643 u".HelpID:vcl:PrintDialog:PrintContent:RadioButton:1"_ustr,
644 u".HelpID:vcl:PrintDialog:PrintContent:RadioButton:2"_ustr };
645 aWidgetIds = { u"rbAllPages"_ustr, u"rbRangePages"_ustr, u"rbRangeSelection"_ustr };
646
647 AddDialogControl( vcl::PrinterOptionsHelper::setChoiceRadiosControlOpt(aWidgetIds, OUString(),
648 aHelpIds, aPrintRangeName,
649 mbImpress ? CreateChoice(STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE)) :
650 CreateChoice(STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE, SAL_N_ELEMENTS(STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE)),
651 nPrintRange )
652 );
653 // create an Edit dependent on "Pages" selected
654 vcl::PrinterOptionsHelper::UIControlOptions aPageRangeOpt( aPrintRangeName, 1, true );
655 AddDialogControl(vcl::PrinterOptionsHelper::setEditControlOpt(u"pagerange"_ustr, u""_ustr,
656 u".HelpID:vcl:PrintDialog:PageRange:Edit"_ustr, u"PageRange"_ustr,
657 aPageRange, aPageRangeOpt));
658 vcl::PrinterOptionsHelper::UIControlOptions aEvenOddOpt(aPrintRangeName, -1, true);
659 AddDialogControl(vcl::PrinterOptionsHelper::setChoiceListControlOpt(u"evenoddbox"_ustr, u""_ustr,
660 uno::Sequence<OUString>(), u"EvenOdd"_ustr, uno::Sequence<OUString>(),
661 0, uno::Sequence<sal_Bool>(), aEvenOddOpt));
662 }
663
664 void AddDialogControl( const Any& i_rCtrl )
665 {
666 beans::PropertyValue aVal;
667 aVal.Value = i_rCtrl;
668 maProperties.push_back( aVal );
669 }
670
671 static Sequence<OUString> CreateChoice(const TranslateId* pResourceId, size_t nCount)
672 {
673 Sequence<OUString> aChoices (nCount);
674 std::transform(pResourceId, pResourceId + nCount, aChoices.getArray(),
675 [](const auto& id) { return SdResId(id); });
676 return aChoices;
677 }
678
679 Sequence<OUString> GetSlidesPerPageSequence()
680 {
681 const Sequence<OUString> aChoice (
682 CreateChoice(STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES, SAL_N_ELEMENTS(STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES)));
683 maSlidesPerPage.clear();
684 maSlidesPerPage.push_back(0); // first is using the default
685 std::transform(std::next(aChoice.begin()), aChoice.end(), std::back_inserter(maSlidesPerPage),
686 [](const OUString& rChoice) -> sal_Int32 { return rChoice.toInt32(); });
687 return aChoice;
688 }
689 };
690
691 /** The Prepare... methods of the DocumentRenderer::Implementation class
692 create a set of PrinterPage objects that contain all necessary
693 information to do the actual printing. There is one PrinterPage
694 object per printed page. Derived classes implement the actual, mode
695 specific printing.
696
697 This and all derived classes support the asynchronous printing
698 process by not storing pointers to any data with lifetime shorter
699 than the PrinterPage objects, i.e. slides, shapes, (one of) the
700 outliner (of the document).
701 */
702 class PrinterPage
703 {
704 public:
705 PrinterPage (
706 const PageKind ePageKind,
707 const MapMode& rMapMode,
708 const bool bPrintMarkedOnly,
709 OUString sPageString,
710 const Point& rPageStringOffset,
711 const DrawModeFlags nDrawMode,
712 const Orientation eOrientation,
713 const sal_uInt16 nPaperTray)
714 : mePageKind(ePageKind),
715 maMap(rMapMode),
716 mbPrintMarkedOnly(bPrintMarkedOnly),
717 msPageString(std::move(sPageString)),
718 maPageStringOffset(rPageStringOffset),
719 mnDrawMode(nDrawMode),
720 meOrientation(eOrientation),
721 mnPaperTray(nPaperTray)
722 {
723 }
724
725 virtual ~PrinterPage() {}
726
727 virtual void Print (
728 Printer& rPrinter,
729 SdDrawDocument& rDocument,
730 ViewShell& rViewShell,
731 View* pView,
732 DrawView& rPrintView,
733 const SdrLayerIDSet& rVisibleLayers,
734 const SdrLayerIDSet& rPrintableLayers) const = 0;
735
736 DrawModeFlags GetDrawMode() const { return mnDrawMode; }
737 Orientation GetOrientation() const { return meOrientation; }
738 sal_uInt16 GetPaperTray() const { return mnPaperTray; }
739
740 protected:
741 const PageKind mePageKind;
742 const MapMode maMap;
743 const bool mbPrintMarkedOnly;
744 const OUString msPageString;
745 const Point maPageStringOffset;
746 const DrawModeFlags mnDrawMode;
747 const Orientation meOrientation;
748 const sal_uInt16 mnPaperTray;
749 };
750
751 /** The RegularPrinterPage is used for printing one regular slide (no
752 notes, handout, or outline) to one printer page.
753 */
754 class RegularPrinterPage : public PrinterPage
755 {
756 public:
757 RegularPrinterPage (
758 const sal_uInt16 nPageIndex,
759 const PageKind ePageKind,
760 const MapMode& rMapMode,
761 const bool bPrintMarkedOnly,
762 const OUString& rsPageString,
763 const Point& rPageStringOffset,
764 const DrawModeFlags nDrawMode,
765 const Orientation eOrientation,
766 const sal_uInt16 nPaperTray)
767 : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, rsPageString,
768 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
769 mnPageIndex(nPageIndex)
770 {
771 }
772
773 virtual void Print (
774 Printer& rPrinter,
775 SdDrawDocument& rDocument,
776 ViewShell&,
777 View* pView,
778 DrawView& rPrintView,
779 const SdrLayerIDSet& rVisibleLayers,
780 const SdrLayerIDSet& rPrintableLayers) const override
781 {
782 SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind);
783 rPrinter.SetMapMode(maMap);
784 PrintPage(
785 rPrinter,
786 rPrintView,
787 *pPageToPrint,
788 pView,
789 mbPrintMarkedOnly,
790 rVisibleLayers,
791 rPrintableLayers);
792 PrintMessage(
793 rPrinter,
794 msPageString,
795 maPageStringOffset);
796 }
797
798 private:
799 const sal_uInt16 mnPageIndex;
800 };
801
802 /** The NotesPrinterPage is used for printing notes pages onto one or more printer pages
803 */
804 class NotesPrinterPage : public PrinterPage
805 {
806 public:
807 NotesPrinterPage(
808 const sal_uInt16 nPageIndex,
809 const sal_Int32 nPageNumb,
810 const sal_Int32 nPageCount,
811 const bool bScaled,
812 const PageKind ePageKind,
813 const MapMode& rMapMode,
814 const bool bPrintMarkedOnly,
815 const OUString& rsPageString,
816 const Point& rPageStringOffset,
817 const DrawModeFlags nDrawMode,
818 const Orientation eOrientation,
819 const sal_uInt16 nPaperTray)
820 : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, rsPageString, rPageStringOffset,
821 nDrawMode, eOrientation, nPaperTray),
822 mnPageIndex(nPageIndex),
823 mnPageNumb(nPageNumb),
824 mnPageCount(nPageCount),
825 mbScaled(bScaled)
826 {
827 }
828
829 virtual void Print(
830 Printer& rPrinter,
831 SdDrawDocument& rDocument,
832 ViewShell&,
833 View* pView,
834 DrawView& rPrintView,
835 const SdrLayerIDSet& rVisibleLayers,
836 const SdrLayerIDSet& rPrintableLayers) const override
837 {
838 SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind);
839 rPrinter.SetMapMode(maMap);
840
841 // Clone the current page to create an independent instance for modifications.
842 // This ensures that changes made to pNotesPage do not affect the original page.
843 rtl::Reference<SdPage> pNotesPage
844 = static_cast<SdPage*>(pPageToPrint->CloneSdrPage(rDocument).get());
845
846 Size aPageSize;
847 if (mbScaled)
848 {
849 aPageSize = pNotesPage->GetSize();
850 lcl_AdjustPageSize(aPageSize, rPrinter.GetPrintPageSize());
851 }
852 else
853 aPageSize = rPrinter.GetPrintPageSize();
854
855 // Adjusts the objects on the notes page to fit the new page size.
856 ::tools::Rectangle aNewBorderRect(-1, -1, -1, -1);
857 pNotesPage->ScaleObjects(aPageSize, aNewBorderRect, true);
858
859 SdrObject* pNotesObj = pNotesPage->GetPresObj(PresObjKind::Notes);
860 if (pNotesObj)
861 {
862 // new page(s) margins
863 sal_Int32 nLeft = aPageSize.Width() * 0.1;
864 sal_Int32 nRight = nLeft;
865 sal_Int32 nTop = aPageSize.Height() * 0.075;
866 sal_Int32 nBottom = nTop;
867
868 Point aNotesPt = pNotesObj->GetRelativePos();
869 Size aNotesSize = pNotesObj->GetLogicRect().GetSize();
870
871 Outliner* pOut = rDocument.GetInternalOutliner();
872 const OutlinerMode nSaveOutlMode(pOut->GetOutlinerMode());
873 const bool bSavedUpdateMode(pOut->IsUpdateLayout());
874 pOut->SetPaperSize(aNotesSize);
875 pOut->SetUpdateLayout(true);
876 pOut->Clear();
877 pOut->SetText(*pNotesObj->GetOutlinerParaObject());
878
879 bool bAutoGrow = pNotesObj->GetMergedItem(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
880
881 // If AutoGrowHeight property is enabled and the notes page has a lower border,
882 // use the lower border but if there is no lower border, use the bottom margin
883 // to determine the first page break position.
884 // If AutoGrow is not enabled, the notes object defines the first page break.
885 ::tools::Long nNotesPageBottom
886 = bAutoGrow ? (pNotesPage->GetLowerBorder() != 0)
887 ? aPageSize.Height() - pNotesPage->GetLowerBorder()
888 : aPageSize.Height() - nBottom
889 : aNotesPt.Y() + aNotesSize.Height();
890 if (mbScaled)
891 {
892 sal_Int32 nTextHeight = aNotesPt.Y() + pOut->GetTextHeight();
893 if (bAutoGrow && (nTextHeight > nNotesPageBottom))
894 {
895 pNotesObj->SetMergedItem(SdrOnOffItem(SDRATTR_TEXT_AUTOGROWHEIGHT, false));
896
897 ::tools::Long nObjW = aNotesSize.Width();
898 ::tools::Long nObjH = aPageSize.Height() - aNotesPt.Y() - nBottom;
899
900 pNotesObj->SetLogicRect(::tools::Rectangle(aNotesPt, Size(nObjW, nObjH)));
901 }
902 SdrTextFitToSizeTypeItem eFitToSize = drawing::TextFitToSizeType_AUTOFIT;
903 pNotesObj->SetMergedItem(eFitToSize);
904 }
905 else // original size
906 {
907 bool bExit = false;
908 sal_Int32 nPrevLineLen = 0;
909 sal_Int32 nPrevParaIdx = 0;
910 sal_uInt16 nActualPageNumb = 1;
911 sal_uInt16 nPrevParaLowerSpace = 0;
912 ::tools::Long nCurrentPosY = aNotesPt.Y();
913 sal_Int32 nParaCount = pOut->GetParagraphCount();
914 std::vector<std::pair<sal_Int32, sal_Int32>> aPageBreaks;
915
916 for (sal_Int32 i = 0; i < nParaCount && !bExit; ++i)
917 {
918 sal_Int32 nActualLineLen = 0;
919 sal_Int32 nLineCount = pOut->GetLineCount(i);
920
921 sal_uInt16 nLowerSpace = 0;
922 sal_uInt16 nUpperSpace = nPrevParaLowerSpace;
923 const SfxItemSet* pItemSet = &pOut->GetParaAttribs(i);
924 if(pItemSet->HasItem(EE_PARA_ULSPACE))
925 {
926 nLowerSpace = pItemSet->Get(EE_PARA_ULSPACE).GetLower();
927 nUpperSpace = (i != 0) ? pItemSet->Get(EE_PARA_ULSPACE).GetUpper() : 0;
928 if (nPrevParaLowerSpace > nUpperSpace)
929 nUpperSpace = nPrevParaLowerSpace;
930 }
931
932 for (sal_Int32 j = 0; j < nLineCount; ++j)
933 {
934 nActualLineLen += pOut->GetLineLen(i, j);
935 sal_Int32 nLineHeight = pOut->GetLineHeight(i, j);
936
937 if (nUpperSpace != 0 && (i > 0) && (j == 0))
938 nLineHeight += nUpperSpace;
939
940 sal_Int32 nNextPosY = nCurrentPosY + nLineHeight;
941
942 if (nNextPosY > nNotesPageBottom)
943 {
944 // If the current or the next page matches the print page
945 // calculate and add a page break, since we only want to add
946 // a page break if the page is relevant.
947 if (mnPageNumb == nActualPageNumb
948 || mnPageNumb == nActualPageNumb + 1)
949 {
950 if (!aPageBreaks.empty())
951 {
952 // determine the page break at the bottom of the page
953 // for pages that have both a previous and a following page
954 aPageBreaks.emplace_back(
955 nPrevParaIdx - aPageBreaks[0].first, nPrevLineLen);
956 }
957 else
958 {
959 if (mnPageNumb == 1 || (nLineCount > 1 && j != 0))
960 {
961 // first page or multi-line paragraphs
962 aPageBreaks.emplace_back(nPrevParaIdx, nPrevLineLen);
963 }
964 else
965 { // single-line paragraphs
966 aPageBreaks.emplace_back(nPrevParaIdx + 1, 0);
967 }
968 }
969
970 if (mnPageNumb == nActualPageNumb || mnPageNumb == mnPageCount)
971 {
972 bExit = true;
973 break;
974 }
975 }
976
977 if (nUpperSpace > 0)
978 nLineHeight -= nUpperSpace;
979
980 nNotesPageBottom = aPageSize.Height() - nBottom;
981 nCurrentPosY = nTop;
982 nActualPageNumb++;
983 nActualLineLen = 0;
984 }
985 nPrevParaIdx = i;
986 nPrevLineLen = nActualLineLen;
987 nCurrentPosY += nLineHeight;
988 }
989 nPrevParaLowerSpace = nLowerSpace;
990 }
991
992 if (!aPageBreaks.empty())
993 {
994 ESelection aE;
995 if (mnPageNumb == 1)
996 {
997 aE.start.nPara = aPageBreaks[0].first;
998 aE.start.nIndex = aPageBreaks[0].second;
999 aE.end.nPara = pOut->GetParagraphCount() - 1;
1000 aE.end.nIndex = pOut->GetText(pOut->GetParagraph(aE.end.nPara)).getLength();
1001 pOut->QuickDelete(aE);
1002 }
1003 else
1004 {
1005 sal_Int16 nDepth = pOut->GetDepth(aPageBreaks[0].first);
1006 SfxItemSet aItemSet = pOut->GetParaAttribs(aPageBreaks[0].first);
1007
1008 aE.start.nPara = 0;
1009 aE.start.nIndex = 0;
1010 aE.end.nPara = aPageBreaks[0].first;
1011 aE.end.nIndex = aPageBreaks[0].second;
1012 pOut->QuickDelete(aE);
1013
1014 Paragraph* pFirstPara = pOut->GetParagraph(0);
1015 pOut->SetDepth(pFirstPara, nDepth);
1016 pOut->SetParaAttribs(0, aItemSet);
1017
1018 if (aPageBreaks.size() > 1)
1019 {
1020 aE.start.nPara = aPageBreaks[1].first;
1021 aE.start.nIndex = aPageBreaks[1].second;
1022 aE.end.nPara = pOut->GetParagraphCount() - 1;
1023 aE.end.nIndex = pOut->GetText(pOut->GetParagraph(aE.end.nPara)).getLength();
1024 pOut->QuickDelete(aE);
1025 }
1026 }
1027 }
1028 pNotesObj->SetOutlinerParaObject(pOut->CreateParaObject());
1029
1030 Size aObjSize;
1031 if (mnPageNumb != 1) // new page(s)
1032 {
1033 SdrObjListIter aShapeIter(pNotesPage.get());
1034 while (aShapeIter.IsMore())
1035 {
1036 SdrObject* pObj = aShapeIter.Next();
1037 if (pObj && pObj->GetObjIdentifier() != SdrObjKind::Text)
1038 pNotesPage->RemoveObject(pObj->GetOrdNum());
1039 }
1040
1041 aNotesPt.setX(nLeft);
1042 aNotesPt.setY(nTop);
1043 ::tools::Long nWidth = aPageSize.Width() - nLeft - nRight;
1044 aObjSize = Size(nWidth, pOut->GetTextHeight());
1045 }
1046 else // first page
1047 {
1048 if (!bAutoGrow)
1049 aObjSize = aNotesSize;
1050 else
1051 aObjSize = Size(aNotesSize.Width(), pOut->GetTextHeight());
1052 }
1053 pNotesObj->SetLogicRect(::tools::Rectangle(aNotesPt, aObjSize));
1054 }
1055 pOut->Clear();
1056 pOut->SetUpdateLayout(bSavedUpdateMode);
1057 pOut->Init(nSaveOutlMode);
1058 }
1059 pNotesPage->SetSize(aPageSize);
1060
1061 PrintPage(
1062 rPrinter,
1063 rPrintView,
1064 *pNotesPage,
1065 pView,
1066 mbPrintMarkedOnly,
1067 rVisibleLayers,
1068 rPrintableLayers);
1069 PrintMessage(
1070 rPrinter,
1071 msPageString,
1072 maPageStringOffset);
1073 }
1074
1075 private:
1076 const sal_uInt16 mnPageIndex;
1077 const sal_Int32 mnPageNumb;
1078 const sal_Int32 mnPageCount;
1079 const bool mbScaled;
1080 };
1081
1082 /** Print one slide multiple times on a printer page so that the whole
1083 printer page is covered.
1084 */
1085 class TiledPrinterPage : public PrinterPage
1086 {
1087 public:
1088 TiledPrinterPage (
1089 const sal_uInt16 nPageIndex,
1090 const PageKind ePageKind,
1091 const bool bPrintMarkedOnly,
1092 const OUString& rsPageString,
1093 const Point& rPageStringOffset,
1094 const DrawModeFlags nDrawMode,
1095 const Orientation eOrientation,
1096 const sal_uInt16 nPaperTray)
1097 : PrinterPage(ePageKind, MapMode(), bPrintMarkedOnly, rsPageString,
1098 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
1099 mnPageIndex(nPageIndex)
1100 {
1101 }
1102
1103 virtual void Print (
1104 Printer& rPrinter,
1105 SdDrawDocument& rDocument,
1106 ViewShell&,
1107 View* pView,
1108 DrawView& rPrintView,
1109 const SdrLayerIDSet& rVisibleLayers,
1110 const SdrLayerIDSet& rPrintableLayers) const override
1111 {
1112 SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind);
1113 if (pPageToPrint==nullptr)
1114 return;
1115 MapMode aMap (rPrinter.GetMapMode());
1116
1117 const Size aPageSize (pPageToPrint->GetSize());
1118 const Size aPrintSize (rPrinter.GetOutputSize());
1119
1120 const sal_Int32 nPageWidth (aPageSize.Width() + mnGap
1121 - pPageToPrint->GetLeftBorder() - pPageToPrint->GetRightBorder());
1122 const sal_Int32 nPageHeight (aPageSize.Height() + mnGap
1123 - pPageToPrint->GetUpperBorder() - pPageToPrint->GetLowerBorder());
1124 if (nPageWidth<=0 || nPageHeight<=0)
1125 return;
1126
1127 // Print at least two rows and columns. More if the document
1128 // page fits completely onto the printer page.
1129 const sal_Int32 nColumnCount (std::max(sal_Int32(2),
1130 sal_Int32(aPrintSize.Width() / nPageWidth)));
1131 const sal_Int32 nRowCount (std::max(sal_Int32(2),
1132 sal_Int32(aPrintSize.Height() / nPageHeight)));
1133 for (sal_Int32 nRow=0; nRow<nRowCount; ++nRow)
1134 for (sal_Int32 nColumn=0; nColumn<nColumnCount; ++nColumn)
1135 {
1136 aMap.SetOrigin(Point(nColumn*nPageWidth,nRow*nPageHeight));
1137 rPrinter.SetMapMode(aMap);
1138 PrintPage(
1139 rPrinter,
1140 rPrintView,
1141 *pPageToPrint,
1142 pView,
1143 mbPrintMarkedOnly,
1144 rVisibleLayers,
1145 rPrintableLayers);
1146 }
1147
1148 PrintMessage(
1149 rPrinter,
1150 msPageString,
1151 maPageStringOffset);
1152 }
1153
1154 private:
1155 const sal_uInt16 mnPageIndex;
1156 static const sal_Int32 mnGap = 500;
1157 };
1158
1159 /** Print two slides to one printer page so that the resulting pages
1160 form a booklet.
1161 */
1162 class BookletPrinterPage : public PrinterPage
1163 {
1164 public:
1165 BookletPrinterPage (
1166 const sal_uInt16 nFirstPageIndex,
1167 const sal_uInt16 nSecondPageIndex,
1168 const Point& rFirstOffset,
1169 const Point& rSecondOffset,
1170 const PageKind ePageKind,
1171 const MapMode& rMapMode,
1172 const bool bPrintMarkedOnly,
1173 const DrawModeFlags nDrawMode,
1174 const Orientation eOrientation,
1175 const sal_uInt16 nPaperTray)
1176 : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, u""_ustr,
1177 Point(), nDrawMode, eOrientation, nPaperTray),
1178 mnFirstPageIndex(nFirstPageIndex),
1179 mnSecondPageIndex(nSecondPageIndex),
1180 maFirstOffset(rFirstOffset),
1181 maSecondOffset(rSecondOffset)
1182 {
1183 }
1184
1185 virtual void Print (
1186 Printer& rPrinter,
1187 SdDrawDocument& rDocument,
1188 ViewShell&,
1189 View* pView,
1190 DrawView& rPrintView,
1191 const SdrLayerIDSet& rVisibleLayers,
1192 const SdrLayerIDSet& rPrintableLayers) const override
1193 {
1194 MapMode aMap (maMap);
1195 SdPage* pPageToPrint = rDocument.GetSdPage(mnFirstPageIndex, mePageKind);
1196 if (pPageToPrint)
1197 {
1198 aMap.SetOrigin(maFirstOffset);
1199 rPrinter.SetMapMode(aMap);
1200 PrintPage(
1201 rPrinter,
1202 rPrintView,
1203 *pPageToPrint,
1204 pView,
1205 mbPrintMarkedOnly,
1206 rVisibleLayers,
1207 rPrintableLayers);
1208 }
1209
1210 pPageToPrint = rDocument.GetSdPage(mnSecondPageIndex, mePageKind);
1211 if( !pPageToPrint )
1212 return;
1213
1214 aMap.SetOrigin(maSecondOffset);
1215 rPrinter.SetMapMode(aMap);
1216 PrintPage(
1217 rPrinter,
1218 rPrintView,
1219 *pPageToPrint,
1220 pView,
1221 mbPrintMarkedOnly,
1222 rVisibleLayers,
1223 rPrintableLayers);
1224 }
1225
1226 private:
1227 const sal_uInt16 mnFirstPageIndex;
1228 const sal_uInt16 mnSecondPageIndex;
1229 const Point maFirstOffset;
1230 const Point maSecondOffset;
1231 };
1232
1233 /** One handout page displays one to nine slides.
1234 */
1235 class HandoutPrinterPage : public PrinterPage
1236 {
1237 public:
1238 HandoutPrinterPage (
1239 const sal_uInt16 nHandoutPageIndex,
1240 std::vector<sal_uInt16>&& rPageIndices,
1241 const MapMode& rMapMode,
1242 const OUString& rsPageString,
1243 const Point& rPageStringOffset,
1244 const DrawModeFlags nDrawMode,
1245 const Orientation eOrientation,
1246 const sal_uInt16 nPaperTray)
1247 : PrinterPage(PageKind::Handout, rMapMode, false, rsPageString,
1248 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
1249 mnHandoutPageIndex(nHandoutPageIndex),
1250 maPageIndices(std::move(rPageIndices))
1251 {
1252 }
1253
1254 virtual void Print (
1255 Printer& rPrinter,
1256 SdDrawDocument& rDocument,
1257 ViewShell& rViewShell,
1258 View* pView,
1259 DrawView& rPrintView,
1260 const SdrLayerIDSet& rVisibleLayers,
1261 const SdrLayerIDSet& rPrintableLayers) const override
1262 {
1263 SdPage& rHandoutPage (*rDocument.GetSdPage(0, PageKind::Handout));
1264
1265 Size aPageSize(rHandoutPage.GetSize());
1266 Size aPrintPageSize = rPrinter.GetPrintPageSize();
1267
1268 if ((aPageSize.Width() < aPageSize.Height()
1269 && aPrintPageSize.Width() > aPrintPageSize.Height())
1270 || (aPageSize.Width() > aPageSize.Height()
1271 && aPrintPageSize.Width() < aPrintPageSize.Height()))
1272 {
1273 ::tools::Long nTmp = aPageSize.Width();
1274 aPageSize.setWidth(aPageSize.Height());
1275 aPageSize.setHeight(nTmp);
1276
1277 rHandoutPage.SetSize(aPageSize);
1278 }
1279
1280 Reference< css::beans::XPropertySet > xHandoutPage( rHandoutPage.getUnoPage(), UNO_QUERY );
1281 static constexpr OUString sPageNumber( u"Number"_ustr );
1282
1283 // Collect the page objects of the handout master.
1284 std::vector<SdrPageObj*> aHandoutPageObjects;
1285 SdrObjListIter aShapeIter (&rHandoutPage);
1286 while (aShapeIter.IsMore())
1287 {
1288 SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next());
1289 if (pPageObj)
1290 aHandoutPageObjects.push_back(pPageObj);
1291 }
1292 if (aHandoutPageObjects.empty())
1293 return;
1294
1295 // Connect page objects with pages.
1296 std::vector<SdrPageObj*>::iterator aPageObjIter (aHandoutPageObjects.begin());
1297 for (std::vector<sal_uInt16>::const_iterator
1298 iPageIndex(maPageIndices.begin()),
1299 iEnd(maPageIndices.end());
1300 iPageIndex!=iEnd && aPageObjIter!=aHandoutPageObjects.end();
1301 ++iPageIndex)
1302 {
1303 // Check if the page still exists.
1304 if (*iPageIndex >= rDocument.GetSdPageCount(PageKind::Standard))
1305 continue;
1306
1307 SdrPageObj* pPageObj = *aPageObjIter++;
1308 pPageObj->SetReferencedPage(rDocument.GetSdPage(*iPageIndex, PageKind::Standard));
1309 }
1310
1311 // if there are more page objects than pages left, set the rest to invisible
1312 int nHangoverCount = 0;
1313 while (aPageObjIter != aHandoutPageObjects.end())
1314 {
1315 (*aPageObjIter++)->SetReferencedPage(nullptr);
1316 nHangoverCount++;
1317 }
1318
1319 // Hide outlines for objects that have pages attached.
1320 if (nHangoverCount > 0)
1321 {
1322 int nSkip = aHandoutPageObjects.size() - nHangoverCount;
1323 aShapeIter.Reset();
1324 while (aShapeIter.IsMore())
1325 {
1326 SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next());
1327 if (pPathObj)
1328 {
1329 if (nSkip > 0)
1330 --nSkip;
1331 else
1332 pPathObj->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1333 }
1334 }
1335 }
1336
1337 if( xHandoutPage.is() ) try
1338 {
1339 xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(mnHandoutPageIndex) ) );
1340 }
1341 catch( Exception& )
1342 {
1343 }
1344 rViewShell.SetPrintedHandoutPageNum( mnHandoutPageIndex + 1 );
1345
1346 rPrinter.SetMapMode(maMap);
1347
1348 PrintPage(
1349 rPrinter,
1350 rPrintView,
1351 rHandoutPage,
1352 pView,
1353 false,
1354 rVisibleLayers,
1355 rPrintableLayers);
1356 PrintMessage(
1357 rPrinter,
1358 msPageString,
1359 maPageStringOffset);
1360
1361 if( xHandoutPage.is() ) try
1362 {
1363 xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(0) ) );
1364 }
1365 catch( Exception& )
1366 {
1367 }
1368 rViewShell.SetPrintedHandoutPageNum(1);
1369
1370 // Restore outlines.
1371 if (nHangoverCount > 0)
1372 {
1373 aShapeIter.Reset();
1374 while (aShapeIter.IsMore())
1375 {
1376 SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next());
1377 if (pPathObj != nullptr)
1378 pPathObj->SetMergedItem(XLineStyleItem(drawing::LineStyle_SOLID));
1379 }
1380 }
1381
1382 }
1383
1384 private:
1385 const sal_uInt16 mnHandoutPageIndex;
1386 const std::vector<sal_uInt16> maPageIndices;
1387 };
1388
1389 /** The outline information (title, subtitle, outline objects) of the
1390 document. There is no fixed mapping of slides to printer pages.
1391 */
1392 class OutlinerPrinterPage : public PrinterPage
1393 {
1394 public:
1395 OutlinerPrinterPage (
1396 std::optional<OutlinerParaObject> pParaObject,
1397 const MapMode& rMapMode,
1398 const OUString& rsPageString,
1399 const Point& rPageStringOffset,
1400 const DrawModeFlags nDrawMode,
1401 const Orientation eOrientation,
1402 const sal_uInt16 nPaperTray)
1403 : PrinterPage(PageKind::Handout, rMapMode, false, rsPageString,
1404 rPageStringOffset, nDrawMode, eOrientation, nPaperTray),
1405 mpParaObject(std::move(pParaObject))
1406 {
1407 }
1408
1409 virtual void Print (
1410 Printer& rPrinter,
1411 SdDrawDocument& rDocument,
1412 ViewShell&,
1413 View*,
1414 DrawView&,
1415 const SdrLayerIDSet&,
1416 const SdrLayerIDSet&) const override
1417 {
1418 // Set up the printer.
1419 rPrinter.SetMapMode(maMap);
1420
1421 // Get and set up the outliner.
1422 const ::tools::Rectangle aOutRect (rPrinter.GetPageOffset(), rPrinter.GetOutputSize());
1423 Outliner* pOutliner = rDocument.GetInternalOutliner();
1424 const OutlinerMode nSavedOutlMode (pOutliner->GetOutlinerMode());
1425 const bool bSavedUpdateMode (pOutliner->IsUpdateLayout());
1426 const Size aSavedPaperSize (pOutliner->GetPaperSize());
1427
1428 pOutliner->Init(OutlinerMode::OutlineView);
1429 pOutliner->SetPaperSize(aOutRect.GetSize());
1430 pOutliner->SetUpdateLayout(true);
1431 pOutliner->Clear();
1432 pOutliner->SetText(*mpParaObject);
1433
1434 pOutliner->Draw(rPrinter, aOutRect);
1435
1436 PrintMessage(
1437 rPrinter,
1438 msPageString,
1439 maPageStringOffset);
1440
1441 // Restore outliner and printer.
1442 pOutliner->Clear();
1443 pOutliner->SetUpdateLayout(bSavedUpdateMode);
1444 pOutliner->SetPaperSize(aSavedPaperSize);
1445 pOutliner->Init(nSavedOutlMode);
1446 }
1447
1448 private:
1449 std::optional<OutlinerParaObject> mpParaObject;
1450 };
1451 }
1452
1453 //===== DocumentRenderer::Implementation ======================================
1454
1455 class DocumentRenderer::Implementation
1456 : public SfxListener,
1457 public vcl::PrinterOptionsHelper
1458 {
1459 public:
1460 explicit Implementation (ViewShellBase& rBase)
1461 : mxObjectShell(rBase.GetDocShell())
1462 , mrBase(rBase)
1463 , mbIsDisposed(false)
1464 , mpPrinter(nullptr)
1465 , mbHasOrientationWarningBeenShown(false)
1466 {
1467 DialogCreator aCreator( mrBase, mrBase.GetDocShell()->GetDocumentType() == DocumentType::Impress, GetCurrentPageIndex() );
1468 m_aUIProperties = aCreator.GetDialogControls();
1469 maSlidesPerPage = aCreator.GetSlidesPerPage();
1470
1471 StartListening(mrBase);
1472 }
1473
1474 virtual ~Implementation() override
1475 {
1476 EndListening(mrBase);
1477 }
1478
1479 virtual void Notify (SfxBroadcaster& rBroadcaster, const SfxHint& rHint) override
1480 {
1481 if (&rBroadcaster != &static_cast<SfxBroadcaster&>(mrBase))
1482 return;
1483
1484 if (rHint.GetId() == SfxHintId::Dying)
1485 {
1486 mbIsDisposed = true;
1487 }
1488 }
1489
1490 /** Process the sequence of properties given to one of the XRenderable
1491 methods.
1492 */
1493 void ProcessProperties (const css::uno::Sequence<css::beans::PropertyValue >& rOptions)
1494 {
1495 OSL_ASSERT(!mbIsDisposed);
1496 if (mbIsDisposed)
1497 return;
1498
1499 bool bIsValueChanged = processProperties( rOptions );
1500 bool bIsPaperChanged = false;
1501
1502 // The RenderDevice property is handled specially: its value is
1503 // stored in mpPrinter instead of being retrieved on demand.
1504 Any aDev( getValue( u"RenderDevice"_ustr ) );
1505 Reference<awt::XDevice> xRenderDevice;
1506
1507 if (aDev >>= xRenderDevice)
1508 {
1509 VCLXDevice* pDevice = dynamic_cast<VCLXDevice*>(xRenderDevice.get());
1510 VclPtr< OutputDevice > pOut = pDevice ? pDevice->GetOutputDevice()
1511 : VclPtr< OutputDevice >();
1512 mpPrinter = dynamic_cast<Printer*>(pOut.get());
1513 Size aPageSizePixel = mpPrinter ? mpPrinter->GetPaperSizePixel() : Size();
1514 Size aPrintPageSize = mpPrinter ? mpPrinter->GetPrintPageSize() : Size();
1515
1516 lcl_AdjustPageSize(aPageSizePixel, aPrintPageSize);
1517
1518 if (aPageSizePixel != maPrinterPageSizePixel)
1519 {
1520 bIsPaperChanged = true;
1521 maPrinterPageSizePixel = aPageSizePixel;
1522 }
1523 }
1524
1525 if (bIsValueChanged && ! mpOptions )
1526 mpOptions.reset(new PrintOptions(*this, std::vector(maSlidesPerPage)));
1527 if( bIsValueChanged || bIsPaperChanged )
1528 PreparePages();
1529 }
1530
1531 /** Return the number of pages that are to be printed.
1532 */
1533 sal_Int32 GetPrintPageCount() const
1534 {
1535 OSL_ASSERT(!mbIsDisposed);
1536 if (mbIsDisposed)
1537 return 0;
1538 else
1539 return maPrinterPages.size();
1540 }
1541
1542 /** Return a sequence of properties that can be returned by the
1543 XRenderable::getRenderer() method.
1544 */
1545 css::uno::Sequence<css::beans::PropertyValue> GetProperties () const
1546 {
1547 css::uno::Sequence<css::beans::PropertyValue> aProperties{
1548 comphelper::makePropertyValue(u"ExtraPrintUIOptions"_ustr,
1549 comphelper::containerToSequence(m_aUIProperties)),
1550 comphelper::makePropertyValue(u"PageSize"_ustr, maPrintSize),
1551 // FIXME: is this always true ?
1552 comphelper::makePropertyValue(u"PageIncludesNonprintableArea"_ustr, true)
1553 };
1554
1555 return aProperties;
1556 }
1557
1558 /** Print one of the prepared pages.
1559 */
1560 void PrintPage (const sal_Int32 nIndex)
1561 {
1562 OSL_ASSERT(!mbIsDisposed);
1563 if (mbIsDisposed)
1564 return;
1565
1566 Printer& rPrinter (*mpPrinter);
1567
1568 std::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
1569 if ( ! pViewShell)
1570 return;
1571
1572 SdDrawDocument* pDocument = pViewShell->GetDoc();
1573 assert(pDocument!=nullptr);
1574
1575 std::shared_ptr<DrawViewShell> pDrawViewShell(
1576 std::dynamic_pointer_cast<DrawViewShell>(pViewShell));
1577
1578 if (!mpPrintView)
1579 mpPrintView.reset(new DrawView(mrBase.GetDocShell(), &rPrinter, nullptr));
1580
1581 if (nIndex<0 || sal::static_int_cast<sal_uInt32>(nIndex)>=maPrinterPages.size())
1582 return;
1583
1584 const std::shared_ptr<PrinterPage> pPage (maPrinterPages[nIndex]);
1585 OSL_ASSERT(pPage);
1586 if ( ! pPage)
1587 return;
1588
1589 const Orientation eSavedOrientation (rPrinter.GetOrientation());
1590 const DrawModeFlags nSavedDrawMode (rPrinter.GetDrawMode());
1591 const MapMode aSavedMapMode (rPrinter.GetMapMode());
1592 const sal_uInt16 nSavedPaperBin (rPrinter.GetPaperBin());
1593
1594 // Set page orientation.
1595 if ( ! rPrinter.SetOrientation(pPage->GetOrientation()))
1596 {
1597 if ( ! mbHasOrientationWarningBeenShown
1598 && mpOptions->IsWarningOrientation())
1599 {
1600 mbHasOrientationWarningBeenShown = true;
1601 // Show warning that the orientation could not be set.
1602 std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(
1603 pViewShell->GetFrameWeld(), VclMessageType::Warning, VclButtonsType::OkCancel,
1604 SdResId(STR_WARN_PRINTFORMAT_FAILURE)));
1605 xWarn->set_default_response(RET_CANCEL);
1606 if (xWarn->run() != RET_OK)
1607 return;
1608 }
1609 }
1610
1611 // Set the draw mode.
1612 rPrinter.SetDrawMode(pPage->GetDrawMode());
1613
1614 // Set paper tray.
1615 rPrinter.SetPaperBin(pPage->GetPaperTray());
1616
1617 // Print the actual page.
1618 pPage->Print(
1619 rPrinter,
1620 *pDocument,
1621 *pViewShell,
1622 pDrawViewShell ? pDrawViewShell->GetView() : nullptr,
1623 *mpPrintView,
1624 pViewShell->GetFrameView()->GetVisibleLayers(),
1625 pViewShell->GetFrameView()->GetPrintableLayers());
1626
1627 rPrinter.SetOrientation(eSavedOrientation);
1628 rPrinter.SetDrawMode(nSavedDrawMode);
1629 rPrinter.SetMapMode(aSavedMapMode);
1630 rPrinter.SetPaperBin(nSavedPaperBin);
1631 }
1632
1633 private:
1634 // rhbz#657394: keep the document alive: prevents crash when
1635 SfxObjectShellRef mxObjectShell; // destroying mpPrintView
1636 ViewShellBase& mrBase;
1637 bool mbIsDisposed;
1638 VclPtr<Printer> mpPrinter;
1639 Size maPrinterPageSizePixel;
1640 std::unique_ptr<PrintOptions> mpOptions;
1641 std::vector< std::shared_ptr< ::sd::PrinterPage> > maPrinterPages;
1642 std::unique_ptr<DrawView> mpPrintView;
1643 bool mbHasOrientationWarningBeenShown;
1644 std::vector<sal_Int32> maSlidesPerPage;
1645 awt::Size maPrintSize;
1646
1647 sal_Int32 GetCurrentPageIndex() const
1648 {
1649 const ViewShell *pShell = mrBase.GetMainViewShell().get();
1650 const SdPage *pCurrentPage = pShell ? pShell->getCurrentPage() : nullptr;
1651 return pCurrentPage ? (pCurrentPage->GetPageNum()-1)/2 : -1;
1652 }
1653
1654 /** Determine and set the paper orientation.
1655 */
1656 void SetupPaperOrientation (
1657 const PageKind ePageKind,
1658 PrintInfo& rInfo)
1659 {
1660 SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc();
1661 rInfo.meOrientation = Orientation::Portrait;
1662
1663 if( ! mpOptions->IsBooklet())
1664 {
1665 rInfo.meOrientation = pDocument->GetSdPage(0, ePageKind)->GetOrientation();
1666 }
1667 else if (rInfo.maPageSize.Width() < rInfo.maPageSize.Height())
1668 rInfo.meOrientation = Orientation::Landscape;
1669
1670 // Draw and Notes should usually abide by their specified paper size
1671 Size aPaperSize;
1672 if (!mpOptions->IsPrinterPreferred(pDocument->GetDocumentType()))
1673 {
1674 aPaperSize.setWidth(rInfo.maPageSize.Width());
1675 aPaperSize.setHeight(rInfo.maPageSize.Height());
1676 }
1677 else
1678 {
1679 aPaperSize.setWidth(rInfo.mpPrinter->GetPaperSize().Width());
1680 aPaperSize.setHeight(rInfo.mpPrinter->GetPaperSize().Height());
1681
1682 if (!mpOptions->IsBooklet())
1683 lcl_AdjustPageSize(aPaperSize, rInfo.mpPrinter->GetPrintPageSize());
1684 }
1685
1686 maPrintSize = awt::Size(aPaperSize.Width(), aPaperSize.Height());
1687
1688 if (mpOptions->IsPrinterPreferred(pDocument->GetDocumentType())
1689 && ePageKind == PageKind::Standard && !mpOptions->IsBooklet())
1690 {
1691 if( (rInfo.meOrientation == Orientation::Landscape &&
1692 (aPaperSize.Width() < aPaperSize.Height()))
1693 ||
1694 (rInfo.meOrientation == Orientation::Portrait &&
1695 (aPaperSize.Width() > aPaperSize.Height()))
1696 )
1697 {
1698 maPrintSize = awt::Size(aPaperSize.Height(), aPaperSize.Width());
1699 }
1700 }
1701 }
1702
1703 /** Top most method for preparing printer pages. In this and the other
1704 Prepare... methods the various special cases are detected and
1705 handled.
1706 For every page that is to be printed (that may contain several
1707 slides) one PrinterPage object is created and inserted into
1708 maPrinterPages.
1709 */
1710 void PreparePages()
1711 {
1712 mpPrintView.reset();
1713 maPrinterPages.clear();
1714 mbHasOrientationWarningBeenShown = false;
1715
1716 ViewShell* pShell = mrBase.GetMainViewShell().get();
1717
1718 PrintInfo aInfo (mpPrinter, mpOptions->IsPrintMarkedOnly());
1719
1720 if (aInfo.mpPrinter==nullptr || pShell==nullptr)
1721 return;
1722
1723 MapMode aMap (aInfo.mpPrinter->GetMapMode());
1724 aMap.SetMapUnit(MapUnit::Map100thMM);
1725 aInfo.maMap = aMap;
1726 mpPrinter->SetMapMode(aMap);
1727
1728 ::Outliner& rOutliner = mrBase.GetDocument()->GetDrawOutliner();
1729 const EEControlBits nSavedControlWord (rOutliner.GetControlWord());
1730 EEControlBits nCntrl = nSavedControlWord;
1731 nCntrl &= ~EEControlBits::MARKFIELDS;
1732 nCntrl &= ~EEControlBits::ONLINESPELLING;
1733 rOutliner.SetControlWord( nCntrl );
1734
1735 // When in outline view then apply all pending changes to the model.
1736 if( auto pOutlineViewShell = dynamic_cast< OutlineViewShell *>( pShell ) )
1737 pOutlineViewShell->PrepareClose (false);
1738
1739 // Collect some frequently used data.
1740 if (mpOptions->IsDate())
1741 {
1742 aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData().getDate( Date( Date::SYSTEM ) );
1743 aInfo.msTimeDate += " ";
1744 }
1745
1746 if (mpOptions->IsTime())
1747 aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData().getTime( ::tools::Time( ::tools::Time::SYSTEM ), false );
1748
1749 // Draw and Notes should usually use specified paper size when printing
1750 if (!mpOptions->IsPrinterPreferred(mrBase.GetDocShell()->GetDocumentType()))
1751 {
1752 aInfo.maPrintSize = mrBase.GetDocument()->GetSdPage(0, PageKind::Standard)->GetSize();
1753 maPrintSize = awt::Size(aInfo.maPrintSize.Width(),
1754 aInfo.maPrintSize.Height());
1755 }
1756 else
1757 {
1758 aInfo.maPrintSize = aInfo.mpPrinter->GetOutputSize();
1759 maPrintSize = awt::Size(
1760 aInfo.mpPrinter->GetPaperSize().Width(),
1761 aInfo.mpPrinter->GetPaperSize().Height());
1762 }
1763
1764 switch (mpOptions->GetOutputQuality())
1765 {
1766 case 1: // Grayscale
1767 aInfo.mnDrawMode = DrawModeFlags::GrayLine | DrawModeFlags::GrayFill
1768 | DrawModeFlags::GrayText | DrawModeFlags::GrayBitmap
1769 | DrawModeFlags::GrayGradient;
1770 break;
1771
1772 case 2: // Black & White
1773 aInfo.mnDrawMode = DrawModeFlags::BlackLine | DrawModeFlags::WhiteFill
1774 | DrawModeFlags::BlackText | DrawModeFlags::GrayBitmap
1775 | DrawModeFlags::WhiteGradient;
1776 break;
1777
1778 default:
1779 aInfo.mnDrawMode = DrawModeFlags::Default;
1780 }
1781
1782 if (mpOptions->IsDraw())
1783 PrepareStdOrNotes(PageKind::Standard, aInfo);
1784 if (mpOptions->IsNotes())
1785 PrepareStdOrNotes(PageKind::Notes, aInfo);
1786 if (mpOptions->IsHandout())
1787 {
1788 InitHandoutTemplate();
1789 PrepareHandout(aInfo);
1790 }
1791 if (mpOptions->IsOutline())
1792 PrepareOutline(aInfo);
1793
1794 rOutliner.SetControlWord(nSavedControlWord);
1795 }
1796
1797 /** Create the page objects of the handout template. When the actual
1798 printing takes place then the page objects are assigned different
1799 sets of slides for each printed page (see HandoutPrinterPage::Print).
1800 */
1801 void InitHandoutTemplate()
1802 {
1803 const sal_Int32 nSlidesPerHandout (mpOptions->GetHandoutPageCount());
1804 const bool bHandoutHorizontal (mpOptions->IsHandoutHorizontal());
1805
1806 AutoLayout eLayout = AUTOLAYOUT_HANDOUT6;
1807 switch (nSlidesPerHandout)
1808 {
1809 case 0: eLayout = AUTOLAYOUT_NONE; break; // AUTOLAYOUT_HANDOUT1; break;
1810 case 1: eLayout = AUTOLAYOUT_HANDOUT1; break;
1811 case 2: eLayout = AUTOLAYOUT_HANDOUT2; break;
1812 case 3: eLayout = AUTOLAYOUT_HANDOUT3; break;
1813 case 4: eLayout = AUTOLAYOUT_HANDOUT4; break;
1814 default:
1815 case 6: eLayout = AUTOLAYOUT_HANDOUT6; break;
1816 case 9: eLayout = AUTOLAYOUT_HANDOUT9; break;
1817 }
1818
1819 if( !mrBase.GetDocument() )
1820 return;
1821
1822 SdDrawDocument& rModel = *mrBase.GetDocument();
1823
1824 // first, prepare handout page (not handout master)
1825
1826 SdPage* pHandout = rModel.GetSdPage(0, PageKind::Handout);
1827 if( !pHandout )
1828 return;
1829
1830 // delete all previous shapes from handout page
1831 while( pHandout->GetObjCount() )
1832 pHandout->NbcRemoveObject(0);
1833
1834 const bool bDrawLines (eLayout == AUTOLAYOUT_HANDOUT3);
1835
1836 Size aHandoutPageSize = pHandout->GetSize();
1837 lcl_AdjustPageSize(aHandoutPageSize, mpPrinter->GetPrintPageSize());
1838 Orientation eOrient = aHandoutPageSize.Width() > aHandoutPageSize.Height()
1839 ? Orientation::Landscape
1840 : Orientation::Portrait;
1841
1842 std::vector< ::tools::Rectangle > aAreas;
1843 SdPage::CalculateHandoutAreas( rModel, eLayout, bHandoutHorizontal, aAreas, eOrient );
1844
1845 std::vector< ::tools::Rectangle >::iterator iter( aAreas.begin() );
1846 while( iter != aAreas.end() )
1847 {
1848 pHandout->NbcInsertObject(
1849 new SdrPageObj(
1850 rModel,
1851 (*iter++)));
1852
1853 if( bDrawLines && (iter != aAreas.end()) )
1854 {
1855 ::tools::Rectangle aRect( *iter++ );
1856
1857 basegfx::B2DPolygon aPoly;
1858 aPoly.insert(0, basegfx::B2DPoint( aRect.Left(), aRect.Top() ) );
1859 aPoly.insert(1, basegfx::B2DPoint( aRect.Right(), aRect.Top() ) );
1860
1861 basegfx::B2DHomMatrix aMatrix;
1862 aMatrix.translate( 0.0, static_cast< double >( aRect.GetHeight() / 7 ) );
1863
1864 basegfx::B2DPolyPolygon aPathPoly;
1865 for( sal_uInt16 nLine = 0; nLine < 7; nLine++ )
1866 {
1867 aPoly.transform( aMatrix );
1868 aPathPoly.append( aPoly );
1869 }
1870
1871 rtl::Reference<SdrPathObj> pPathObj = new SdrPathObj(
1872 rModel,
1873 SdrObjKind::PathLine,
1874 std::move(aPathPoly));
1875 pPathObj->SetMergedItem(XLineStyleItem(drawing::LineStyle_SOLID));
1876 pPathObj->SetMergedItem(XLineColorItem(OUString(), COL_BLACK));
1877
1878 pHandout->NbcInsertObject( pPathObj.get() );
1879 }
1880 }
1881 }
1882
1883 /** Detect whether the specified slide is to be printed.
1884 @return
1885 When the slide is not to be printed then <NULL/> is returned.
1886 Otherwise a pointer to the slide is returned.
1887 */
1888 SdPage* GetFilteredPage (
1889 const sal_Int32 nPageIndex,
1890 const PageKind ePageKind) const
1891 {
1892 OSL_ASSERT(mrBase.GetDocument() != nullptr);
1893 OSL_ASSERT(nPageIndex>=0);
1894 SdPage* pPage = mrBase.GetDocument()->GetSdPage(
1895 sal::static_int_cast<sal_uInt16>(nPageIndex),
1896 ePageKind);
1897 if (pPage == nullptr)
1898 return nullptr;
1899 if ( ! pPage->IsExcluded() || mpOptions->IsPrintExcluded())
1900 return pPage;
1901 else
1902 return nullptr;
1903 }
1904
1905 /** Prepare the outline of the document for printing. There is no fixed
1906 number of slides whose outline data is put onto one printer page.
1907 If the current printer page has enough room for the outline of the
1908 current slide then that is added. Otherwise a new printer page is
1909 started.
1910 */
1911 void PrepareOutline (PrintInfo const & rInfo)
1912 {
1913 MapMode aMap (rInfo.maMap);
1914 Point aPageOfs (rInfo.mpPrinter->GetPageOffset() );
1915 aMap.SetScaleX(Fraction(1,2));
1916 aMap.SetScaleY(Fraction(1,2));
1917 mpPrinter->SetMapMode(aMap);
1918
1919 ::tools::Rectangle aOutRect(aPageOfs, rInfo.mpPrinter->GetOutputSize());
1920 if( aOutRect.GetWidth() > aOutRect.GetHeight() )
1921 {
1922 Size aPaperSize( rInfo.mpPrinter->PixelToLogic( rInfo.mpPrinter->GetPaperSizePixel(), MapMode( MapUnit::Map100thMM ) ) );
1923 maPrintSize.Width = aPaperSize.Height();
1924 maPrintSize.Height = aPaperSize.Width();
1925 const auto nRotatedWidth = aOutRect.GetHeight();
1926 const auto nRotatedHeight = aOutRect.GetWidth();
1927 const auto nRotatedX = aPageOfs.Y();
1928 const auto nRotatedY = aPageOfs.X();
1929 aOutRect = ::tools::Rectangle(Point( nRotatedX, nRotatedY),
1930 Size(nRotatedWidth, nRotatedHeight));
1931 }
1932
1933 Outliner* pOutliner = mrBase.GetDocument()->GetInternalOutliner();
1934 pOutliner->Init(OutlinerMode::OutlineView);
1935 const OutlinerMode nSavedOutlMode (pOutliner->GetOutlinerMode());
1936 const bool bSavedUpdateMode (pOutliner->IsUpdateLayout());
1937 const Size aSavedPaperSize (pOutliner->GetPaperSize());
1938 const MapMode aSavedMapMode (pOutliner->GetRefMapMode());
1939 pOutliner->SetPaperSize(aOutRect.GetSize());
1940 pOutliner->SetUpdateLayout(true);
1941
1942 ::tools::Long nPageH = aOutRect.GetHeight();
1943
1944 std::vector< sal_Int32 > aPages;
1945 sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(PageKind::Standard);
1946 StringRangeEnumerator::getRangesFromString(
1947 mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
1948 aPages, 0, nPageCount-1);
1949
1950 for (size_t nIndex = 0, nCount = aPages.size(); nIndex < nCount;)
1951 {
1952 pOutliner->Clear();
1953
1954 Paragraph* pPara = nullptr;
1955 ::tools::Long nH (0);
1956 while (nH < nPageH && nIndex<nCount)
1957 {
1958 SdPage* pPage = GetFilteredPage(aPages[nIndex], PageKind::Standard);
1959 ++nIndex;
1960 if (pPage == nullptr)
1961 continue;
1962
1963 SdrTextObj* pTextObj = nullptr;
1964
1965 for (const rtl::Reference<SdrObject>& pObj : *pPage)
1966 {
1967 if (pObj->GetObjInventor() == SdrInventor::Default
1968 && pObj->GetObjIdentifier() == SdrObjKind::TitleText)
1969 {
1970 pTextObj = DynCastSdrTextObj(pObj.get());
1971 if (pTextObj)
1972 break;
1973 }
1974 }
1975
1976 pPara = pOutliner->GetParagraph(pOutliner->GetParagraphCount() - 1);
1977
1978 if (pTextObj!=nullptr
1979 && !pTextObj->IsEmptyPresObj()
1980 && pTextObj->GetOutlinerParaObject())
1981 {
1982 pOutliner->AddText(*(pTextObj->GetOutlinerParaObject()));
1983 }
1984 else
1985 pOutliner->Insert(OUString());
1986
1987 pTextObj = nullptr;
1988
1989 for (const rtl::Reference<SdrObject>& pObj : *pPage)
1990 {
1991 if (pObj->GetObjInventor() == SdrInventor::Default
1992 && pObj->GetObjIdentifier() == SdrObjKind::OutlineText)
1993 {
1994 pTextObj = DynCastSdrTextObj(pObj.get());
1995 if (pTextObj)
1996 break;
1997 }
1998 }
1999
2000 bool bSubTitle (false);
2001 if (!pTextObj)
2002 {
2003 bSubTitle = true;
2004 pTextObj = DynCastSdrTextObj(pPage->GetPresObj(PresObjKind::Text)); // is there a subtitle?
2005 }
2006
2007 sal_Int32 nParaCount1 = pOutliner->GetParagraphCount();
2008
2009 if (pTextObj!=nullptr
2010 && !pTextObj->IsEmptyPresObj()
2011 && pTextObj->GetOutlinerParaObject())
2012 {
2013 pOutliner->AddText(*(pTextObj->GetOutlinerParaObject()));
2014 }
2015
2016 if (bSubTitle )
2017 {
2018 const sal_Int32 nParaCount2 (pOutliner->GetParagraphCount());
2019 for (sal_Int32 nPara=nParaCount1; nPara<nParaCount2; ++nPara)
2020 {
2021 Paragraph* pP = pOutliner->GetParagraph(nPara);
2022 if (pP!=nullptr && pOutliner->GetDepth(nPara) > 0)
2023 pOutliner->SetDepth(pP, 0);
2024 }
2025 }
2026
2027 nH = pOutliner->GetTextHeight();
2028 }
2029
2030 // Remove the last paragraph when that does not fit completely on
2031 // the current page.
2032 if (nH > nPageH && pPara!=nullptr)
2033 {
2034 sal_Int32 nCnt = pOutliner->GetAbsPos(
2035 pOutliner->GetParagraph( pOutliner->GetParagraphCount() - 1 ) );
2036 sal_Int32 nParaPos = pOutliner->GetAbsPos( pPara );
2037 nCnt -= nParaPos;
2038 pPara = pOutliner->GetParagraph( ++nParaPos );
2039 if ( nCnt && pPara )
2040 {
2041 pOutliner->Remove(pPara, nCnt);
2042 --nIndex;
2043 }
2044 }
2045
2046 if ( CheckForFrontBackPages( nIndex ) )
2047 {
2048 maPrinterPages.push_back(
2049 std::make_shared<OutlinerPrinterPage>(
2050 pOutliner->CreateParaObject(),
2051 aMap,
2052 rInfo.msTimeDate,
2053 aPageOfs,
2054 rInfo.mnDrawMode,
2055 rInfo.meOrientation,
2056 rInfo.mpPrinter->GetPaperBin()));
2057 }
2058 }
2059
2060 pOutliner->SetRefMapMode(aSavedMapMode);
2061 pOutliner->SetUpdateLayout(bSavedUpdateMode);
2062 pOutliner->SetPaperSize(aSavedPaperSize);
2063 pOutliner->Init(nSavedOutlMode);
2064 }
2065
2066 /** Prepare handout pages for slides that are to be printed.
2067 */
2068 void PrepareHandout (PrintInfo& rInfo)
2069 {
2070 SdDrawDocument* pDocument = mrBase.GetDocument();
2071 assert(pDocument != nullptr);
2072 SdPage& rHandoutPage (*pDocument->GetSdPage(0, PageKind::Handout));
2073
2074 const bool bScalePage (mpOptions->IsPageSize());
2075
2076 sal_uInt16 nPaperBin;
2077 if ( ! mpOptions->IsPaperBin())
2078 nPaperBin = rHandoutPage.GetPaperBin();
2079 else
2080 nPaperBin = rInfo.mpPrinter->GetPaperBin();
2081
2082 // Change orientation?
2083 SdPage& rMaster (dynamic_cast<SdPage&>(rHandoutPage.TRG_GetMasterPage()));
2084 rInfo.meOrientation = rMaster.GetOrientation();
2085
2086 Size aPaperSize (rInfo.mpPrinter->GetPaperSize());
2087 lcl_AdjustPageSize(aPaperSize, rInfo.mpPrinter->GetPrintPageSize());
2088 maPrintSize = awt::Size(aPaperSize.Width(),aPaperSize.Height());
2089
2090 MapMode aMap (rInfo.maMap);
2091 const Point aPageOfs (rInfo.mpPrinter->GetPageOffset());
2092
2093 if ( bScalePage )
2094 {
2095 Size aPageSize (rHandoutPage.GetSize());
2096 Size aPrintSize (rInfo.mpPrinter->GetOutputSize());
2097 lcl_AdjustPageSize(aPageSize, aPrintSize);
2098
2099 const double fHorz = static_cast<double>(aPrintSize.Width()) / aPageSize.Width();
2100 const double fVert = static_cast<double>(aPrintSize.Height()) / aPageSize.Height();
2101
2102 Fraction aFract;
2103 if ( fHorz < fVert )
2104 aFract = Fraction(aPrintSize.Width(), aPageSize.Width());
2105 else
2106 aFract = Fraction(aPrintSize.Height(), aPageSize.Height());
2107
2108 aMap.SetScaleX(aFract);
2109 aMap.SetScaleY(aFract);
2110 aMap.SetOrigin(Point());
2111 }
2112
2113 std::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
2114 pViewShell->WriteFrameViewData();
2115
2116 // Count page shapes.
2117 sal_uInt32 nShapeCount (0);
2118 SdrObjListIter aShapeIter (&rHandoutPage);
2119 while (aShapeIter.IsMore())
2120 {
2121 SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next());
2122 if (pPageObj)
2123 ++nShapeCount;
2124 }
2125
2126 const sal_uInt16 nPageCount = mrBase.GetDocument()->GetSdPageCount(PageKind::Standard);
2127 const sal_uInt16 nHandoutPageCount = nShapeCount ? (nPageCount + nShapeCount - 1) / nShapeCount : 0;
2128 pViewShell->SetPrintedHandoutPageCount( nHandoutPageCount );
2129 mrBase.GetDocument()->setHandoutPageCount( nHandoutPageCount );
2130
2131 // Distribute pages to handout pages.
2132 StringRangeEnumerator aRangeEnum(
2133 mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
2134 0, nPageCount-1);
2135 std::vector<sal_uInt16> aPageIndices;
2136 sal_uInt16 nPrinterPageIndex = 0;
2137 StringRangeEnumerator::Iterator it = aRangeEnum.begin(), itEnd = aRangeEnum.end();
2138 bool bLastLoop = (it == itEnd);
2139 while (!bLastLoop)
2140 {
2141 sal_Int32 nPageIndex = *it;
2142 ++it;
2143 bLastLoop = (it == itEnd);
2144
2145 if (GetFilteredPage(nPageIndex, PageKind::Standard))
2146 aPageIndices.push_back(nPageIndex);
2147 else if (!bLastLoop)
2148 continue;
2149
2150 // Create a printer page when we have found one page for each
2151 // placeholder or when this is the last (and special) loop.
2152 if ( !aPageIndices.empty() && CheckForFrontBackPages( nPageIndex )
2153 && (aPageIndices.size() == nShapeCount || bLastLoop) )
2154 {
2155 maPrinterPages.push_back(
2156 std::make_shared<HandoutPrinterPage>(
2157 nPrinterPageIndex++,
2158 std::move(aPageIndices),
2159 aMap,
2160 rInfo.msTimeDate,
2161 aPageOfs,
2162 rInfo.mnDrawMode,
2163 rInfo.meOrientation,
2164 nPaperBin));
2165 aPageIndices.clear();
2166 }
2167 }
2168 }
2169
2170 /** Prepare the notes pages or regular slides.
2171 */
2172 void PrepareStdOrNotes (
2173 const PageKind ePageKind,
2174 PrintInfo& rInfo)
2175 {
2176 OSL_ASSERT(rInfo.mpPrinter != nullptr);
2177
2178 // Fill in page kind specific data.
2179 SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc();
2180 if (pDocument->GetSdPageCount(ePageKind) == 0)
2181 return;
2182 SdPage* pRefPage = pDocument->GetSdPage(0, ePageKind);
2183
2184 if (!mpOptions->IsPrinterPreferred(pDocument->GetDocumentType()) && mpOptions->IsNotes())
2185 rInfo.maPageSize = mpPrinter->GetPrintPageSize();
2186 else
2187 rInfo.maPageSize = pRefPage->GetSize();
2188
2189 SetupPaperOrientation(ePageKind, rInfo);
2190
2191 if (mpOptions->IsBooklet())
2192 PrepareBooklet(ePageKind, rInfo);
2193 else
2194 PrepareRegularPages(ePageKind, rInfo);
2195 }
2196
2197 /** Prepare slides in a non-booklet way: one slide per one to many
2198 printer pages.
2199 */
2200 void PrepareRegularPages (
2201 const PageKind ePageKind,
2202 PrintInfo& rInfo)
2203 {
2204 std::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell());
2205 pViewShell->WriteFrameViewData();
2206
2207 sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(PageKind::Standard);
2208 StringRangeEnumerator aRangeEnum(
2209 mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
2210 0, nPageCount-1);
2211 for (StringRangeEnumerator::Iterator
2212 it = aRangeEnum.begin(),
2213 itEnd = aRangeEnum.end();
2214 it != itEnd;
2215 ++it)
2216 {
2217 SdPage* pPage = GetFilteredPage(*it, ePageKind);
2218 if (pPage == nullptr)
2219 continue;
2220
2221 MapMode aMap (rInfo.maMap);
2222
2223 Size aPageSize = pPage->GetSize();
2224
2225 if (mpOptions->IsPageSize())
2226 {
2227 Size aPrintSize = rInfo.maPrintSize;
2228 lcl_AdjustPageSize(aPageSize, aPrintSize);
2229
2230 const double fHorz(static_cast<double>(aPrintSize.Width()) / aPageSize.Width());
2231 const double fVert(static_cast<double>(aPrintSize.Height()) / aPageSize.Height());
2232
2233 Fraction aFract;
2234 if (fHorz < fVert)
2235 aFract = Fraction(aPrintSize.Width(), aPageSize.Width());
2236 else
2237 aFract = Fraction(aPrintSize.Height(), aPageSize.Height());
2238
2239 aMap.SetScaleX(aFract);
2240 aMap.SetScaleY(aFract);
2241 aMap.SetOrigin(Point());
2242 }
2243
2244 if (mpOptions->IsPrintPageName())
2245 {
2246 rInfo.msPageString = pPage->GetName() + " ";
2247 }
2248 else
2249 rInfo.msPageString.clear();
2250 rInfo.msPageString += rInfo.msTimeDate;
2251
2252 ::tools::Long aPageWidth = aPageSize.Width() - pPage->GetLeftBorder() - pPage->GetRightBorder();
2253 ::tools::Long aPageHeight = aPageSize.Height() - pPage->GetUpperBorder() - pPage->GetLowerBorder();
2254 // Bugfix for 44530:
2255 // if it was implicitly changed (Landscape/Portrait),
2256 // this is considered for tiling, respectively for the splitting up
2257 // (Poster)
2258 if( ( rInfo.maPrintSize.Width() > rInfo.maPrintSize.Height()
2259 && aPageWidth < aPageHeight )
2260 || ( rInfo.maPrintSize.Width() < rInfo.maPrintSize.Height()
2261 && aPageWidth > aPageHeight ) )
2262 {
2263 const sal_Int32 nTmp (rInfo.maPrintSize.Width());
2264 rInfo.maPrintSize.setWidth( rInfo.maPrintSize.Height() );
2265 rInfo.maPrintSize.setHeight( nTmp );
2266 }
2267
2268 if (mpOptions->IsTilePage()
2269 && aPageWidth < rInfo.maPrintSize.Width()
2270 && aPageHeight < rInfo.maPrintSize.Height())
2271 {
2272 // Put multiple slides on one printer page.
2273 PrepareTiledPage(*it, *pPage, ePageKind, rInfo);
2274 }
2275 else
2276 {
2277 rInfo.maMap = std::move(aMap);
2278 PrepareScaledPage(*it, *pPage, ePageKind, rInfo);
2279 }
2280 }
2281 }
2282
2283 /** Put two slides on one printer page.
2284 */
2285 void PrepareBooklet (
2286 const PageKind ePageKind,
2287 const PrintInfo& rInfo)
2288 {
2289 MapMode aStdMap (rInfo.maMap);
2290 Point aOffset;
2291 Size aPrintSize_2 (rInfo.maPrintSize);
2292 Size aPageSize_2 (rInfo.maPageSize);
2293
2294 if (rInfo.meOrientation == Orientation::Landscape)
2295 aPrintSize_2.setWidth( aPrintSize_2.Width() >> 1 );
2296 else
2297 aPrintSize_2.setHeight( aPrintSize_2.Height() >> 1 );
2298
2299 const double fPageWH = static_cast<double>(aPageSize_2.Width()) / aPageSize_2.Height();
2300 const double fPrintWH = static_cast<double>(aPrintSize_2.Width()) / aPrintSize_2.Height();
2301
2302 if( fPageWH < fPrintWH )
2303 {
2304 aPageSize_2.setWidth( static_cast<::tools::Long>( aPrintSize_2.Height() * fPageWH ) );
2305 aPageSize_2.setHeight( aPrintSize_2.Height() );
2306 }
2307 else
2308 {
2309 aPageSize_2.setWidth( aPrintSize_2.Width() );
2310 aPageSize_2.setHeight( static_cast<::tools::Long>( aPrintSize_2.Width() / fPageWH ) );
2311 }
2312
2313 MapMode aMap (rInfo.maMap);
2314 aMap.SetScaleX( Fraction( aPageSize_2.Width(), rInfo.maPageSize.Width() ) );
2315 aMap.SetScaleY( Fraction( aPageSize_2.Height(), rInfo.maPageSize.Height() ) );
2316
2317 // calculate adjusted print size
2318 const Size aAdjustedPrintSize (OutputDevice::LogicToLogic(
2319 rInfo.maPrintSize,
2320 aStdMap,
2321 aMap));
2322
2323 if (rInfo.meOrientation == Orientation::Landscape)
2324 {
2325 aOffset.setX( ( ( aAdjustedPrintSize.Width() >> 1 ) - rInfo.maPageSize.Width() ) >> 1 );
2326 aOffset.setY( ( aAdjustedPrintSize.Height() - rInfo.maPageSize.Height() ) >> 1 );
2327 }
2328 else
2329 {
2330 aOffset.setX( ( aAdjustedPrintSize.Width() - rInfo.maPageSize.Width() ) >> 1 );
2331 aOffset.setY( ( ( aAdjustedPrintSize.Height() >> 1 ) - rInfo.maPageSize.Height() ) >> 1 );
2332 }
2333
2334 // create vector of pages to print
2335 sal_Int32 nPageCount = mrBase.GetDocument()->GetSdPageCount(ePageKind);
2336 StringRangeEnumerator aRangeEnum(
2337 mpOptions->GetPrinterSelection(nPageCount, GetCurrentPageIndex()),
2338 0, nPageCount-1);
2339 std::vector< sal_uInt16 > aPageVector;
2340 for (StringRangeEnumerator::Iterator
2341 it = aRangeEnum.begin(),
2342 itEnd = aRangeEnum.end();
2343 it != itEnd;
2344 ++it)
2345 {
2346 SdPage* pPage = GetFilteredPage(*it, ePageKind);
2347 if (pPage != nullptr)
2348 aPageVector.push_back(*it);
2349 }
2350
2351 // create pairs of pages to print on each page
2352 std::vector< std::pair< sal_uInt16, sal_uInt16 > > aPairVector;
2353 if ( ! aPageVector.empty())
2354 {
2355 sal_uInt32 nFirstIndex = 0, nLastIndex = aPageVector.size() - 1;
2356
2357 if( aPageVector.size() & 1 )
2358 aPairVector.emplace_back( sal_uInt16(65535), aPageVector[ nFirstIndex++ ] );
2359 else
2360 aPairVector.emplace_back( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] );
2361
2362 while( nFirstIndex < nLastIndex )
2363 {
2364 if( nFirstIndex & 1 )
2365 aPairVector.emplace_back( aPageVector[ nFirstIndex++ ], aPageVector[ nLastIndex-- ] );
2366 else
2367 aPairVector.emplace_back( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] );
2368 }
2369 }
2370
2371 for (sal_uInt32
2372 nIndex=0,
2373 nCount=aPairVector.size();
2374 nIndex < nCount;
2375 ++nIndex)
2376 {
2377 if ( CheckForFrontBackPages( nIndex ) )
2378 {
2379 const std::pair<sal_uInt16, sal_uInt16> aPair (aPairVector[nIndex]);
2380 Point aSecondOffset (aOffset);
2381 if (rInfo.meOrientation == Orientation::Landscape)
2382 aSecondOffset.AdjustX( aAdjustedPrintSize.Width() / 2 );
2383 else
2384 aSecondOffset.AdjustY( aAdjustedPrintSize.Height() / 2 );
2385 maPrinterPages.push_back(
2386 std::make_shared<BookletPrinterPage>(
2387 aPair.first,
2388 aPair.second,
2389 aOffset,
2390 aSecondOffset,
2391 ePageKind,
2392 aMap,
2393 rInfo.mbPrintMarkedOnly,
2394 rInfo.mnDrawMode,
2395 rInfo.meOrientation,
2396 rInfo.mpPrinter->GetPaperBin()));
2397
2398 }
2399 }
2400 }
2401
2402 /** Print one slide multiple times on one printer page so that the whole
2403 printer page is covered.
2404 */
2405 void PrepareTiledPage (
2406 const sal_Int32 nPageIndex,
2407 const SdPage& rPage,
2408 const PageKind ePageKind,
2409 const PrintInfo& rInfo)
2410 {
2411 sal_uInt16 nPaperBin;
2412 if ( ! mpOptions->IsPaperBin())
2413 nPaperBin = rPage.GetPaperBin();
2414 else
2415 nPaperBin = rInfo.mpPrinter->GetPaperBin();
2416
2417 if ( !CheckForFrontBackPages( nPageIndex ) )
2418 return;
2419
2420 maPrinterPages.push_back(
2421 std::make_shared<TiledPrinterPage>(
2422 sal::static_int_cast<sal_uInt16>(nPageIndex),
2423 ePageKind,
2424 rInfo.mbPrintMarkedOnly,
2425 rInfo.msPageString,
2426 rInfo.mpPrinter->GetPageOffset(),
2427 rInfo.mnDrawMode,
2428 rInfo.meOrientation,
2429 nPaperBin));
2430 }
2431
2432 /** Print one standard slide or notes page on one to many printer
2433 pages. More than on printer page is used when the slide is larger
2434 than the printable area.
2435 */
2436 void PrepareScaledPage (
2437 const sal_Int32 nPageIndex,
2438 const SdPage& rPage,
2439 const PageKind ePageKind,
2440 const PrintInfo& rInfo)
2441 {
2442 const Point aPageOffset (rInfo.mpPrinter->GetPageOffset());
2443
2444 sal_uInt16 nPaperBin;
2445 if ( ! mpOptions->IsPaperBin())
2446 nPaperBin = rPage.GetPaperBin();
2447 else
2448 nPaperBin = rInfo.mpPrinter->GetPaperBin();
2449
2450 // For pages larger than the printable area there are three options:
2451 // 1. Scale down to the page to the printable area.
2452 // 2. Print only the upper left part of the page (without the unprintable borders).
2453 // 3. Split the page into parts of the size of the printable area.
2454 const bool bScalePage (mpOptions->IsPageSize());
2455 const bool bCutPage (mpOptions->IsCutPage());
2456 MapMode aMap (rInfo.maMap);
2457 if ( (bScalePage || bCutPage) && CheckForFrontBackPages( nPageIndex ) )
2458 {
2459 // Handle 1 and 2.
2460
2461 // if CutPage is set then do not move it, otherwise move the
2462 // scaled page to printable area
2463 if (ePageKind == PageKind::Standard)
2464 {
2465 maPrinterPages.push_back(
2466 std::make_shared<RegularPrinterPage>(
2467 sal::static_int_cast<sal_uInt16>(nPageIndex),
2468 ePageKind,
2469 aMap,
2470 rInfo.mbPrintMarkedOnly,
2471 rInfo.msPageString,
2472 aPageOffset,
2473 rInfo.mnDrawMode,
2474 rInfo.meOrientation,
2475 nPaperBin));
2476 }
2477 else if (SdPage* pPage = GetFilteredPage(nPageIndex, PageKind::Notes))// Notes
2478 {
2479 SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc();
2480
2481 // Clone the current page to create an independent instance.
2482 // This ensures that changes made to pNotesPage do not affect the original page.
2483 rtl::Reference<SdPage> pNotesPage
2484 = static_cast<SdPage*>(pPage->CloneSdrPage(*pDocument).get());
2485
2486 Size aPageSize = bScalePage ? pNotesPage->GetSize() : rInfo.mpPrinter->GetPrintPageSize();
2487 // Adjusts the objects on the notes page to fit the new page size.
2488 ::tools::Rectangle aNewBorderRect(-1, -1, -1, -1);
2489 pNotesPage->ScaleObjects(aPageSize, aNewBorderRect, true);
2490
2491 SdrObject* pNotesObj = pNotesPage->GetPresObj(PresObjKind::Notes);
2492 if (pNotesObj && bCutPage)
2493 {
2494 // default margins
2495 sal_Int32 nTopMargin = aPageSize.Height() * 0.075;
2496 sal_Int32 nBottomMargin = nTopMargin;
2497
2498 Size nNotesObjSize = pNotesObj->GetLogicRect().GetSize();
2499
2500 Outliner* pOut = pDocument->GetInternalOutliner();
2501 const OutlinerMode nSaveOutlMode(pOut->GetOutlinerMode());
2502 const bool bSavedUpdateMode(pOut->IsUpdateLayout());
2503 pOut->Init(OutlinerMode::OutlineView);
2504 pOut->SetPaperSize(nNotesObjSize);
2505 pOut->SetUpdateLayout(true);
2506 pOut->Clear();
2507 pOut->SetText(*pNotesObj->GetOutlinerParaObject());
2508
2509 sal_Int32 nFirstPageBottomMargin = 0;
2510 ::tools::Long nNotesHeight = nNotesObjSize.Height();
2511 bool bAutoGrow = pNotesObj->GetMergedItem(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
2512 if (bAutoGrow)
2513 {
2514 nNotesHeight += pNotesObj->GetRelativePos().Y();
2515 nFirstPageBottomMargin = (pNotesPage->GetLowerBorder() != 0)
2516 ? pNotesPage->GetLowerBorder()
2517 : nBottomMargin;
2518 }
2519 double nOverflowedTextHeight = 0;
2520 ::tools::Long nFirstPageBottom = aPageSize.Height() - nFirstPageBottomMargin;
2521 if (nNotesHeight > nFirstPageBottom)
2522 {
2523 // Calculate the height of the overflow text
2524 // when the AutoGrowHeight property of the notes object is enabled
2525 // and the height of the object exceeds the page height.
2526 nOverflowedTextHeight = pNotesObj->GetRelativePos().Y()
2527 + pOut->GetTextHeight() - nFirstPageBottom;
2528 }
2529 else
2530 nOverflowedTextHeight = pOut->GetTextHeight() - nNotesObjSize.Height();
2531
2532 sal_Int32 nNotePageCount = 1;
2533 double nNewPageHeight = aPageSize.Height() - nTopMargin - nBottomMargin;
2534 if (nOverflowedTextHeight > 0)
2535 {
2536 nNotePageCount += std::ceil(nOverflowedTextHeight / nNewPageHeight);
2537 }
2538
2539 for (sal_Int32 i = 1; i <= nNotePageCount; i++)
2540 {
2541 // set page numbers
2542 sal_Int32 nPageNumb = i;
2543 OUString sPageNumb = rInfo.msPageString;
2544 if (!sPageNumb.isEmpty() && nNotePageCount > 1)
2545 {
2546 OUString sTmp;
2547 if (!rInfo.msTimeDate.isEmpty())
2548 {
2549 sTmp += " ";
2550 }
2551 sTmp += SdResId(STR_PAGE_NAME) + " " + OUString::number(i);
2552 sPageNumb += sTmp;
2553 }
2554
2555 maPrinterPages.push_back(
2556 std::make_shared<NotesPrinterPage>(
2557 sal::static_int_cast<sal_uInt16>(nPageIndex),
2558 nPageNumb,
2559 nNotePageCount,
2560 bScalePage,
2561 PageKind::Notes,
2562 aMap,
2563 rInfo.mbPrintMarkedOnly,
2564 sPageNumb,
2565 aPageOffset,
2566 rInfo.mnDrawMode,
2567 rInfo.meOrientation,
2568 nPaperBin));
2569 }
2570 pOut->Clear();
2571 pOut->SetUpdateLayout(bSavedUpdateMode);
2572 pOut->Init(nSaveOutlMode);
2573 }
2574 else // scaled page
2575 {
2576 maPrinterPages.push_back(
2577 std::make_shared<NotesPrinterPage>(
2578 sal::static_int_cast<sal_uInt16>(nPageIndex),
2579 sal_Int32(0),
2580 sal_Int32(0),
2581 bScalePage,
2582 PageKind::Notes,
2583 aMap,
2584 rInfo.mbPrintMarkedOnly,
2585 rInfo.msPageString,
2586 aPageOffset,
2587 rInfo.mnDrawMode,
2588 rInfo.meOrientation,
2589 nPaperBin));
2590 }
2591 }
2592 }
2593 else
2594 {
2595 // Handle 3. Print parts of the page in the size of the
2596 // printable area until the whole page is covered.
2597
2598 // keep the page content at its position if it fits, otherwise
2599 // move it to the printable area
2600 const ::tools::Long nPageWidth (
2601 rInfo.maPageSize.Width() - rPage.GetLeftBorder() - rPage.GetRightBorder());
2602 const ::tools::Long nPageHeight (
2603 rInfo.maPageSize.Height() - rPage.GetUpperBorder() - rPage.GetLowerBorder());
2604
2605 Point aOrigin ( 0, 0 );
2606
2607 for (Point aPageOrigin = aOrigin;
2608 -aPageOrigin.Y()<nPageHeight;
2609 aPageOrigin.AdjustY( -rInfo.maPrintSize.Height() ))
2610 {
2611 for (aPageOrigin.setX(aOrigin.X());
2612 -aPageOrigin.X()<nPageWidth;
2613 aPageOrigin.AdjustX(-rInfo.maPrintSize.Width()))
2614 {
2615 if ( CheckForFrontBackPages( nPageIndex ) )
2616 {
2617 aMap.SetOrigin(aPageOrigin);
2618 maPrinterPages.push_back(
2619 std::make_shared<RegularPrinterPage>(
2620 sal::static_int_cast<sal_uInt16>(nPageIndex),
2621 ePageKind,
2622 aMap,
2623 rInfo.mbPrintMarkedOnly,
2624 rInfo.msPageString,
2625 aPageOffset,
2626 rInfo.mnDrawMode,
2627 rInfo.meOrientation,
2628 nPaperBin));
2629 }
2630 }
2631 }
2632 }
2633 }
2634
2635 bool CheckForFrontBackPages( sal_Int32 nPage )
2636 {
2637 const bool bIsIndexOdd(nPage & 1);
2638 if ((!bIsIndexOdd && mpOptions->IsPrintFrontPage())
2639 || (bIsIndexOdd && mpOptions->IsPrintBackPage()))
2640 {
2641 return true;
2642 }
2643 else
2644 return false;
2645 }
2646 };
2647
2648 //===== DocumentRenderer ======================================================
2649
2650 DocumentRenderer::DocumentRenderer (ViewShellBase& rBase)
2651 : mpImpl(new Implementation(rBase))
2652 {
2653 }
2654
2655 DocumentRenderer::~DocumentRenderer()
2656 {
2657 }
2658
2659 //----- XRenderable -----------------------------------------------------------
2660
2661 sal_Int32 SAL_CALL DocumentRenderer::getRendererCount (
2662 const css::uno::Any&,
2663 const css::uno::Sequence<css::beans::PropertyValue >& rOptions)
2664 {
2665 mpImpl->ProcessProperties(rOptions);
2666 return mpImpl->GetPrintPageCount();
2667 }
2668
2669 Sequence<beans::PropertyValue> SAL_CALL DocumentRenderer::getRenderer (
2670 sal_Int32,
2671 const css::uno::Any&,
2672 const css::uno::Sequence<css::beans::PropertyValue>& rOptions)
2673 {
2674 mpImpl->ProcessProperties(rOptions);
2675 return mpImpl->GetProperties();
2676 }
2677
2678 void SAL_CALL DocumentRenderer::render (
2679 sal_Int32 nRenderer,
2680 const css::uno::Any&,
2681 const css::uno::Sequence<css::beans::PropertyValue>& rOptions)
2682 {
2683 mpImpl->ProcessProperties(rOptions);
2684 mpImpl->PrintPage(nRenderer);
2685 }
2686
2687 } // end of namespace sd
2688
2689 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE