?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sw / source / core / view / vprint.cxx
blob9c4144dfa10a6bde2da4fd90c53b36b6a9c2e794
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: vprint.cxx,v $
10 * $Revision: 1.46 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35 #include <hintids.hxx>
36 #include <sfx2/printer.hxx>
37 #include <sfx2/objsh.hxx>
38
39 // #include <tools/intn.hxx>
40 #include <sfx2/progress.hxx>
41 #include <sfx2/app.hxx>
42 #include <sfx2/prnmon.hxx>
43 #include <svx/paperinf.hxx>
44 #include <svx/pbinitem.hxx>
45 #include <svx/svdview.hxx>
46 #include <unotools/localedatawrapper.hxx>
47 #include <svtools/syslocale.hxx>
48 #include <txtfld.hxx>
49 #include <fmtfld.hxx>
50 #include <fmtfsize.hxx>
51 #include <frmatr.hxx>
52 #include <rootfrm.hxx>
53 #include <pagefrm.hxx>
54 #include <cntfrm.hxx>
55 #include <doc.hxx>
56 #include <fesh.hxx>
57 #include <pam.hxx>
58 #include <viewimp.hxx> // Imp->SetFirstVisPageInvalid()
59 #include <layact.hxx>
60 #include <ndtxt.hxx>
61 #include <fldbas.hxx>
62 #include <docufld.hxx> // PostItFld /-Type
63 #include <docfld.hxx> // _SetGetExpFld
64 #include <shellres.hxx>
65 #include <viewopt.hxx>
66 #include <swprtopt.hxx> // SwPrtOptions
67 #include <pagedesc.hxx>
68 #include <poolfmt.hxx> // fuer RES_POOLPAGE_JAKET
69 #include <mdiexp.hxx> // Ansteuern der Statusleiste
70 #ifndef _STATSTR_HRC
71 #include <statstr.hrc> // -- " --
72 #endif
73 #include <ptqueue.hxx>
74 #include <tabfrm.hxx>
75 #include <txtfrm.hxx> // MinPrtLine
76 #include <viscrs.hxx> // SwShellCrsr
77 #include <fmtpdsc.hxx> // SwFmtPageDesc
78
79 #define JOBSET_ERR_DEFAULT 0
80 #define JOBSET_ERR_ERROR 1
81 #define JOBSET_ERR_ISSTARTET 2
82
83 //--------------------------------------------------------------------
84 //Klasse zum Puffern von Paints
85 class SwQueuedPaint
86 {
87 public:
88 SwQueuedPaint *pNext;
89 ViewShell *pSh;
90 SwRect aRect;
91
92 SwQueuedPaint( ViewShell *pNew, const SwRect &rRect ) :
93 pNext( 0 ),
94 pSh( pNew ),
95 aRect( rRect )
96 {}
97 };
98
99 SwQueuedPaint *SwPaintQueue::pQueue = 0;
100
101 //Klasse zum Speichern einiger Druckereinstellungen
102 class SwPrtOptSave
103 {
104 Printer *pPrt;
105 Size aSize;
106 Paper ePaper;
107 Orientation eOrientation;
108 USHORT nPaperBin;
109 public:
110 SwPrtOptSave( Printer *pPrinter );
111 ~SwPrtOptSave();
112 };
113
114 // saves some settings from the draw view
115 class SwDrawViewSave
116 {
117 String sLayerNm;
118 SdrView* pDV;
119 sal_Bool bPrintControls;
120 public:
121 SwDrawViewSave( SdrView* pSdrView );
122 ~SwDrawViewSave();
123 };
124
125
126 void SwPaintQueue::Add( ViewShell *pNew, const SwRect &rNew )
127 {
128 SwQueuedPaint *pPt;
129 if ( 0 != (pPt = pQueue) )
130 {
131 while ( pPt->pSh != pNew && pPt->pNext )
132 pPt = pPt->pNext;
133 if ( pPt->pSh == pNew )
134 {
135 pPt->aRect.Union( rNew );
136 return;
137 }
138 }
139 SwQueuedPaint *pNQ = new SwQueuedPaint( pNew, rNew );
140 if ( pPt )
141 pPt->pNext = pNQ;
142 else
143 pQueue = pNQ;
144 }
145
146
147
148 void SwPaintQueue::Repaint()
149 {
150 if ( !SwRootFrm::IsInPaint() && pQueue )
151 {
152 SwQueuedPaint *pPt = pQueue;
153 do
154 { ViewShell *pSh = pPt->pSh;
155 SET_CURR_SHELL( pSh );
156 if ( pSh->IsPreView() )
157 {
158 if ( pSh->GetWin() )
159 {
160 //Fuer PreView aussenherum, weil im PaintHdl (UI) die
161 //Zeilen/Spalten bekannt sind.
162 pSh->GetWin()->Invalidate();
163 pSh->GetWin()->Update();
164 }
165 }
166 else
167 pSh->Paint( pPt->aRect.SVRect() );
168 pPt = pPt->pNext;
169 } while ( pPt );
170
171 do
172 { pPt = pQueue;
173 pQueue = pQueue->pNext;
174 delete pPt;
175 } while ( pQueue );
176 }
177 }
178
179
180
181 void SwPaintQueue::Remove( ViewShell *pSh )
182 {
183 SwQueuedPaint *pPt;
184 if ( 0 != (pPt = pQueue) )
185 {
186 SwQueuedPaint *pPrev = 0;
187 while ( pPt && pPt->pSh != pSh )
188 {
189 pPrev = pPt;
190 pPt = pPt->pNext;
191 }
192 if ( pPt )
193 {
194 if ( pPrev )
195 pPrev->pNext = pPt->pNext;
196 else if ( pPt == pQueue )
197 pQueue = 0;
198 delete pPt;
199 }
200 }
201 }
202
203
204 const XubString& SwPrtOptions::MakeNextJobName()
205 {
206 static char __READONLY_DATA sDelim[] = " - ";
207 USHORT nDelim = sJobName.SearchAscii( sDelim );
208 if( STRING_NOTFOUND == nDelim )
209 sJobName.AppendAscii(sDelim);
210 else
211 sJobName.Erase( nDelim + 3/*Zeichen!*/ );
212
213 return sJobName += XubString::CreateFromInt32( ++nJobNo );
214 }
215
216 /******************************************************************************
217 * Methode : void SetSwVisArea( ViewShell *pSh, Point aPrtOffset, ...
218 * Beschreibung:
219 * Erstellt : OK 04.11.94 16:27
220 * Aenderung :
221 ******************************************************************************/
222
223 void SetSwVisArea( ViewShell *pSh, const SwRect &rRect, BOOL bPDFExport )
224 {
225 ASSERT( !pSh->GetWin(), "Drucken mit Window?" );
226 pSh->aVisArea = rRect;
227 pSh->Imp()->SetFirstVisPageInvalid();
228 Point aPt( rRect.Pos() );
229
230 if (!bPDFExport)
231 aPt += pSh->aPrtOffst;
232 aPt.X() = -aPt.X(); aPt.Y() = -aPt.Y();
233
234 OutputDevice *pOut = bPDFExport ?
235 pSh->GetOut() :
236 pSh->getIDocumentDeviceAccess()->getPrinter( false );
237
238 MapMode aMapMode( pOut->GetMapMode() );
239 aMapMode.SetOrigin( aPt );
240 pOut->SetMapMode( aMapMode );
241 }
242
243 /******************************************************************************
244 * Methode : struct _PostItFld : public _SetGetExpFld
245 * Beschreibung: Update an das PostItFeld
246 * Erstellt : OK 07.11.94 10:18
247 * Aenderung :
248 ******************************************************************************/
249 struct _PostItFld : public _SetGetExpFld
250 {
251 _PostItFld( const SwNodeIndex& rNdIdx, const SwTxtFld* pFld,
252 const SwIndex* pIdx = 0 )
253 : _SetGetExpFld( rNdIdx, pFld, pIdx ) {}
254
255 USHORT GetPageNo( MultiSelection &rMulti, BOOL bRgt, BOOL bLft,
256 USHORT& rVirtPgNo, USHORT& rLineNo );
257 SwPostItField* GetPostIt() const
258 { return (SwPostItField*) GetFld()->GetFld().GetFld(); }
259 };
260
261
262
263 USHORT _PostItFld::GetPageNo( MultiSelection &rMulti, BOOL bRgt, BOOL bLft,
264 USHORT& rVirtPgNo, USHORT& rLineNo )
265 {
266 //Problem: Wenn ein PostItFld in einem Node steht, der von mehr als
267 //einer Layout-Instanz repraesentiert wird, steht die Frage im Raum,
268 //ob das PostIt nur ein- oder n-mal gedruck werden soll.
269 //Wahrscheinlich nur einmal, als Seitennummer soll hier keine Zufaellige
270 //sondern die des ersten Auftretens des PostIts innerhalb des selektierten
271 //Bereichs ermittelt werden.
272 rVirtPgNo = 0;
273 USHORT nPos = GetCntnt();
274 SwClientIter aIter( (SwModify &)GetFld()->GetTxtNode() );
275 for( SwTxtFrm* pFrm = (SwTxtFrm*)aIter.First( TYPE( SwFrm ));
276 pFrm; pFrm = (SwTxtFrm*)aIter.Next() )
277 {
278 if( pFrm->GetOfst() > nPos ||
279 (pFrm->HasFollow() && pFrm->GetFollow()->GetOfst() <= nPos) )
280 continue;
281 USHORT nPgNo = pFrm->GetPhyPageNum();
282 BOOL bRight = pFrm->OnRightPage();
283 if( rMulti.IsSelected( nPgNo ) &&
284 ( (bRight && bRgt) || (!bRight && bLft) ) )
285 {
286 rLineNo = (USHORT)(pFrm->GetLineCount( nPos ) +
287 pFrm->GetAllLines() - pFrm->GetThisLines());
288 rVirtPgNo = pFrm->GetVirtPageNum();
289 return nPgNo;
290 }
291 }
292 return 0;
293 }
294
295 /******************************************************************************
296 * Methode : void lcl_GetPostIts( IDocumentFieldsAccess* pIDFA, _SetGetExpFlds& ...
297 * Beschreibung:
298 * Erstellt : OK 07.11.94 10:20
299 * Aenderung :
300 ******************************************************************************/
301
302
303 void lcl_GetPostIts( IDocumentFieldsAccess* pIDFA, _SetGetExpFlds& rSrtLst )
304 {
305 SwFieldType* pFldType = pIDFA->GetSysFldType( RES_POSTITFLD );
306 ASSERT( pFldType, "kein PostItType ? ");
307
308 if( pFldType->GetDepends() )
309 {
310 // Modify-Object gefunden, trage alle Felder ins Array ein
311 SwClientIter aIter( *pFldType );
312 SwClient* pLast;
313 const SwTxtFld* pTxtFld;
314
315 for( pLast = aIter.First( TYPE(SwFmtFld)); pLast; pLast = aIter.Next() )
316 if( 0 != ( pTxtFld = ((SwFmtFld*)pLast)->GetTxtFld() ) &&
317 pTxtFld->GetTxtNode().GetNodes().IsDocNodes() )
318 {
319 SwNodeIndex aIdx( pTxtFld->GetTxtNode() );
320 _PostItFld* pNew = new _PostItFld( aIdx, pTxtFld );
321 rSrtLst.Insert( pNew );
322 }
323 }
324 }
325
326 /******************************************************************************
327 * Methode : void lcl_FormatPostIt( IDocumentContentOperations* pIDCO, SwPaM& aPam, ...
328 * Beschreibung:
329 * Erstellt : OK 07.11.94 10:20
330 * Aenderung :
331 ******************************************************************************/
332
333
334 void lcl_FormatPostIt( IDocumentContentOperations* pIDCO, SwPaM& aPam, SwPostItField* pField,
335 USHORT nPageNo, USHORT nLineNo )
336 {
337 static char __READONLY_DATA sTmp[] = " : ";
338
339 ASSERT( ViewShell::GetShellRes(), "missing ShellRes" );
340
341 String aStr( ViewShell::GetShellRes()->aPostItPage );
342 aStr.AppendAscii(sTmp);
343
344 aStr += XubString::CreateFromInt32( nPageNo );
345 aStr += ' ';
346 if( nLineNo )
347 {
348 aStr += ViewShell::GetShellRes()->aPostItLine;
349 aStr.AppendAscii(sTmp);
350 aStr += XubString::CreateFromInt32( nLineNo );
351 aStr += ' ';
352 }
353 aStr += ViewShell::GetShellRes()->aPostItAuthor;
354 aStr.AppendAscii(sTmp);
355 aStr += pField->GetPar1();
356 aStr += ' ';
357 aStr += SvtSysLocale().GetLocaleData().getDate( pField->GetDate() );
358 pIDCO->Insert( aPam, aStr, true );
359
360 pIDCO->SplitNode( *aPam.GetPoint(), false );
361 aStr = pField->GetPar2();
362 #if defined( WIN ) || defined( WNT ) || defined( PM2 )
363 // Bei Windows und Co alle CR rausschmeissen
364 aStr.EraseAllChars( '\r' );
365 #endif
366 pIDCO->Insert( aPam, aStr, true );
367 pIDCO->SplitNode( *aPam.GetPoint(), false );
368 pIDCO->SplitNode( *aPam.GetPoint(), false );
369 }
370
371 /******************************************************************************
372 * Methode : void lcl_PrintPostIts( ViewShell* pPrtShell )
373 * Beschreibung:
374 * Erstellt : OK 07.11.94 10:21
375 * Aenderung : MA 10. May. 95
376 ******************************************************************************/
377
378
379 void lcl_PrintPostIts( ViewShell* pPrtShell, const XubString& rJobName,
380 BOOL& rStartJob, int& rJobStartError, BOOL bReverse)
381 {
382 // Formatieren und Ausdrucken
383 pPrtShell->CalcLayout();
384
385 SfxPrinter* pPrn = pPrtShell->getIDocumentDeviceAccess()->getPrinter( false );
386
387 //Das Druckdokument ist ein default Dokument, mithin arbeitet es auf der
388 //StandardSeite.
389 SwFrm *pPage = pPrtShell->GetLayout()->Lower();
390
391 SwPrtOptSave aPrtSave( pPrn );
392
393 pPrn->SetOrientation( ORIENTATION_PORTRAIT );
394 pPrn->SetPaperBin( pPage->GetAttrSet()->GetPaperBin().GetValue() );
395
396 if( !rStartJob && JOBSET_ERR_DEFAULT == rJobStartError &&
397 rJobName.Len() )
398 {
399 if( !pPrn->IsJobActive() )
400 {
401 rStartJob = pPrn->StartJob( rJobName );
402 if( !rStartJob )
403 {
404 rJobStartError = JOBSET_ERR_ERROR;
405 return;
406 }
407 }
408 pPrtShell->InitPrt( pPrn );
409 rJobStartError = JOBSET_ERR_ISSTARTET;
410 }
411
412 // Wir koennen auch rueckwaerts:
413 if ( bReverse )
414 pPage = pPrtShell->GetLayout()->GetLastPage();
415
416 while( pPage )
417 {
418 //Mag der Anwender noch?, Abbruch erst in Prt()
419 GetpApp()->Reschedule();
420 ::SetSwVisArea( pPrtShell, pPage->Frm() );
421 pPrn->StartPage();
422 pPage->GetUpper()->Paint( pPage->Frm() );
423 // SFX_APP()->SpoilDemoOutput( *pPrtShell->GetOut(), pPage->Frm().SVRect());
424 SwPaintQueue::Repaint();
425 pPrn->EndPage();
426 pPage = bReverse ? pPage->GetPrev() : pPage->GetNext();
427 }
428 }
429
430 /******************************************************************************
431 * Methode : void lcl_PrintPostItsEndDoc( ViewShell* pPrtShell, ...
432 * Beschreibung:
433 * Erstellt : OK 07.11.94 10:21
434 * Aenderung : MA 10. May. 95
435 ******************************************************************************/
436
437
438 void lcl_PrintPostItsEndDoc( ViewShell* pPrtShell,
439 _SetGetExpFlds& rPostItFields, MultiSelection &rMulti,
440 const XubString& rJobName, BOOL& rStartJob, int& rJobStartError,
441 BOOL bRgt, BOOL bLft, BOOL bRev )
442 {
443 USHORT nPostIts = rPostItFields.Count();
444 if( !nPostIts )
445 // Keine Arbeit
446 return;
447
448 SET_CURR_SHELL( pPrtShell );
449
450 SwDoc* pPrtDoc = pPrtShell->GetDoc();
451
452 // Dokument leeren und ans Dokumentende gehen
453 SwPaM aPam( pPrtDoc->GetNodes().GetEndOfContent() );
454 aPam.Move( fnMoveBackward, fnGoDoc );
455 aPam.SetMark();
456 aPam.Move( fnMoveForward, fnGoDoc );
457 pPrtDoc->Delete( aPam );
458
459 for( USHORT i = 0, nVirtPg, nLineNo; i < nPostIts; ++i )
460 {
461 _PostItFld& rPostIt = (_PostItFld&)*rPostItFields[ i ];
462 if( rPostIt.GetPageNo( rMulti, bRgt, bLft, nVirtPg, nLineNo ) )
463 lcl_FormatPostIt( pPrtShell->GetDoc(), aPam,
464 rPostIt.GetPostIt(), nVirtPg, nLineNo );
465 }
466
467 lcl_PrintPostIts( pPrtShell, rJobName, rStartJob, rJobStartError, bRev );
468 }
469
470 /******************************************************************************
471 * Methode : void lcl_PrintPostItsEndPage( ViewShell* pPrtShell, ...
472 * Beschreibung:
473 * Erstellt : OK 07.11.94 10:22
474 * Aenderung :
475 ******************************************************************************/
476
477
478 void lcl_PrintPostItsEndPage( ViewShell* pPrtShell,
479 _SetGetExpFlds& rPostItFields, USHORT nPageNo, MultiSelection &rMulti,
480 const XubString& rJobName, BOOL& rStartJob, int& rJobStartError,
481 BOOL bRgt, BOOL bLft, BOOL bRev )
482 {
483 USHORT nPostIts = rPostItFields.Count();
484 if( !nPostIts )
485 // Keine Arbeit
486 return;
487
488 SET_CURR_SHELL( pPrtShell );
489
490 USHORT i = 0, nVirtPg, nLineNo;
491 while( ( i < nPostIts ) &&
492 ( nPageNo != ((_PostItFld&)*rPostItFields[ i ]).
493 GetPageNo( rMulti,bRgt, bLft, nVirtPg, nLineNo )))
494 ++i;
495 if(i == nPostIts)
496 // Nix zu drucken
497 return;
498
499 SwDoc* pPrtDoc = pPrtShell->GetDoc();
500
501 // Dokument leeren und ans Dokumentende gehen
502 SwPaM aPam( pPrtDoc->GetNodes().GetEndOfContent() );
503 aPam.Move( fnMoveBackward, fnGoDoc );
504 aPam.SetMark();
505 aPam.Move( fnMoveForward, fnGoDoc );
506 pPrtDoc->Delete( aPam );
507
508 while( i < nPostIts )
509 {
510 _PostItFld& rPostIt = (_PostItFld&)*rPostItFields[ i ];
511 if( nPageNo == rPostIt.GetPageNo( rMulti, bRgt, bLft, nVirtPg, nLineNo ) )
512 lcl_FormatPostIt( pPrtShell->GetDoc(), aPam,
513 rPostIt.GetPostIt(), nVirtPg, nLineNo );
514 ++i;
515 }
516 lcl_PrintPostIts( pPrtShell, rJobName, rStartJob, rJobStartError, bRev );
517 }
518
519 /******************************************************************************
520 * Methode : void ViewShell::InitPrt( SfxPrinter *pNew, OutputDevice *pPDFOut )
521 * Beschreibung:
522 * Erstellt : OK 07.11.94 10:22
523 * Aenderung :
524 ******************************************************************************/
525
526 void ViewShell::InitPrt( SfxPrinter *pPrt, OutputDevice *pPDFOut )
527 {
528 //Fuer den Printer merken wir uns einen negativen Offset, der
529 //genau dem Offset de OutputSize entspricht. Das ist notwendig,
530 //weil unser Ursprung der linken ober Ecke der physikalischen
531 //Seite ist, die Ausgaben (SV) aber den Outputoffset als Urstprung
532 //betrachten.
533 OutputDevice *pTmpDev = pPDFOut ? pPDFOut : (OutputDevice *) pPrt;
534 if ( pTmpDev )
535 {
536 aPrtOffst = pPrt ? pPrt->GetPageOffset() : Point();
537
538 aPrtOffst += pTmpDev->GetMapMode().GetOrigin();
539 MapMode aMapMode( pTmpDev->GetMapMode() );
540 aMapMode.SetMapUnit( MAP_TWIP );
541 pTmpDev->SetMapMode( aMapMode );
542 pTmpDev->SetLineColor();
543 pTmpDev->SetFillColor();
544 }
545 else
546 aPrtOffst.X() = aPrtOffst.Y() = 0;
547
548 if ( !pWin )
549 pOut = pTmpDev; //Oder was sonst?
550 }
551
552 /******************************************************************************
553 * Methode : void ViewShell::ChgAllPageOrientation
554 * Erstellt : MA 08. Aug. 95
555 * Aenderung :
556 ******************************************************************************/
557
558
559 void ViewShell::ChgAllPageOrientation( USHORT eOri )
560 {
561 ASSERT( nStartAction, "missing an Action" );
562 SET_CURR_SHELL( this );
563
564 USHORT nAll = GetDoc()->GetPageDescCnt();
565 BOOL bNewOri = Orientation(eOri) == ORIENTATION_PORTRAIT ? FALSE : TRUE;
566
567 for( USHORT i = 0; i < nAll; ++ i )
568 {
569 const SwPageDesc& rOld =
570 const_cast<const SwDoc *>(GetDoc())->GetPageDesc( i );
571
572 if( rOld.GetLandscape() != bNewOri )
573 {
574 SwPageDesc aNew( rOld );
575 const sal_Bool bDoesUndo( GetDoc()->DoesUndo() );
576 GetDoc()->DoUndo( sal_False );
577 GetDoc()->CopyPageDesc(rOld, aNew);
578 GetDoc()->DoUndo( bDoesUndo );
579 aNew.SetLandscape( bNewOri );
580 SwFrmFmt& rFmt = aNew.GetMaster();
581 SwFmtFrmSize aSz( rFmt.GetFrmSize() );
582 // Groesse anpassen.
583 // PORTRAIT -> Hoeher als Breit
584 // LANDSCAPE -> Breiter als Hoch
585 // Hoehe ist die VarSize, Breite ist die FixSize (per Def.)
586 if( bNewOri ? aSz.GetHeight() > aSz.GetWidth()
587 : aSz.GetHeight() < aSz.GetWidth() )
588 {
589 SwTwips aTmp = aSz.GetHeight();
590 aSz.SetHeight( aSz.GetWidth() );
591 aSz.SetWidth( aTmp );
592 rFmt.SetFmtAttr( aSz );
593 }
594 GetDoc()->ChgPageDesc( i, aNew );
595 }
596 }
597 }
598
599 /******************************************************************************
600 * Methode : void ViewShell::ChgAllPageOrientation
601 * Erstellt : MA 08. Aug. 95
602 * Aenderung :
603 ******************************************************************************/
604
605
606 void ViewShell::ChgAllPageSize( Size &rSz )
607 {
608 ASSERT( nStartAction, "missing an Action" );
609 SET_CURR_SHELL( this );
610
611 SwDoc* pMyDoc = GetDoc();
612 USHORT nAll = pMyDoc->GetPageDescCnt();
613
614 for( USHORT i = 0; i < nAll; ++i )
615 {
616 const SwPageDesc &rOld = const_cast<const SwDoc *>(pMyDoc)->GetPageDesc( i );
617 SwPageDesc aNew( rOld );
618 const sal_Bool bDoesUndo( GetDoc()->DoesUndo() );
619 GetDoc()->DoUndo( sal_False );
620 GetDoc()->CopyPageDesc( rOld, aNew );
621 GetDoc()->DoUndo( bDoesUndo );
622 SwFrmFmt& rPgFmt = aNew.GetMaster();
623 Size aSz( rSz );
624 const BOOL bOri = aNew.GetLandscape();
625 if( bOri ? aSz.Height() > aSz.Width()
626 : aSz.Height() < aSz.Width() )
627 {
628 SwTwips aTmp = aSz.Height();
629 aSz.Height() = aSz.Width();
630 aSz.Width() = aTmp;
631 }
632
633 SwFmtFrmSize aFrmSz( rPgFmt.GetFrmSize() );
634 aFrmSz.SetSize( aSz );
635 rPgFmt.SetFmtAttr( aFrmSz );
636 pMyDoc->ChgPageDesc( i, aNew );
637 }
638 }
639
640 /******************************************************************************
641 * Methode : void ViewShell::CalcPagesForPrint( short nMax, BOOL ...
642 * Beschreibung:
643 * Erstellt : OK 04.11.94 15:33
644 * Aenderung : MA 07. Jun. 95
645 ******************************************************************************/
646
647
648
649 void lcl_SetState( SfxProgress& rProgress, ULONG nPage, ULONG nMax,
650 const XubString *pStr, ULONG nAct, ULONG nCnt, ULONG nOffs, ULONG nPageNo )
651 {
652 XubString aTmp = XubString::CreateFromInt64( nPageNo );
653 if( pStr )
654 {
655 aTmp += ' ';
656 aTmp += *pStr;
657 if( nCnt )
658 {
659 nMax *= 2;
660 rProgress.SetStateText( (nAct-1)*nMax+nPage+nOffs,
661 aTmp, nCnt*nMax );
662 }
663 else
664 rProgress.SetStateText( nPage, aTmp, nMax );
665 }
666 else
667 {
668 aTmp += ' '; aTmp += '('; aTmp += XubString::CreateFromInt64( nPage );
669 aTmp += '/'; aTmp += XubString::CreateFromInt64( nMax ); aTmp += ')';
670 rProgress.SetStateText( nPage, aTmp, nMax );
671 }
672 }
673
674
675
676 void ViewShell::CalcPagesForPrint( USHORT nMax, SfxProgress* pProgress,
677 const XubString* pStr, ULONG nMergeAct, ULONG nMergeCnt )
678 {
679 SET_CURR_SHELL( this );
680
681 //Seitenweise durchformatieren, by the way kann die Statusleiste
682 //angetriggert werden, damit der Anwender sieht worauf er wartet.
683 //Damit der Vorgang moeglichst transparent gestaltet werden kann
684 //Versuchen wir mal eine Schaetzung.
685 SfxPrinter* pPrt = getIDocumentDeviceAccess()->getPrinter( false );
686 BOOL bPrtJob = pPrt ? pPrt->IsJobActive() : FALSE;
687 SwRootFrm* pLayout = GetLayout();
688 ULONG nStatMax = pLayout->GetPageNum();
689
690 const SwFrm *pPage = pLayout->Lower();
691 SwLayAction aAction( pLayout, Imp() );
692
693 if( pProgress )
694 {
695 // HACK, damit die Anzeige sich nicht verschluckt.
696 const XubString aTmp( SW_RES( STR_STATSTR_FORMAT ) );
697 pProgress->SetText( aTmp );
698 lcl_SetState( *pProgress, 1, nStatMax, pStr, nMergeAct, nMergeCnt, 0, 1 );
699 pProgress->Reschedule(); //Mag der Anwender noch oder hat er genug?
700 aAction.SetProgress(pProgress);
701 }
702
703 pLayout->StartAllAction();
704 for ( USHORT i = 1; pPage && i <= nMax; pPage = pPage->GetNext(), ++i )
705 {
706 if ( ( bPrtJob && !pPrt->IsJobActive() ) || Imp()->IsStopPrt() )
707 break;
708
709 if( pProgress )
710 {
711 //HACK, damit die Anzeige sich nicht verschluckt.
712 if ( i > nStatMax ) nStatMax = i;
713 lcl_SetState( *pProgress, i, nStatMax, pStr, nMergeAct, nMergeCnt, 0, i );
714 pProgress->Reschedule(); //Mag der Anwender noch oder hat er genug?
715 }
716
717 if ( ( bPrtJob && !pPrt->IsJobActive() ) || Imp()->IsStopPrt() )
718 break;
719
720 pPage->Calc();
721 SwRect aOldVis( VisArea() );
722 aVisArea = pPage->Frm();
723 Imp()->SetFirstVisPageInvalid();
724 aAction.Reset();
725 aAction.SetPaint( FALSE );
726 aAction.SetWaitAllowed( FALSE );
727 aAction.SetReschedule( TRUE );
728
729 aAction.Action();
730
731 aVisArea = aOldVis; //Zuruecksetzen wg. der Paints!
732 Imp()->SetFirstVisPageInvalid();
733 SwPaintQueue::Repaint();
734
735 if ( pProgress )
736 pProgress->Reschedule(); //Mag der Anwender noch oder hat er genug?
737 }
738
739 if (pProgress)
740 aAction.SetProgress( NULL );
741
742 pLayout->EndAllAction();
743 }
744
745 /******************************************************************************/
746
747 SwDoc * ViewShell::CreatePrtDoc( SfxPrinter* pPrt, SfxObjectShellRef &rDocShellRef)
748 {
749 ASSERT( this->IsA( TYPE(SwFEShell) ),"ViewShell::Prt for FEShell only");
750 SwFEShell* pFESh = (SwFEShell*)this;
751 // Wir bauen uns ein neues Dokument
752 SwDoc *pPrtDoc = new SwDoc;
753 pPrtDoc->acquire();
754 pPrtDoc->SetRefForDocShell( boost::addressof(rDocShellRef) );
755 pPrtDoc->LockExpFlds();
756
757 // Der Drucker wird uebernommen
758 if (pPrt)
759 pPrtDoc->setPrinter( pPrt, true, true );
760
761 const SfxPoolItem* pCpyItem;
762 const SfxItemPool& rPool = GetAttrPool();
763 for( USHORT nWh = POOLATTR_BEGIN; nWh < POOLATTR_END; ++nWh )
764 if( 0 != ( pCpyItem = rPool.GetPoolDefaultItem( nWh ) ) )
765 pPrtDoc->GetAttrPool().SetPoolDefaultItem( *pCpyItem );
766
767 // JP 29.07.99 - Bug 67951 - set all Styles from the SourceDoc into
768 // the PrintDoc - will be replaced!
769 pPrtDoc->ReplaceStyles( *GetDoc() );
770
771 SwShellCrsr *pActCrsr = pFESh->_GetCrsr();
772 SwShellCrsr *pFirstCrsr = dynamic_cast<SwShellCrsr*>(pActCrsr->GetNext());
773 if( !pActCrsr->HasMark() ) // bei Multiselektion kann der aktuelle Cursor leer sein
774 {
775 pActCrsr = dynamic_cast<SwShellCrsr*>(pActCrsr->GetPrev());
776 }
777
778 // Die Y-Position der ersten Selektion
779 const Point aSelPoint = pFESh->IsTableMode() ?
780 pFESh->GetTableCrsr()->GetSttPos() :
781 pFirstCrsr->GetSttPos();
782
783 const SwPageFrm* pPage = GetLayout()->GetPageAtPos( aSelPoint );
784
785 // und ihren Seitendescribtor
786 const SwPageDesc* pPageDesc = pPrtDoc->FindPageDescByName(
787 pPage->GetPageDesc()->GetName() );
788
789 if( !pFESh->IsTableMode() && pActCrsr->HasMark() )
790 { // Am letzten Absatz die Absatzattribute richten:
791 SwNodeIndex aNodeIdx( *pPrtDoc->GetNodes().GetEndOfContent().StartOfSectionNode() );
792 SwTxtNode* pTxtNd = pPrtDoc->GetNodes().GoNext( &aNodeIdx )->GetTxtNode();
793 SwCntntNode *pLastNd =
794 pActCrsr->GetCntntNode( (*pActCrsr->GetMark()) <= (*pActCrsr->GetPoint()) );
795 // Hier werden die Absatzattribute des ersten Absatzes uebertragen
796 if( pLastNd && pLastNd->IsTxtNode() )
797 ((SwTxtNode*)pLastNd)->CopyCollFmt( *pTxtNd );
798 }
799
800 // es wurde in der CORE eine neu angelegt (OLE-Objekte kopiert!)
801 // if( aDocShellRef.Is() )
802 // SwDataExchange::InitOle( aDocShellRef, pPrtDoc );
803 // und fuellen es mit dem selektierten Bereich
804 pFESh->Copy( pPrtDoc );
805
806 //Jetzt noch am ersten Absatz die Seitenvorlage setzen
807 {
808 SwNodeIndex aNodeIdx( *pPrtDoc->GetNodes().GetEndOfContent().StartOfSectionNode() );
809 SwCntntNode* pCNd = pPrtDoc->GetNodes().GoNext( &aNodeIdx ); // gehe zum 1. ContentNode
810 if( pFESh->IsTableMode() )
811 {
812 SwTableNode* pTNd = pCNd->FindTableNode();
813 if( pTNd )
814 pTNd->GetTable().GetFrmFmt()->SetFmtAttr( SwFmtPageDesc( pPageDesc ) );
815 }
816 else
817 {
818 pCNd->SetAttr( SwFmtPageDesc( pPageDesc ) );
819 if( pFirstCrsr->HasMark() )
820 {
821 SwTxtNode *pTxtNd = pCNd->GetTxtNode();
822 if( pTxtNd )
823 {
824 SwCntntNode *pFirstNd =
825 pFirstCrsr->GetCntntNode( (*pFirstCrsr->GetMark()) > (*pFirstCrsr->GetPoint()) );
826 // Hier werden die Absatzattribute des ersten Absatzes uebertragen
827 if( pFirstNd && pFirstNd->IsTxtNode() )
828 ((SwTxtNode*)pFirstNd)->CopyCollFmt( *pTxtNd );
829 }
830 }
831 }
832 }
833 return pPrtDoc;
834 }
835 SwDoc * ViewShell::FillPrtDoc( SwDoc *pPrtDoc, const SfxPrinter* pPrt)
836 {
837 ASSERT( this->IsA( TYPE(SwFEShell) ),"ViewShell::Prt for FEShell only");
838 SwFEShell* pFESh = (SwFEShell*)this;
839 // Wir bauen uns ein neues Dokument
840 // SwDoc *pPrtDoc = new SwDoc;
841 // pPrtDoc->acquire();
842 // pPrtDoc->SetRefForDocShell( boost::addressof(rDocShellRef) );
843 pPrtDoc->LockExpFlds();
844
845 // Der Drucker wird uebernommen
846 //! Make a copy of it since it gets destroyed with the temporary document
847 //! used for PDF export
848 if (pPrt)
849 pPrtDoc->setPrinter( new SfxPrinter(*pPrt), true, true );
850
851 const SfxPoolItem* pCpyItem;
852 const SfxItemPool& rPool = GetAttrPool();
853 for( USHORT nWh = POOLATTR_BEGIN; nWh < POOLATTR_END; ++nWh )
854 if( 0 != ( pCpyItem = rPool.GetPoolDefaultItem( nWh ) ) )
855 pPrtDoc->GetAttrPool().SetPoolDefaultItem( *pCpyItem );
856
857 // JP 29.07.99 - Bug 67951 - set all Styles from the SourceDoc into
858 // the PrintDoc - will be replaced!
859 pPrtDoc->ReplaceStyles( *GetDoc() );
860
861 SwShellCrsr *pActCrsr = pFESh->_GetCrsr();
862 SwShellCrsr *pFirstCrsr = dynamic_cast<SwShellCrsr*>(pActCrsr->GetNext());
863 if( !pActCrsr->HasMark() ) // bei Multiselektion kann der aktuelle Cursor leer sein
864 {
865 pActCrsr = dynamic_cast<SwShellCrsr*>(pActCrsr->GetPrev());
866 }
867
868 // Die Y-Position der ersten Selektion
869 // Die Y-Position der ersten Selektion
870 const Point aSelPoint = pFESh->IsTableMode() ?
871 pFESh->GetTableCrsr()->GetSttPos() :
872 pFirstCrsr->GetSttPos();
873
874 const SwPageFrm* pPage = GetLayout()->GetPageAtPos( aSelPoint );
875
876 // und ihren Seitendescribtor
877 const SwPageDesc* pPageDesc = pPrtDoc->FindPageDescByName(
878 pPage->GetPageDesc()->GetName() );
879
880 if( !pFESh->IsTableMode() && pActCrsr->HasMark() )
881 { // Am letzten Absatz die Absatzattribute richten:
882 SwNodeIndex aNodeIdx( *pPrtDoc->GetNodes().GetEndOfContent().StartOfSectionNode() );
883 SwTxtNode* pTxtNd = pPrtDoc->GetNodes().GoNext( &aNodeIdx )->GetTxtNode();
884 SwCntntNode *pLastNd =
885 pActCrsr->GetCntntNode( (*pActCrsr->GetMark()) <= (*pActCrsr->GetPoint()) );
886 // Hier werden die Absatzattribute des ersten Absatzes uebertragen
887 if( pLastNd && pLastNd->IsTxtNode() )
888 ((SwTxtNode*)pLastNd)->CopyCollFmt( *pTxtNd );
889 }
890
891 // es wurde in der CORE eine neu angelegt (OLE-Objekte kopiert!)
892 // if( aDocShellRef.Is() )
893 // SwDataExchange::InitOle( aDocShellRef, pPrtDoc );
894 // und fuellen es mit dem selektierten Bereich
895 pFESh->Copy( pPrtDoc );
896
897 //Jetzt noch am ersten Absatz die Seitenvorlage setzen
898 {
899 SwNodeIndex aNodeIdx( *pPrtDoc->GetNodes().GetEndOfContent().StartOfSectionNode() );
900 SwCntntNode* pCNd = pPrtDoc->GetNodes().GoNext( &aNodeIdx ); // gehe zum 1. ContentNode
901 if( pFESh->IsTableMode() )
902 {
903 SwTableNode* pTNd = pCNd->FindTableNode();
904 if( pTNd )
905 pTNd->GetTable().GetFrmFmt()->SetFmtAttr( SwFmtPageDesc( pPageDesc ) );
906 }
907 else
908 {
909 pCNd->SetAttr( SwFmtPageDesc( pPageDesc ) );
910 if( pFirstCrsr->HasMark() )
911 {
912 SwTxtNode *pTxtNd = pCNd->GetTxtNode();
913 if( pTxtNd )
914 {
915 SwCntntNode *pFirstNd =
916 pFirstCrsr->GetCntntNode( (*pFirstCrsr->GetMark()) > (*pFirstCrsr->GetPoint()) );
917 // Hier werden die Absatzattribute des ersten Absatzes uebertragen
918 if( pFirstNd && pFirstNd->IsTxtNode() )
919 ((SwTxtNode*)pFirstNd)->CopyCollFmt( *pTxtNd );
920 }
921 }
922 }
923 }
924 return pPrtDoc;
925 }
926
927 /******************************************************************************
928 * Methode : void ViewShell::Prt( const SwPrtOptions& rOptions,
929 * SfxProgress* pProgress,
930 * OutputDevice* pPDFOut )
931 * Beschreibung:
932 * Erstellt : OK 04.11.94 15:33
933 * Aenderung : MA 10. May. 95
934 ******************************************************************************/
935
936
937 BOOL ViewShell::Prt( SwPrtOptions& rOptions, SfxProgress* pProgress,
938 OutputDevice* pPDFOut )
939 {
940 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
941 //Immer die Druckroutine in viewpg.cxx (fuer Seitenvorschau) mitpflegen!!
942 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
943 ASSERT( pPDFOut || pProgress, "Printing without progress bar!" )
944
945 BOOL bStartJob = FALSE;
946
947 //! Note: Since for PDF export of (multi-)selection a temporary
948 //! document is created that contains only the selects parts,
949 //! and thus that document is to printed in whole the,
950 //! rOptions.bPrintSelection parameter will be false.
951 BOOL bSelection = rOptions.bPrintSelection;
952
953 MultiSelection aMulti( rOptions.aMulti );
954
955 if ( !aMulti.GetSelectCount() )
956 return bStartJob;
957
958 Range aPages( aMulti.FirstSelected(), aMulti.LastSelected() );
959 if ( aPages.Max() > USHRT_MAX )
960 aPages.Max() = USHRT_MAX;
961
962 ASSERT( aPages.Min() > 0,
963 "Seite 0 Drucken?" );
964 ASSERT( aPages.Min() <= aPages.Max(),
965 "MinSeite groesser MaxSeite." );
966
967 SfxPrinter* pPrt = 0; //!! will be 0 for PDF export !!
968 if (pPDFOut)
969 pPDFOut->Push();
970 else
971 {
972 // wenn kein Drucker vorhanden ist, wird nicht gedruckt
973 pPrt = getIDocumentDeviceAccess()->getPrinter( false );
974 if( !pPrt || !pPrt->GetName().Len() )
975 {
976 ASSERT( FALSE, "Drucken ohne Drucker?" );
977 return bStartJob;
978 }
979
980 if( !rOptions.GetJobName().Len() && !pPrt->IsJobActive() )
981 return bStartJob;
982 }
983
984 // Einstellungen am Drucker merken
985 SwPrtOptSave aPrtSave( pPrt );
986
987 OutputDevice *pPrtOrPDFOut = pPDFOut ? pPDFOut : (OutputDevice *) pPrt;
988
989 // eine neue Shell fuer den Printer erzeugen
990 ViewShell *pShell;
991 SwDoc *pPrtDoc;
992
993 //!! muss warum auch immer hier in diesem scope existieren !!
994 //!! (h?ngt mit OLE Objekten im Dokument zusammen.)
995 SfxObjectShellRef aDocShellRef;
996
997 // PDF export for (multi-)selection has already generated a temporary document
998 // with the selected text. (see XRenderable implementation in unotxdoc.cxx)
999 // Thus we like to go in the 'else' part here in that case.
1000 // Is is implemented this way because PDF export calls this Prt function
1001 // once per page and we do not like to always have the temporary document
1002 // to be created that often here in the 'then' part.
1003 if ( bSelection )
1004 {
1005 pPrtDoc = CreatePrtDoc( pPrt, aDocShellRef );
1006
1007 // eine ViewShell darauf
1008 OutputDevice *pTmpDev = pPDFOut ? pPDFOut : 0;
1009 pShell = new ViewShell( *pPrtDoc, 0, pOpt, pTmpDev );
1010 pPrtDoc->SetRefForDocShell( 0 );
1011 }
1012 else
1013 {
1014 pPrtDoc = GetDoc();
1015 OutputDevice *pTmpDev = pPDFOut ? pPDFOut : 0;
1016 pShell = new ViewShell( *this, 0, pTmpDev );
1017 }
1018
1019 { //Zusaetzlicher Scope, damit die CurrShell vor dem zerstoeren der
1020 //Shell zurueckgesetzt wird.
1021
1022 SET_CURR_SHELL( pShell );
1023
1024 if ( pProgress )
1025 {
1026 Link aLnk = LINK(pShell->Imp(), SwViewImp, SetStopPrt);
1027 ((SfxPrintProgress *)pProgress)->SetCancelHdl(aLnk);
1028 }
1029
1030 //JP 01.02.99: das ReadOnly Flag wird NIE mitkopiert; Bug 61335
1031 if( pOpt->IsReadonly() )
1032 pShell->pOpt->SetReadonly( TRUE );
1033
1034 // save options at draw view:
1035 SwDrawViewSave aDrawViewSave( pShell->GetDrawView() );
1036
1037 pShell->PrepareForPrint( rOptions );
1038
1039 XubString* pStr = 0;
1040 ULONG nMergeAct = rOptions.nMergeAct, nMergeCnt = rOptions.nMergeCnt;
1041 if ( pProgress )
1042 {
1043 if( nMergeAct )
1044 {
1045 pStr = new SW_RESSTR(STR_STATSTR_LETTER);
1046 *pStr += ' ';
1047 *pStr += XubString::CreateFromInt64( nMergeAct );
1048 if( nMergeCnt )
1049 {
1050 *pStr += '/';
1051 *pStr += XubString::CreateFromInt64( nMergeCnt );
1052 }
1053 }
1054 else
1055 {
1056 ++nMergeAct;
1057 }
1058 }
1059
1060 // Seiten fuers Drucken formatieren
1061 pShell->CalcPagesForPrint( (USHORT)aPages.Max(), pProgress, pStr,
1062 nMergeAct, nMergeCnt );
1063
1064 // Some field types, can require a valid layout
1065 // (expression fields in tables). For these we do an UpdateFlds
1066 // here after calculation of the pages.
1067 // --> FME 2004-06-21 #i9684# For performance reasons, we do not update
1068 // the fields during pdf export.
1069 // #i56195# prevent update of fields (for mail merge)
1070 if ( !pPDFOut && rOptions.bUpdateFieldsInPrinting )
1071 // <--
1072 pShell->UpdateFlds(TRUE);
1073
1074 if( !pShell->Imp()->IsStopPrt() &&
1075 ( pPDFOut || rOptions.GetJobName().Len() || pPrt->IsJobActive()) )
1076 {
1077 BOOL bStop = FALSE;
1078 int nJobStartError = JOBSET_ERR_DEFAULT;
1079
1080 USHORT nCopyCnt = rOptions.bCollate ? rOptions.nCopyCount : 1;
1081
1082 USHORT nPrintCount = 1;
1083 XubString sJobName( rOptions.GetJobName() );
1084
1085 for ( USHORT nCnt = 0; !bStop && nCnt < nCopyCnt; nCnt++ )
1086 {
1087 const SwPageFrm *pStPage = (SwPageFrm*)pShell->GetLayout()->Lower();
1088 const SwFrm *pEndPage = pStPage;
1089
1090 USHORT nFirstPageNo = 0;
1091 USHORT nLastPageNo = 0;
1092 USHORT nPageNo = 1;
1093
1094 if (pPrt)
1095 {
1096 if( rOptions.IsPrintSingleJobs() && sJobName.Len() &&
1097 ( bStartJob || rOptions.bJobStartet ) )
1098 {
1099 pPrt->EndJob();
1100 bStartJob = FALSE;
1101 rOptions.bJobStartet = TRUE;
1102
1103 // Reschedule statt Yield, da Yield keine Events abarbeitet
1104 // und es sonst eine Endlosschleife gibt.
1105 while( pPrt->IsPrinting() && pProgress )
1106 pProgress->Reschedule();
1107
1108 sJobName = rOptions.MakeNextJobName();
1109 nJobStartError = JOBSET_ERR_DEFAULT;
1110 }
1111 }
1112
1113 for( USHORT i = 1; i <= (USHORT)aPages.Max(); ++i )
1114 {
1115 if( i < (USHORT)aPages.Min() )
1116 {
1117 if( !pStPage->GetNext() )
1118 break;
1119 pStPage = (SwPageFrm*)pStPage->GetNext();
1120 pEndPage= pStPage;
1121 }
1122 else if( i == (USHORT)aPages.Min() )
1123 {
1124 nFirstPageNo = i;
1125 nLastPageNo = nFirstPageNo;
1126 if( !pStPage->GetNext() || (i == (USHORT)aPages.Max()) )
1127 break;
1128 pEndPage = pStPage->GetNext();
1129 }
1130 else if( i > (USHORT)aPages.Min() )
1131 {
1132 nLastPageNo = i;
1133 if( !pEndPage->GetNext() || (i == (USHORT)aPages.Max()) )
1134 break;
1135 pEndPage = pEndPage->GetNext();
1136 }
1137 }
1138
1139 if( !nFirstPageNo )
1140 {
1141 bStop = TRUE;
1142 break;
1143 }
1144
1145 // HACK: Hier muss von der MultiSelection noch eine akzeptable Moeglichkeit
1146 // geschaffen werden, alle Seiten von Seite x an zu deselektieren.
1147 // Z.B. durch SetTotalRange ....
1148
1149 // aMulti.Select( Range( nLastPageNo+1, SELECTION_MAX ), FALSE );
1150 MultiSelection aTmpMulti( Range( 1, nLastPageNo ) );
1151 long nTmpIdx = aMulti.FirstSelected();
1152 static long nEndOfSelection = SFX_ENDOFSELECTION;
1153 while ( nEndOfSelection != nTmpIdx && nTmpIdx <= long(nLastPageNo) )
1154 {
1155 aTmpMulti.Select( nTmpIdx );
1156 nTmpIdx = aMulti.NextSelected();
1157 }
1158 aMulti = aTmpMulti;
1159 // Ende des HACKs
1160
1161 const USHORT nSelCount = USHORT(aMulti.GetSelectCount()
1162 /* * nCopyCnt*/);
1163
1164 if ( pProgress )
1165 {
1166 pProgress->SetText( SW_RESSTR(STR_STATSTR_PRINT) );
1167 lcl_SetState( *pProgress, 1, nSelCount, pStr,
1168 nMergeAct, nMergeCnt, nSelCount, 1 );
1169 }
1170
1171 if ( rOptions.bPrintReverse )
1172 {
1173 const SwFrm *pTmp = pStPage;
1174 pStPage = (SwPageFrm*)pEndPage;
1175 pEndPage = pTmp;
1176 nPageNo = nLastPageNo;
1177 }
1178 else
1179 nPageNo = nFirstPageNo;
1180
1181 // PostitListe holen
1182 _SetGetExpFlds aPostItFields;
1183 SwDoc* pPostItDoc = 0;
1184 ViewShell* pPostItShell = 0;
1185 if( rOptions.nPrintPostIts != POSTITS_NONE )
1186 {
1187 lcl_GetPostIts( pDoc, aPostItFields );
1188 pPostItDoc = new SwDoc;
1189 if (pPrt)
1190 pPostItDoc->setPrinter( pPrt, true, true );
1191 pPostItShell = new ViewShell( *pPostItDoc, 0,
1192 pShell->GetViewOptions() );
1193 // Wenn PostIts am Dokumentenende gedruckt werden sollen,
1194 // die Druckreihenfolge allerdings umgekehrt ist, dann hier
1195 if ( ( rOptions.nPrintPostIts == POSTITS_ENDDOC ) &&
1196 rOptions.bPrintReverse )
1197 lcl_PrintPostItsEndDoc( pPostItShell, aPostItFields,
1198 aMulti, sJobName, bStartJob, nJobStartError,
1199 rOptions.bPrintRightPage, rOptions.bPrintLeftPage, TRUE );
1200
1201 }
1202
1203 // aOldMapMode wird fuer das Drucken von Umschlaegen gebraucht.
1204 MapMode aOldMapMode;
1205
1206 const SwPageDesc *pLastPageDesc = NULL;
1207 BOOL bSetOrient = FALSE;
1208 BOOL bSetPaperSz = FALSE;
1209 BOOL bSetPaperBin = FALSE;
1210 BOOL bSetPrt = FALSE;
1211 if (pPrt)
1212 {
1213 bSetOrient = pPrt->HasSupport( SUPPORT_SET_ORIENTATION );
1214 bSetPaperSz = pPrt->HasSupport( SUPPORT_SET_PAPERSIZE );
1215 bSetPaperBin = !rOptions.bPaperFromSetup &&
1216 pPrt->HasSupport( SUPPORT_SET_PAPERBIN );
1217 bSetPrt = bSetOrient || bSetPaperSz || bSetPaperBin;
1218 }
1219
1220 if ( rOptions.nPrintPostIts != POSTITS_ONLY )
1221 {
1222 // --> FME 2005-01-05 #110536# This valiable is used to track
1223 // the number of pages which actually have been printed.
1224 // If nPagesPrinted is odd, we have to send an additional
1225 // empty page to the printer if we are currently in collation
1226 // and duplex mode and there are still some more copies of the
1227 // document to print.
1228 USHORT nPagesPrinted = 0;
1229 // <--
1230
1231 while( pStPage && !bStop )
1232 {
1233 // Mag der Anwender noch ?
1234 if ( pProgress )
1235 pProgress->Reschedule();
1236
1237 if (pPrt)
1238 {
1239 if ( JOBSET_ERR_ERROR == nJobStartError ||
1240 ( !pPrt->IsJobActive() && ( !sJobName.Len() || bStartJob ) ) ||
1241 pShell->Imp()->IsStopPrt() )
1242 {
1243 bStop = TRUE;
1244 break;
1245 }
1246 }
1247
1248 ::SetSwVisArea( pShell, pStPage->Frm(), 0 != pPDFOut );
1249
1250 // wenn wir einen Umschlag drucken wird ein Offset beachtet
1251 if( pStPage->GetFmt()->GetPoolFmtId() == RES_POOLPAGE_JAKET )
1252 {
1253 aOldMapMode = pPrtOrPDFOut->GetMapMode();
1254 Point aNewOrigin = pPrtOrPDFOut->GetMapMode().GetOrigin();
1255 aNewOrigin += rOptions.aOffset;
1256 MapMode aTmp( pPrtOrPDFOut->GetMapMode() );
1257 aTmp.SetOrigin( aNewOrigin );
1258 pPrtOrPDFOut->SetMapMode( aTmp );
1259 }
1260
1261 const BOOL bRightPg = pStPage->OnRightPage();
1262 if( aMulti.IsSelected( nPageNo ) &&
1263 ( (bRightPg && rOptions.bPrintRightPage) ||
1264 (!bRightPg && rOptions.bPrintLeftPage) ) )
1265 {
1266 if ( bSetPrt )
1267 {
1268 // check for empty page
1269 const SwPageFrm& rFormatPage = pStPage->GetFormatPage();
1270
1271 if ( pLastPageDesc != rFormatPage.GetPageDesc() )
1272 {
1273 pLastPageDesc = rFormatPage.GetPageDesc();
1274
1275 const BOOL bLandScp = rFormatPage.GetPageDesc()->GetLandscape();
1276
1277 if( bSetPaperBin ) // Schacht einstellen.
1278 pPrt->SetPaperBin( rFormatPage.GetFmt()->
1279 GetPaperBin().GetValue() );
1280
1281 if (bSetOrient )
1282 {
1283 // Orientation einstellen: Breiter als Hoch
1284 // -> Landscape, sonst -> Portrait.
1285 if( bLandScp )
1286 pPrt->SetOrientation(ORIENTATION_LANDSCAPE);
1287 else
1288 pPrt->SetOrientation(ORIENTATION_PORTRAIT);
1289 }
1290
1291 if (bSetPaperSz )
1292 {
1293 Size aSize = pStPage->Frm().SSize();
1294 if ( bLandScp && bSetOrient )
1295 {
1296 // landscape is always interpreted as a rotation by 90 degrees !
1297 // this leads to non WYSIWIG but at least it prints!
1298 // #i21775#
1299 long nWidth = aSize.Width();
1300 aSize.Width() = aSize.Height();
1301 aSize.Height() = nWidth;
1302 }
1303 Paper ePaper = SvxPaperInfo::GetSvxPaper(aSize,MAP_TWIP,TRUE);
1304 if ( PAPER_USER == ePaper )
1305 pPrt->SetPaperSizeUser( aSize );
1306 else
1307 pPrt->SetPaper( ePaper );
1308 }
1309 }
1310 }
1311
1312 // Wenn PostIts nach Seite gedruckt werden sollen,
1313 // jedoch Reverse eingestellt ist ...
1314 if( rOptions.bPrintReverse &&
1315 rOptions.nPrintPostIts == POSTITS_ENDPAGE )
1316 lcl_PrintPostItsEndPage( pPostItShell, aPostItFields,
1317 nPageNo, aMulti, sJobName, bStartJob, nJobStartError,
1318 rOptions.bPrintRightPage, rOptions.bPrintLeftPage,
1319 rOptions.bPrintReverse );
1320
1321 if ( pProgress )
1322 lcl_SetState( *pProgress, nPrintCount++, nSelCount,
1323 pStr, nMergeAct, nMergeCnt,
1324 nSelCount, nPageNo );
1325
1326 if( !bStartJob && JOBSET_ERR_DEFAULT == nJobStartError
1327 && sJobName.Len() )
1328 {
1329 if( pPrt && !pPrt->IsJobActive() )
1330 {
1331 bStartJob = pPrt->StartJob( sJobName );
1332 if( !bStartJob )
1333 {
1334 nJobStartError = JOBSET_ERR_ERROR;
1335 continue;
1336 }
1337 }
1338
1339 pShell->InitPrt( pPrt, pPDFOut );
1340
1341 ::SetSwVisArea( pShell, pStPage->Frm(), 0 != pPDFOut );
1342 nJobStartError = JOBSET_ERR_ISSTARTET;
1343 }
1344 // --> FME 2005-12-12 #b6354161# Feature - Print empty pages
1345 if ( rOptions.bPrintEmptyPages || pStPage->Frm().Height() )
1346 // <--
1347 {
1348 if (pPrt)
1349 pPrt->StartPage();
1350
1351 pStPage->GetUpper()->Paint( pStPage->Frm() );
1352 ++nPagesPrinted;
1353
1354 if (pPrt)
1355 pPrt->EndPage();
1356 }
1357 SwPaintQueue::Repaint();
1358
1359 // Wenn PostIts nach Seite gedruckt werden sollen ...
1360 if( (!rOptions.bPrintReverse) &&
1361 rOptions.nPrintPostIts == POSTITS_ENDPAGE )
1362 lcl_PrintPostItsEndPage( pPostItShell, aPostItFields,
1363 nPageNo, aMulti, sJobName, bStartJob, nJobStartError,
1364 rOptions.bPrintRightPage, rOptions.bPrintLeftPage,
1365 rOptions.bPrintReverse );
1366 }
1367
1368 // den eventl. fuer Umschlaege modifizierte OutDevOffset wieder
1369 // zuruecksetzen.
1370 if( pStPage->GetFmt()->GetPoolFmtId() == RES_POOLPAGE_JAKET )
1371 pPrtOrPDFOut->SetMapMode( aOldMapMode );
1372
1373 if ( pStPage == pEndPage )
1374 {
1375 // --> FME 2005-01-05 #110536# Print emtpy page if
1376 // we are have an odd page count in collation/duplex
1377 // mode and there are still some copies to print:
1378 if ( pPrt && ( 1 == ( nPagesPrinted % 2 ) ) &&
1379 DUPLEX_ON == pPrt->GetDuplexMode() &&
1380 nCnt + 1 < nCopyCnt )
1381 {
1382 pPrt->StartPage();
1383 pPrt->EndPage();
1384 }
1385 // <--
1386
1387 pStPage = 0;
1388 }
1389 else if ( rOptions.bPrintReverse )
1390 {
1391 --nPageNo;
1392 pStPage = (SwPageFrm*)pStPage->GetPrev();
1393 }
1394 else
1395 { ++nPageNo;
1396 pStPage = (SwPageFrm*)pStPage->GetNext();
1397 }
1398 }
1399 if ( bStop )
1400 break;
1401 }
1402
1403 // Wenn PostIts am Dokumentenende gedruckt werden sollen, dann hier machen
1404 if( ((rOptions.nPrintPostIts == POSTITS_ENDDOC) && !rOptions.bPrintReverse)
1405 || (rOptions.nPrintPostIts == POSTITS_ONLY) )
1406 lcl_PrintPostItsEndDoc( pPostItShell, aPostItFields, aMulti,
1407 sJobName, bStartJob, nJobStartError,
1408 rOptions.bPrintRightPage, rOptions.bPrintLeftPage,
1409 rOptions.bPrintReverse );
1410
1411 if( pPostItShell )
1412 {
1413 pPostItDoc->setPrinter( 0, false, false ); //damit am echten DOC der Drucker bleibt
1414 delete pPostItShell; //Nimmt das PostItDoc mit ins Grab.
1415 }
1416
1417 if( bStartJob )
1418 rOptions.bJobStartet = TRUE;
1419 }
1420
1421 }
1422 delete pStr;
1423
1424 } //Zus. Scope wg. CurShell!
1425
1426 delete pShell;
1427
1428 if (bSelection )
1429 {
1430 // damit das Dokument nicht den Drucker mit ins Grab nimmt
1431 pPrtDoc->setPrinter( 0, false, false );
1432
1433 if ( !pPrtDoc->release() )
1434 delete pPrtDoc;
1435 }
1436
1437 // restore settings of OutputDevicef
1438 if (pPDFOut)
1439 pPDFOut->Pop();
1440
1441 return bStartJob;
1442 }
1443
1444 /******************************************************************************
1445 * Methode : PrtOle2()
1446 * Beschreibung:
1447 * Erstellt : PK 07.12.94
1448 * Aenderung : MA 16. Feb. 95
1449 ******************************************************************************/
1450
1451
1452
1453 void ViewShell::PrtOle2( SwDoc *pDoc, const SwViewOption *pOpt, SwPrtOptions& rOptions,
1454 OutputDevice* pOleOut, const Rectangle& rRect )
1455 {
1456 //Wir brauchen eine Shell fuer das Drucken. Entweder hat das Doc schon
1457 //eine, dann legen wir uns eine neue Sicht an, oder das Doc hat noch
1458 //keine, dann erzeugen wir die erste Sicht.
1459 ViewShell *pSh;
1460 if( pDoc->GetRootFrm() && pDoc->GetRootFrm()->GetCurrShell() )
1461 pSh = new ViewShell( *pDoc->GetRootFrm()->GetCurrShell(), 0, pOleOut );
1462 else
1463 pSh = new ViewShell( *pDoc, 0, pOpt, pOleOut );
1464
1465 {
1466 SET_CURR_SHELL( pSh );
1467 pSh->PrepareForPrint( rOptions );
1468 pSh->SetPrtFormatOption( TRUE );
1469
1470 SwRect aSwRect( rRect );
1471 pSh->aVisArea = aSwRect;
1472
1473 if ( pSh->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE) &&
1474 pSh->GetNext() == pSh )
1475 {
1476 pSh->CheckBrowseView( FALSE );
1477 pDoc->GetRootFrm()->Lower()->InvalidateSize();
1478 }
1479
1480 // --> FME 2005-02-10 #119474#
1481 // CalcPagesForPrint() should not be necessary here. The pages in the
1482 // visible area will be formatted in SwRootFrm::Paint().
1483 // Removing this gives us a performance gain during saving the
1484 // document because the thumbnail creation will not trigger a complete
1485 // formatting of the document.
1486 // Seiten fuers Drucken formatieren
1487 // pSh->CalcPagesForPrint( SHRT_MAX );
1488 // <--
1489
1490 //#39275# jetzt will der Meyer doch ein Clipping
1491 pOleOut->Push( PUSH_CLIPREGION );
1492 pOleOut->IntersectClipRegion( aSwRect.SVRect() );
1493 pSh->GetLayout()->Paint( aSwRect );
1494 // SFX_APP()->SpoilDemoOutput( *pOleOut, rRect );
1495 pOleOut->Pop();
1496
1497 // erst muss das CurrShell Object zerstoert werden!!
1498 }
1499 delete pSh;
1500 }
1501
1502 /******************************************************************************
1503 * Methode : IsAnyFieldInDoc()
1504 * Beschreibung: Stellt fest, ob im DocNodesArray Felder verankert sind
1505 * Erstellt : JP 27.07.95
1506 * Aenderung : JP 10.12.97
1507 ******************************************************************************/
1508
1509
1510
1511 BOOL ViewShell::IsAnyFieldInDoc() const
1512 {
1513 const SfxPoolItem* pItem;
1514 USHORT nMaxItems = pDoc->GetAttrPool().GetItemCount( RES_TXTATR_FIELD );
1515 for( USHORT n = 0; n < nMaxItems; ++n )
1516 if( 0 != (pItem = pDoc->GetAttrPool().GetItem( RES_TXTATR_FIELD, n )))
1517 {
1518 const SwFmtFld* pFmtFld = (SwFmtFld*)pItem;
1519 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1520 if( pTxtFld && pTxtFld->GetTxtNode().GetNodes().IsDocNodes() )
1521 return TRUE;
1522 }
1523 return FALSE;
1524 }
1525
1526
1527
1528 /******************************************************************************
1529 * Klasse : SwPrtOptSave
1530 * Erstellt : AMA 12.07.95
1531 * Aenderung : AMA 12.07.95
1532 * Holt sich im Ctor folgende Einstellungen des Druckers, die im Dtor dann
1533 * wieder im Drucker gesetzt werden (falls sie sich ueberhaupt geaendert haben)
1534 * - PaperBin - Orientation - PaperSize -
1535 ******************************************************************************/
1536
1537
1538
1539 SwPrtOptSave::SwPrtOptSave( Printer *pPrinter )
1540 : pPrt( pPrinter )
1541 {
1542 if ( pPrt )
1543 {
1544 ePaper = pPrt->GetPaper();
1545 if ( PAPER_USER == ePaper )
1546 aSize = pPrt->GetPaperSize();
1547 eOrientation = pPrt->GetOrientation();
1548 nPaperBin = pPrt->GetPaperBin();
1549
1550 }
1551 }
1552
1553
1554
1555 SwPrtOptSave::~SwPrtOptSave()
1556 {
1557 if ( pPrt )
1558 {
1559 if ( PAPER_USER == ePaper )
1560 {
1561 if( pPrt->GetPaperSize() != aSize )
1562 pPrt->SetPaperSizeUser( aSize );
1563 }
1564 else if ( pPrt->GetPaper() != ePaper )
1565 pPrt->SetPaper( ePaper );
1566 if ( pPrt->GetOrientation() != eOrientation)
1567 pPrt->SetOrientation( eOrientation );
1568 if ( pPrt->GetPaperBin() != nPaperBin )
1569 pPrt->SetPaperBin( nPaperBin );
1570 }
1571 }
1572
1573
1574 /******************************************************************************
1575 * SwDrawViewSave
1576 *
1577 * Saves some settings at the draw view
1578 ******************************************************************************/
1579
1580 SwDrawViewSave::SwDrawViewSave( SdrView* pSdrView )
1581 : pDV( pSdrView )
1582 {
1583 if ( pDV )
1584 {
1585 sLayerNm.AssignAscii( RTL_CONSTASCII_STRINGPARAM("Controls" ) );
1586 bPrintControls = pDV->IsLayerPrintable( sLayerNm );
1587 }
1588 }
1589
1590 SwDrawViewSave::~SwDrawViewSave()
1591 {
1592 if ( pDV )
1593 {
1594 pDV->SetLayerPrintable( sLayerNm, bPrintControls );
1595 }
1596 }
1597
1598
1599 // OD 09.01.2003 #i6467# - method also called for page preview
1600 void ViewShell::PrepareForPrint( const SwPrtOptions &rOptions )
1601 {
1602 // Viewoptions fuer den Drucker setzen
1603 pOpt->SetGraphic ( TRUE == rOptions.bPrintGraphic );
1604 pOpt->SetTable ( TRUE == rOptions.bPrintTable );
1605 pOpt->SetDraw ( TRUE == rOptions.bPrintDraw );
1606 pOpt->SetControl ( TRUE == rOptions.bPrintControl );
1607 pOpt->SetPageBack( TRUE == rOptions.bPrintPageBackground );
1608 pOpt->SetBlackFont( TRUE == rOptions.bPrintBlackFont );
1609
1610 if ( HasDrawView() )
1611 {
1612 SdrView *pDrawView = GetDrawView();
1613 String sLayerNm;
1614 sLayerNm.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Controls" ));
1615 // OD 09.01.2003 #i6467# - consider, if view shell belongs to page preview
1616 if ( !IsPreView() )
1617 {
1618 pDrawView->SetLayerPrintable( sLayerNm, rOptions.bPrintControl );
1619 }
1620 else
1621 {
1622 pDrawView->SetLayerVisible( sLayerNm, rOptions.bPrintControl );
1623 }
1624 }
1625 }
vba interoperability for OOo