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