Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "scitems.hxx"
21 : #include <editeng/eeitem.hxx>
22 :
23 : #include "printfun.hxx"
24 :
25 : #include <svx/svxids.hrc>
26 : #include <editeng/adjitem.hxx>
27 : #include <editeng/boxitem.hxx>
28 : #include <editeng/brshitem.hxx>
29 : #include <svtools/colorcfg.hxx>
30 : #include <editeng/editstat.hxx> // EE_CNTRL_RTFSTYLESHEETS
31 : #include <svx/fmview.hxx>
32 : #include <editeng/frmdiritem.hxx>
33 : #include <editeng/lrspitem.hxx>
34 : #include <editeng/paperinf.hxx>
35 : #include <editeng/pbinitem.hxx>
36 : #include <editeng/shaditem.hxx>
37 : #include <editeng/sizeitem.hxx>
38 : #include <svx/svdpagv.hxx>
39 : #include <editeng/ulspitem.hxx>
40 : #include <sfx2/app.hxx>
41 : #include <sfx2/printer.hxx>
42 : #include <tools/multisel.hxx>
43 : #include <sfx2/docfile.hxx>
44 : #include <tools/urlobj.hxx>
45 : #include <svx/xoutbmp.hxx>
46 :
47 : #include "editutil.hxx"
48 : #include "docsh.hxx"
49 : #include "output.hxx"
50 : #include "viewdata.hxx"
51 : #include "viewopti.hxx"
52 : #include "stlpool.hxx"
53 : #include "pagepar.hxx"
54 : #include "attrib.hxx"
55 : #include "patattr.hxx"
56 : #include "docpool.hxx"
57 : #include "dociter.hxx"
58 : #include "cell.hxx"
59 : #include "drawutil.hxx"
60 : #include "globstr.hrc"
61 : #include "scresid.hxx"
62 : #include "sc.hrc"
63 : #include "pagedata.hxx"
64 : #include "printopt.hxx"
65 : #include "prevloc.hxx"
66 : #include "scmod.hxx"
67 : #include "drwlayer.hxx"
68 : #include "fillinfo.hxx"
69 : #include "postit.hxx"
70 :
71 : #include <vcl/lineinfo.hxx>
72 :
73 : #include <boost/scoped_ptr.hpp>
74 : #include <com/sun/star/document/XDocumentProperties.hpp>
75 :
76 : #define ZOOM_MIN 10
77 :
78 : #define GET_BOOL(set,which) ((const SfxBoolItem&)(set)->Get((which))).GetValue()
79 : #define GET_USHORT(set,which) ((const SfxUInt16Item&)(set)->Get((which))).GetValue()
80 : #define GET_SHOW(set,which) ( VOBJ_MODE_SHOW == ScVObjMode( ((const ScViewObjectModeItem&)(set)->Get((which))).GetValue()) )
81 :
82 : //------------------------------------------------------------------------
83 :
84 0 : ScPageRowEntry::ScPageRowEntry(const ScPageRowEntry& r)
85 : {
86 0 : nStartRow = r.nStartRow;
87 0 : nEndRow = r.nEndRow;
88 0 : nPagesX = r.nPagesX;
89 0 : if (r.pHidden && nPagesX)
90 : {
91 0 : pHidden = new sal_Bool[nPagesX];
92 0 : memcpy( pHidden, r.pHidden, nPagesX * sizeof(sal_Bool) );
93 : }
94 : else
95 0 : pHidden = NULL;
96 0 : }
97 :
98 0 : const ScPageRowEntry& ScPageRowEntry::operator=(const ScPageRowEntry& r)
99 : {
100 0 : delete[] pHidden;
101 :
102 0 : nStartRow = r.nStartRow;
103 0 : nEndRow = r.nEndRow;
104 0 : nPagesX = r.nPagesX;
105 0 : if (r.pHidden && nPagesX)
106 : {
107 0 : pHidden = new sal_Bool[nPagesX];
108 0 : memcpy( pHidden, r.pHidden, nPagesX * sizeof(sal_Bool) );
109 : }
110 : else
111 0 : pHidden = NULL;
112 :
113 0 : return *this;
114 : }
115 :
116 17 : void ScPageRowEntry::SetPagesX(size_t nNew)
117 : {
118 17 : if (pHidden)
119 : {
120 : OSL_FAIL("SetPagesX nicht nach SetHidden");
121 0 : delete[] pHidden;
122 0 : pHidden = NULL;
123 : }
124 17 : nPagesX = nNew;
125 17 : }
126 :
127 0 : void ScPageRowEntry::SetHidden(size_t nX)
128 : {
129 0 : if ( nX < nPagesX )
130 : {
131 0 : if ( nX+1 == nPagesX ) // letzte Seite?
132 0 : --nPagesX;
133 : else
134 : {
135 0 : if (!pHidden)
136 : {
137 0 : pHidden = new sal_Bool[nPagesX];
138 0 : memset( pHidden, false, nPagesX * sizeof(sal_Bool) );
139 : }
140 0 : pHidden[nX] = sal_True;
141 : }
142 : }
143 0 : }
144 :
145 0 : sal_Bool ScPageRowEntry::IsHidden(size_t nX) const
146 : {
147 0 : return nX>=nPagesX || ( pHidden && pHidden[nX] ); //! inline?
148 : }
149 :
150 0 : size_t ScPageRowEntry::CountVisible() const
151 : {
152 0 : if ( pHidden )
153 : {
154 0 : size_t nVis = 0;
155 0 : for (size_t i=0; i<nPagesX; i++)
156 0 : if (!pHidden[i])
157 0 : ++nVis;
158 0 : return nVis;
159 : }
160 : else
161 0 : return nPagesX;
162 : }
163 :
164 : //------------------------------------------------------------------------
165 :
166 1228 : static long lcl_LineTotal(const ::editeng::SvxBorderLine* pLine)
167 : {
168 1228 : return pLine ? ( pLine->GetOutWidth() + pLine->GetInWidth() + pLine->GetDistance() ) : 0;
169 : }
170 :
171 69 : void ScPrintFunc::Construct( const ScPrintOptions* pOptions )
172 : {
173 69 : pDocShell->UpdatePendingRowHeights( nPrintTab );
174 69 : pDoc = pDocShell->GetDocument();
175 :
176 69 : SfxPrinter* pDocPrinter = pDoc->GetPrinter(); // auch fuer Preview den Drucker nehmen
177 69 : if (pDocPrinter)
178 69 : aOldPrinterMode = pDocPrinter->GetMapMode();
179 :
180 : // einheitlicher MapMode ueber alle Aufrufe (z.B. Repaint !!!),
181 : // weil die EditEngine sonst unterschiedliche Texthoehen liefert
182 69 : pDev->SetMapMode(MAP_PIXEL);
183 :
184 69 : pPageEndX = NULL;
185 69 : pPageEndY = NULL;
186 69 : pPageRows = NULL;
187 69 : pBorderItem = NULL;
188 69 : pBackgroundItem = NULL;
189 69 : pShadowItem = NULL;
190 :
191 69 : pEditEngine = NULL;
192 69 : pEditDefaults = NULL;
193 :
194 69 : ScStyleSheetPool* pStylePool = pDoc->GetStyleSheetPool();
195 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find(
196 : pDoc->GetPageStyle( nPrintTab ),
197 69 : SFX_STYLE_FAMILY_PAGE );
198 69 : if (pStyleSheet)
199 69 : pParamSet = &pStyleSheet->GetItemSet();
200 : else
201 : {
202 : OSL_FAIL("Seitenvorlage nicht gefunden" );
203 0 : pParamSet = NULL;
204 : }
205 :
206 69 : if (!bState)
207 69 : nZoom = 100;
208 69 : nManualZoom = 100;
209 69 : bClearWin = false;
210 69 : bUseStyleColor = false;
211 69 : bIsRender = false;
212 :
213 69 : InitParam(pOptions);
214 :
215 69 : pPageData = NULL; // wird nur zur Initialisierung gebraucht
216 69 : }
217 :
218 69 : ScPrintFunc::ScPrintFunc( ScDocShell* pShell, SfxPrinter* pNewPrinter, SCTAB nTab,
219 : long nPage, long nDocP, const ScRange* pArea,
220 : const ScPrintOptions* pOptions,
221 : ScPageBreakData* pData )
222 : : pDocShell ( pShell ),
223 : pPrinter ( pNewPrinter ),
224 : pDrawView ( NULL ),
225 : nPrintTab ( nTab ),
226 : nPageStart ( nPage ),
227 : nDocPages ( nDocP ),
228 : pUserArea ( pArea ),
229 : bState ( false ),
230 : bSourceRangeValid ( false ),
231 : bPrintCurrentTable ( false ),
232 : bMultiArea ( false ),
233 : nTabPages ( 0 ),
234 : nTotalPages ( 0 ),
235 : nPagesX(0),
236 : nPagesY(0),
237 : nTotalY(0),
238 69 : pPageData ( pData )
239 : {
240 69 : pDev = pPrinter;
241 69 : aSrcOffset = pPrinter->PixelToLogic( pPrinter->GetPageOffsetPixel(), MAP_100TH_MM );
242 69 : Construct( pOptions );
243 69 : }
244 :
245 0 : ScPrintFunc::ScPrintFunc( OutputDevice* pOutDev, ScDocShell* pShell, SCTAB nTab,
246 : long nPage, long nDocP, const ScRange* pArea,
247 : const ScPrintOptions* pOptions )
248 : : pDocShell ( pShell ),
249 : pPrinter ( NULL ),
250 : pDrawView ( NULL ),
251 : nPrintTab ( nTab ),
252 : nPageStart ( nPage ),
253 : nDocPages ( nDocP ),
254 : pUserArea ( pArea ),
255 : bState ( false ),
256 : bSourceRangeValid ( false ),
257 : bPrintCurrentTable ( false ),
258 : bMultiArea ( false ),
259 : nTabPages ( 0 ),
260 : nTotalPages ( 0 ),
261 : nPagesX(0),
262 : nPagesY(0),
263 : nTotalY(0),
264 0 : pPageData ( NULL )
265 : {
266 0 : pDev = pOutDev;
267 0 : Construct( pOptions );
268 0 : }
269 :
270 0 : ScPrintFunc::ScPrintFunc( OutputDevice* pOutDev, ScDocShell* pShell,
271 : const ScPrintState& rState, const ScPrintOptions* pOptions )
272 : : pDocShell ( pShell ),
273 : pPrinter ( NULL ),
274 : pDrawView ( NULL ),
275 : pUserArea ( NULL ),
276 : bSourceRangeValid ( false ),
277 : bPrintCurrentTable ( false ),
278 : bMultiArea ( false ),
279 : nPagesX(0),
280 : nPagesY(0),
281 : nTotalY(0),
282 0 : pPageData ( NULL )
283 : {
284 0 : pDev = pOutDev;
285 :
286 0 : nPrintTab = rState.nPrintTab;
287 0 : nStartCol = rState.nStartCol;
288 0 : nStartRow = rState.nStartRow;
289 0 : nEndCol = rState.nEndCol;
290 0 : nEndRow = rState.nEndRow;
291 0 : nZoom = rState.nZoom;
292 0 : nPagesX = rState.nPagesX;
293 0 : nPagesY = rState.nPagesY;
294 0 : nTabPages = rState.nTabPages;
295 0 : nTotalPages = rState.nTotalPages;
296 0 : nPageStart = rState.nPageStart;
297 0 : nDocPages = rState.nDocPages;
298 0 : bState = sal_True;
299 :
300 0 : Construct( pOptions );
301 0 : }
302 :
303 0 : void ScPrintFunc::GetPrintState( ScPrintState& rState )
304 : {
305 0 : rState.nPrintTab = nPrintTab;
306 0 : rState.nStartCol = nStartCol;
307 0 : rState.nStartRow = nStartRow;
308 0 : rState.nEndCol = nEndCol;
309 0 : rState.nEndRow = nEndRow;
310 0 : rState.nZoom = nZoom;
311 0 : rState.nPagesX = nPagesX;
312 0 : rState.nPagesY = nPagesY;
313 0 : rState.nTabPages = nTabPages;
314 0 : rState.nTotalPages = nTotalPages;
315 0 : rState.nPageStart = nPageStart;
316 0 : rState.nDocPages = nDocPages;
317 0 : }
318 :
319 0 : sal_Bool ScPrintFunc::GetLastSourceRange( ScRange& rRange ) const
320 : {
321 0 : rRange = aLastSourceRange;
322 0 : return bSourceRangeValid;
323 : }
324 :
325 0 : void ScPrintFunc::FillPageData()
326 : {
327 0 : if (pPageData)
328 : {
329 0 : sal_uInt16 nCount = sal::static_int_cast<sal_uInt16>( pPageData->GetCount() );
330 0 : ScPrintRangeData& rData = pPageData->GetData(nCount); // hochzaehlen
331 :
332 : rData.SetPrintRange( ScRange( nStartCol, nStartRow, nPrintTab,
333 0 : nEndCol, nEndRow, nPrintTab ) );
334 0 : rData.SetPagesX( nPagesX, pPageEndX );
335 0 : rData.SetPagesY( nTotalY, pPageEndY );
336 :
337 : // Einstellungen
338 0 : rData.SetTopDown( aTableParam.bTopDown );
339 0 : rData.SetAutomatic( !aAreaParam.bPrintArea );
340 : }
341 0 : }
342 :
343 138 : ScPrintFunc::~ScPrintFunc()
344 : {
345 69 : delete[] pPageEndX;
346 69 : delete[] pPageEndY;
347 69 : delete[] pPageRows;
348 69 : delete pEditDefaults;
349 69 : delete pEditEngine;
350 :
351 : // Druckereinstellungen werden jetzt von aussen wiederhergestellt
352 :
353 : // Fuer DrawingLayer/Charts muss der MapMode am Drucker (RefDevice) immer stimmen
354 69 : SfxPrinter* pDocPrinter = pDoc->GetPrinter(); // auch fuer Preview den Drucker nehmen
355 69 : if (pDocPrinter)
356 69 : pDocPrinter->SetMapMode(aOldPrinterMode);
357 69 : }
358 :
359 0 : void ScPrintFunc::SetDrawView( FmFormView* pNew )
360 : {
361 0 : pDrawView = pNew;
362 0 : }
363 :
364 1 : static void lcl_HidePrint( ScTableInfo& rTabInfo, SCCOL nX1, SCCOL nX2 )
365 : {
366 28 : for (SCSIZE nArrY=1; nArrY+1<rTabInfo.mnArrCount; nArrY++)
367 : {
368 27 : RowInfo* pThisRowInfo = &rTabInfo.mpRowInfo[nArrY];
369 135 : for (SCCOL nX=nX1; nX<=nX2; nX++)
370 : {
371 108 : const CellInfo& rCellInfo = pThisRowInfo->pCellInfo[nX+1];
372 108 : if (!rCellInfo.bEmptyCellText)
373 1 : if (((const ScProtectionAttr&)rCellInfo.pPatternAttr->
374 1 : GetItem(ATTR_PROTECTION, rCellInfo.pConditionSet)).GetHidePrint())
375 : {
376 0 : pThisRowInfo->pCellInfo[nX+1].pCell = NULL;
377 0 : pThisRowInfo->pCellInfo[nX+1].bEmptyCellText = sal_True;
378 : }
379 : }
380 : }
381 1 : }
382 :
383 : //
384 : // Ausgabe auf Device (static)
385 : //
386 : // wird benutzt fuer:
387 : // - Clipboard/Bitmap
388 : // - Ole-Object (DocShell::Draw)
389 : // - Vorschau bei Vorlagen
390 :
391 1 : void ScPrintFunc::DrawToDev( ScDocument* pDoc, OutputDevice* pDev, double /* nPrintFactor */,
392 : const Rectangle& rBound, ScViewData* pViewData, sal_Bool bMetaFile )
393 : {
394 : //! nPrintFactor auswerten !!!
395 :
396 1 : SCTAB nTab = 0;
397 1 : if (pViewData)
398 1 : nTab = pViewData->GetTabNo();
399 :
400 : sal_Bool bDoGrid, bNullVal, bFormula;
401 1 : ScStyleSheetPool* pStylePool = pDoc->GetStyleSheetPool();
402 1 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find( pDoc->GetPageStyle( nTab ), SFX_STYLE_FAMILY_PAGE );
403 1 : if (pStyleSheet)
404 : {
405 1 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
406 1 : bDoGrid = ((const SfxBoolItem&)rSet.Get(ATTR_PAGE_GRID)).GetValue();
407 1 : bNullVal = ((const SfxBoolItem&)rSet.Get(ATTR_PAGE_NULLVALS)).GetValue();
408 1 : bFormula = ((const SfxBoolItem&)rSet.Get(ATTR_PAGE_FORMULAS)).GetValue();
409 : }
410 : else
411 : {
412 0 : const ScViewOptions& rOpt = pDoc->GetViewOptions();
413 0 : bDoGrid = rOpt.GetOption(VOPT_GRID);
414 0 : bNullVal = rOpt.GetOption(VOPT_NULLVALS);
415 0 : bFormula = rOpt.GetOption(VOPT_FORMULAS);
416 : }
417 :
418 1 : MapMode aMode = pDev->GetMapMode();
419 :
420 1 : Rectangle aRect = rBound;
421 :
422 1 : if (aRect.Right() < aRect.Left() || aRect.Bottom() < aRect.Top())
423 0 : aRect = Rectangle( Point(), pDev->GetOutputSize() );
424 :
425 1 : SCCOL nX1 = 0;
426 1 : SCROW nY1 = 0;
427 1 : SCCOL nX2 = OLE_STD_CELLS_X - 1;
428 1 : SCROW nY2 = OLE_STD_CELLS_Y - 1;
429 1 : if (bMetaFile)
430 : {
431 1 : ScRange aRange = pDoc->GetRange( nTab, rBound );
432 1 : nX1 = aRange.aStart.Col();
433 1 : nY1 = aRange.aStart.Row();
434 1 : nX2 = aRange.aEnd.Col();
435 1 : nY2 = aRange.aEnd.Row();
436 : }
437 0 : else if (pViewData)
438 : {
439 0 : ScSplitPos eWhich = pViewData->GetActivePart();
440 0 : ScHSplitPos eHWhich = WhichH(eWhich);
441 0 : ScVSplitPos eVWhich = WhichV(eWhich);
442 0 : nX1 = pViewData->GetPosX(eHWhich);
443 0 : nY1 = pViewData->GetPosY(eVWhich);
444 0 : nX2 = nX1 + pViewData->VisibleCellsX(eHWhich);
445 0 : if (nX2>nX1) --nX2;
446 0 : nY2 = nY1 + pViewData->VisibleCellsY(eVWhich);
447 0 : if (nY2>nY1) --nY2;
448 : }
449 :
450 1 : if (nX1 > MAXCOL) nX1 = MAXCOL;
451 1 : if (nX2 > MAXCOL) nX2 = MAXCOL;
452 1 : if (nY1 > MAXROW) nY1 = MAXROW;
453 1 : if (nY2 > MAXROW) nY2 = MAXROW;
454 :
455 1 : long nDevSizeX = aRect.Right()-aRect.Left()+1;
456 1 : long nDevSizeY = aRect.Bottom()-aRect.Top()+1;
457 :
458 1 : Rectangle aLines;
459 1 : ScRange aRange( nX1,nY1,nTab, nX2,nY2,nTab );
460 :
461 1 : long nTwipsSizeX = 0;
462 5 : for (SCCOL i=nX1; i<=nX2; i++)
463 4 : nTwipsSizeX += pDoc->GetColWidth( i, nTab );
464 1 : long nTwipsSizeY = (long) pDoc->GetRowHeight( nY1, nY2, nTab );
465 :
466 : // wenn keine Linien, dann trotzdem Platz fuer den Aussenrahmen (20 Twips = 1pt)
467 : // (HasLines initalisiert aLines auf 0,0,0,0)
468 1 : nTwipsSizeX += aLines.Left() + Max( aLines.Right(), 20L );
469 1 : nTwipsSizeY += aLines.Top() + Max( aLines.Bottom(), 20L );
470 :
471 1 : double nScaleX = (double) nDevSizeX / nTwipsSizeX;
472 1 : double nScaleY = (double) nDevSizeY / nTwipsSizeY;
473 :
474 : //! Flag bei FillInfo uebergeben !!!!!
475 1 : ScRange aERange;
476 1 : sal_Bool bEmbed = pDoc->IsEmbedded();
477 1 : if (bEmbed)
478 : {
479 0 : pDoc->GetEmbedded(aERange);
480 0 : pDoc->ResetEmbedded();
481 : }
482 :
483 : // Daten zusammenstellen
484 :
485 1 : ScTableInfo aTabInfo;
486 : pDoc->FillInfo( aTabInfo, nX1, nY1, nX2, nY2, nTab,
487 1 : nScaleX, nScaleY, false, bFormula );
488 1 : lcl_HidePrint( aTabInfo, nX1, nX2 );
489 :
490 1 : if (bEmbed)
491 0 : pDoc->SetEmbedded(aERange);
492 :
493 1 : long nScrX = aRect.Left();
494 1 : long nScrY = aRect.Top();
495 :
496 : // Wenn keine Linien, trotzdem Platz fuer Gitterlinien lassen
497 : // (werden sonst abgeschnitten)
498 1 : long nAddX = (long)( aLines.Left() * nScaleX );
499 1 : nScrX += ( nAddX ? nAddX : 1 );
500 1 : long nAddY = (long)( aLines.Top() * nScaleY );
501 1 : nScrY += ( nAddY ? nAddY : 1 );
502 :
503 : ScOutputData aOutputData( pDev, OUTTYPE_PRINTER, aTabInfo, pDoc, nTab,
504 1 : nScrX, nScrY, nX1, nY1, nX2, nY2, nScaleX, nScaleY );
505 1 : aOutputData.SetMetaFileMode(bMetaFile);
506 1 : aOutputData.SetShowNullValues(bNullVal);
507 1 : aOutputData.SetShowFormulas(bFormula);
508 :
509 : // #114135#
510 1 : ScDrawLayer* pModel = pDoc->GetDrawLayer();
511 1 : FmFormView* pDrawView = NULL;
512 :
513 1 : if( pModel )
514 : {
515 1 : pDrawView = new FmFormView( pModel, pDev );
516 1 : pDrawView->ShowSdrPage(pDrawView->GetModel()->GetPage(nTab));
517 1 : pDrawView->SetPrintPreview( sal_True );
518 1 : aOutputData.SetDrawView( pDrawView );
519 : }
520 :
521 : //! SetUseStyleColor ??
522 :
523 1 : if ( bMetaFile && pDev->GetOutDevType() == OUTDEV_VIRDEV )
524 1 : aOutputData.SetSnapPixel();
525 :
526 1 : Point aLogStart = pDev->PixelToLogic( Point(nScrX,nScrY), MAP_100TH_MM );
527 1 : long nLogStX = aLogStart.X();
528 1 : long nLogStY = aLogStart.Y();
529 :
530 : //! nZoom fuer GetFont in OutputData ???
531 :
532 1 : if (!bMetaFile && pViewData)
533 0 : pDev->SetMapMode(pViewData->GetLogicMode(pViewData->GetActivePart()));
534 :
535 : // #i72502#
536 1 : const Point aMMOffset(aOutputData.PrePrintDrawingLayer(nLogStX, nLogStY));
537 1 : aOutputData.PrintDrawingLayer(SC_LAYER_BACK, aMMOffset);
538 :
539 1 : if (!bMetaFile && pViewData)
540 0 : pDev->SetMapMode(aMode);
541 :
542 1 : aOutputData.DrawBackground();
543 1 : aOutputData.DrawShadow();
544 1 : aOutputData.DrawFrame();
545 1 : aOutputData.DrawStrings();
546 :
547 1 : if (!bMetaFile && pViewData)
548 0 : pDev->SetMapMode(pViewData->GetLogicMode(pViewData->GetActivePart()));
549 :
550 1 : aOutputData.DrawEdit(!bMetaFile);
551 :
552 1 : if (bDoGrid)
553 : {
554 0 : if (!bMetaFile && pViewData)
555 0 : pDev->SetMapMode(aMode);
556 :
557 0 : aOutputData.DrawGrid( sal_True, false ); // keine Seitenumbrueche
558 :
559 0 : pDev->SetLineColor( COL_BLACK );
560 :
561 0 : Size aOne = pDev->PixelToLogic( Size(1,1) );
562 0 : if (bMetaFile)
563 0 : aOne = Size(1,1); // compatible with DrawGrid
564 0 : long nRight = nScrX + aOutputData.GetScrW() - aOne.Width();
565 0 : long nBottom = nScrY + aOutputData.GetScrH() - aOne.Height();
566 :
567 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
568 :
569 : // extra line at the left edge for left-to-right, right for right-to-left
570 0 : if ( bLayoutRTL )
571 0 : pDev->DrawLine( Point(nRight,nScrY), Point(nRight,nBottom) );
572 : else
573 0 : pDev->DrawLine( Point(nScrX,nScrY), Point(nScrX,nBottom) );
574 : // extra line at the top in both cases
575 0 : pDev->DrawLine( Point(nScrX,nScrY), Point(nRight,nScrY) );
576 : }
577 :
578 : // #i72502#
579 1 : aOutputData.PrintDrawingLayer(SC_LAYER_FRONT, aMMOffset);
580 1 : aOutputData.PrintDrawingLayer(SC_LAYER_INTERN, aMMOffset);
581 1 : aOutputData.PostPrintDrawingLayer(aMMOffset); // #i74768#
582 :
583 : // #114135#
584 1 : delete pDrawView;
585 1 : }
586 :
587 : //
588 : // Drucken
589 : //
590 :
591 138 : static void lcl_FillHFParam( ScPrintHFParam& rParam, const SfxItemSet* pHFSet )
592 : {
593 : // nDistance muss vorher unterschiedlich initalisiert sein
594 :
595 138 : if ( pHFSet == NULL )
596 : {
597 0 : rParam.bEnable = false;
598 0 : rParam.pBorder = NULL;
599 0 : rParam.pBack = NULL;
600 0 : rParam.pShadow = NULL;
601 : }
602 : else
603 : {
604 138 : rParam.bEnable = ((const SfxBoolItem&) pHFSet->Get(ATTR_PAGE_ON)).GetValue();
605 138 : rParam.bDynamic = ((const SfxBoolItem&) pHFSet->Get(ATTR_PAGE_DYNAMIC)).GetValue();
606 138 : rParam.bShared = ((const SfxBoolItem&) pHFSet->Get(ATTR_PAGE_SHARED)).GetValue();
607 138 : rParam.nHeight = ((const SvxSizeItem&) pHFSet->Get(ATTR_PAGE_SIZE)).GetSize().Height();
608 138 : const SvxLRSpaceItem* pHFLR = &(const SvxLRSpaceItem&) pHFSet->Get(ATTR_LRSPACE);
609 : long nTmp;
610 138 : nTmp = pHFLR->GetLeft();
611 138 : rParam.nLeft = nTmp < 0 ? 0 : sal_uInt16(nTmp);
612 138 : nTmp = pHFLR->GetRight();
613 138 : rParam.nRight = nTmp < 0 ? 0 : sal_uInt16(nTmp);
614 138 : rParam.pBorder = (const SvxBoxItem*) &pHFSet->Get(ATTR_BORDER);
615 138 : rParam.pBack = (const SvxBrushItem*) &pHFSet->Get(ATTR_BACKGROUND);
616 138 : rParam.pShadow = (const SvxShadowItem*)&pHFSet->Get(ATTR_SHADOW);
617 :
618 : // jetzt doch wieder schon im Dialog:
619 : // rParam.nHeight += rParam.nDistance; // nicht mehr im Dialog ???
620 :
621 138 : if (rParam.pBorder)
622 138 : rParam.nHeight += lcl_LineTotal( rParam.pBorder->GetTop() ) +
623 138 : lcl_LineTotal( rParam.pBorder->GetBottom() );
624 :
625 138 : rParam.nManHeight = rParam.nHeight;
626 : }
627 :
628 138 : if (!rParam.bEnable)
629 12 : rParam.nHeight = 0;
630 138 : }
631 :
632 : // bNew = TRUE: benutzten Bereich aus dem Dokument suchen
633 : // bNew = FALSE: nur ganze Zeilen/Spalten begrenzen
634 :
635 86 : sal_Bool ScPrintFunc::AdjustPrintArea( sal_Bool bNew )
636 : {
637 86 : SCCOL nOldEndCol = nEndCol; // nur wichtig bei !bNew
638 86 : SCROW nOldEndRow = nEndRow;
639 86 : sal_Bool bChangeCol = sal_True; // bei bNew werden beide angepasst
640 86 : sal_Bool bChangeRow = sal_True;
641 :
642 86 : sal_Bool bNotes = aTableParam.bNotes;
643 86 : if ( bNew )
644 : {
645 69 : nStartCol = 0;
646 69 : nStartRow = 0;
647 69 : if (!pDoc->GetPrintArea( nPrintTab, nEndCol, nEndRow, bNotes ))
648 52 : return false; // nix
649 : }
650 : else
651 : {
652 17 : sal_Bool bFound = sal_True;
653 17 : bChangeCol = ( nStartCol == 0 && nEndCol == MAXCOL );
654 17 : bChangeRow = ( nStartRow == 0 && nEndRow == MAXROW );
655 17 : sal_Bool bForcedChangeRow = false;
656 :
657 : // #i53558# Crop entire column of old row limit to real print area with
658 : // some fuzzyness.
659 17 : if (!bChangeRow && nStartRow == 0)
660 : {
661 : SCROW nPAEndRow;
662 17 : bFound = pDoc->GetPrintAreaVer( nPrintTab, nStartCol, nEndCol, nPAEndRow, bNotes );
663 : // Say we don't want to print more than ~1000 empty rows, which are
664 : // about 14 pages intentionally left blank..
665 17 : const SCROW nFuzzy = 23*42;
666 17 : if (nPAEndRow + nFuzzy < nEndRow)
667 : {
668 0 : bForcedChangeRow = sal_True;
669 0 : nEndRow = nPAEndRow;
670 : }
671 : else
672 17 : bFound = sal_True; // user seems to _want_ to print some empty rows
673 : }
674 : // TODO: in case we extend the number of columns we may have to do the
675 : // same for horizontal cropping.
676 :
677 17 : if ( bChangeCol && bChangeRow )
678 0 : bFound = pDoc->GetPrintArea( nPrintTab, nEndCol, nEndRow, bNotes );
679 17 : else if ( bChangeCol )
680 0 : bFound = pDoc->GetPrintAreaHor( nPrintTab, nStartRow, nEndRow, nEndCol, bNotes );
681 17 : else if ( bChangeRow )
682 0 : bFound = pDoc->GetPrintAreaVer( nPrintTab, nStartCol, nEndCol, nEndRow, bNotes );
683 :
684 17 : if (!bFound)
685 0 : return false; // leer
686 :
687 17 : if (bForcedChangeRow)
688 0 : bChangeRow = sal_True;
689 : }
690 :
691 : pDoc->ExtendMerge( nStartCol,nStartRow, nEndCol,nEndRow, nPrintTab,
692 34 : false ); // kein Refresh, incl. Attrs
693 :
694 34 : if ( bChangeCol )
695 : {
696 17 : OutputDevice* pRefDev = pDoc->GetPrinter(); // auch fuer Preview den Drucker nehmen
697 17 : pRefDev->SetMapMode( MAP_PIXEL ); // wichtig fuer GetNeededSize
698 :
699 : pDoc->ExtendPrintArea( pRefDev,
700 17 : nPrintTab, nStartCol, nStartRow, nEndCol, nEndRow );
701 : // nEndCol wird veraendert
702 : }
703 :
704 68 : if ( nEndCol < MAXCOL && pDoc->HasAttrib(
705 34 : nEndCol,nStartRow,nPrintTab, nEndCol,nEndRow,nPrintTab, HASATTR_SHADOW_RIGHT ) )
706 0 : ++nEndCol;
707 68 : if ( nEndRow < MAXROW && pDoc->HasAttrib(
708 34 : nStartCol,nEndRow,nPrintTab, nEndCol,nEndRow,nPrintTab, HASATTR_SHADOW_DOWN ) )
709 0 : ++nEndRow;
710 :
711 34 : if (!bChangeCol) nEndCol = nOldEndCol;
712 34 : if (!bChangeRow) nEndRow = nOldEndRow;
713 :
714 34 : return sal_True;
715 : }
716 :
717 912 : long ScPrintFunc::TextHeight( const EditTextObject* pObject )
718 : {
719 912 : if (!pObject)
720 192 : return 0;
721 :
722 720 : pEditEngine->SetTextNewDefaults( *pObject, *pEditDefaults, false );
723 :
724 720 : return (long) pEditEngine->GetTextHeight();
725 : }
726 :
727 : // nZoom muss gesetzt sein !!!
728 : // und der entsprechende Twip-MapMode eingestellt
729 :
730 172 : void ScPrintFunc::UpdateHFHeight( ScPrintHFParam& rParam )
731 : {
732 : OSL_ENSURE( aPageSize.Width(), "UpdateHFHeight ohne aPageSize");
733 :
734 172 : if (rParam.bEnable && rParam.bDynamic)
735 : {
736 : // nHeight aus Inhalten berechnen
737 :
738 152 : MakeEditEngine();
739 152 : long nPaperWidth = ( aPageSize.Width() - nLeftMargin - nRightMargin -
740 152 : rParam.nLeft - rParam.nRight ) * 100 / nZoom;
741 152 : if (rParam.pBorder)
742 152 : nPaperWidth -= ( rParam.pBorder->GetDistance(BOX_LINE_LEFT) +
743 152 : rParam.pBorder->GetDistance(BOX_LINE_RIGHT) +
744 152 : lcl_LineTotal(rParam.pBorder->GetLeft()) +
745 456 : lcl_LineTotal(rParam.pBorder->GetRight()) ) * 100 / nZoom;
746 :
747 152 : if (rParam.pShadow && rParam.pShadow->GetLocation() != SVX_SHADOW_NONE)
748 0 : nPaperWidth -= ( rParam.pShadow->CalcShadowSpace(SHADOW_LEFT) +
749 0 : rParam.pShadow->CalcShadowSpace(SHADOW_RIGHT) ) * 100L / nZoom;
750 :
751 152 : pEditEngine->SetPaperSize( Size( nPaperWidth, 10000 ) );
752 :
753 152 : long nMaxHeight = 0;
754 152 : if ( rParam.pLeft )
755 : {
756 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pLeft->GetLeftArea() ) );
757 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pLeft->GetCenterArea() ) );
758 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pLeft->GetRightArea() ) );
759 : }
760 152 : if ( rParam.pRight )
761 : {
762 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pRight->GetLeftArea() ) );
763 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pRight->GetCenterArea() ) );
764 152 : nMaxHeight = Max( nMaxHeight, TextHeight( rParam.pRight->GetRightArea() ) );
765 : }
766 :
767 152 : rParam.nHeight = nMaxHeight + rParam.nDistance;
768 152 : if (rParam.pBorder)
769 152 : rParam.nHeight += rParam.pBorder->GetDistance(BOX_LINE_TOP) +
770 152 : rParam.pBorder->GetDistance(BOX_LINE_BOTTOM) +
771 152 : lcl_LineTotal( rParam.pBorder->GetTop() ) +
772 456 : lcl_LineTotal( rParam.pBorder->GetBottom() );
773 152 : if (rParam.pShadow && rParam.pShadow->GetLocation() != SVX_SHADOW_NONE)
774 0 : rParam.nHeight += rParam.pShadow->CalcShadowSpace(SHADOW_TOP) +
775 0 : rParam.pShadow->CalcShadowSpace(SHADOW_BOTTOM);
776 :
777 152 : if (rParam.nHeight < rParam.nManHeight)
778 88 : rParam.nHeight = rParam.nManHeight; // eingestelltes Minimum
779 : }
780 172 : }
781 :
782 69 : void ScPrintFunc::InitParam( const ScPrintOptions* pOptions )
783 : {
784 69 : if (!pParamSet)
785 69 : return;
786 :
787 : // TabPage "Seite"
788 69 : const SvxLRSpaceItem* pLRItem = (const SvxLRSpaceItem*) &pParamSet->Get( ATTR_LRSPACE );
789 : long nTmp;
790 69 : nTmp = pLRItem->GetLeft();
791 69 : nLeftMargin = nTmp < 0 ? 0 : sal_uInt16(nTmp);
792 69 : nTmp = pLRItem->GetRight();
793 69 : nRightMargin = nTmp < 0 ? 0 : sal_uInt16(nTmp);
794 69 : const SvxULSpaceItem* pULItem = (const SvxULSpaceItem*) &pParamSet->Get( ATTR_ULSPACE );
795 69 : nTopMargin = pULItem->GetUpper();
796 69 : nBottomMargin = pULItem->GetLower();
797 :
798 69 : const SvxPageItem* pPageItem = (const SvxPageItem*) &pParamSet->Get( ATTR_PAGE );
799 69 : nPageUsage = pPageItem->GetPageUsage();
800 69 : bLandscape = pPageItem->IsLandscape();
801 69 : aFieldData.eNumType = pPageItem->GetNumType();
802 :
803 69 : bCenterHor = ((const SfxBoolItem&) pParamSet->Get(ATTR_PAGE_HORCENTER)).GetValue();
804 69 : bCenterVer = ((const SfxBoolItem&) pParamSet->Get(ATTR_PAGE_VERCENTER)).GetValue();
805 :
806 69 : aPageSize = ((const SvxSizeItem&) pParamSet->Get(ATTR_PAGE_SIZE)).GetSize();
807 69 : if ( !aPageSize.Width() || !aPageSize.Height() )
808 : {
809 : OSL_FAIL("PageSize Null ?!?!?");
810 0 : aPageSize = SvxPaperInfo::GetPaperSize( PAPER_A4 );
811 : }
812 :
813 69 : pBorderItem = (const SvxBoxItem*) &pParamSet->Get(ATTR_BORDER);
814 69 : pBackgroundItem = (const SvxBrushItem*) &pParamSet->Get(ATTR_BACKGROUND);
815 69 : pShadowItem = (const SvxShadowItem*) &pParamSet->Get(ATTR_SHADOW);
816 :
817 : // TabPage "Kopfzeile"
818 :
819 69 : aHdr.pLeft = (const ScPageHFItem*) &pParamSet->Get(ATTR_PAGE_HEADERLEFT); // Inhalt
820 69 : aHdr.pRight = (const ScPageHFItem*) &pParamSet->Get(ATTR_PAGE_HEADERRIGHT);
821 :
822 : const SvxSetItem* pHeaderSetItem;
823 69 : const SfxItemSet* pHeaderSet = NULL;
824 69 : if ( pParamSet->GetItemState( ATTR_PAGE_HEADERSET, false,
825 69 : (const SfxPoolItem**)&pHeaderSetItem ) == SFX_ITEM_SET )
826 : {
827 69 : pHeaderSet = &pHeaderSetItem->GetItemSet();
828 : // Kopfzeile hat unteren Abstand
829 69 : aHdr.nDistance = ((const SvxULSpaceItem&) pHeaderSet->Get(ATTR_ULSPACE)).GetLower();
830 : }
831 69 : lcl_FillHFParam( aHdr, pHeaderSet );
832 :
833 : // TabPage "Fusszeile"
834 :
835 69 : aFtr.pLeft = (const ScPageHFItem*) &pParamSet->Get(ATTR_PAGE_FOOTERLEFT); // Inhalt
836 69 : aFtr.pRight = (const ScPageHFItem*) &pParamSet->Get(ATTR_PAGE_FOOTERRIGHT);
837 :
838 : const SvxSetItem* pFooterSetItem;
839 69 : const SfxItemSet* pFooterSet = NULL;
840 69 : if ( pParamSet->GetItemState( ATTR_PAGE_FOOTERSET, false,
841 69 : (const SfxPoolItem**)&pFooterSetItem ) == SFX_ITEM_SET )
842 : {
843 69 : pFooterSet = &pFooterSetItem->GetItemSet();
844 : // Fusszeile hat oberen Abstand
845 69 : aFtr.nDistance = ((const SvxULSpaceItem&) pFooterSet->Get(ATTR_ULSPACE)).GetUpper();
846 : }
847 69 : lcl_FillHFParam( aFtr, pFooterSet );
848 :
849 : //------------------------------------------------------
850 : // Table-/Area-Params aus einzelnen Items zusammenbauen:
851 : //------------------------------------------------------
852 : // TabPage "Tabelle"
853 :
854 69 : const SfxUInt16Item* pScaleItem = NULL;
855 69 : const ScPageScaleToItem* pScaleToItem = NULL;
856 69 : const SfxUInt16Item* pScaleToPagesItem = NULL;
857 : SfxItemState eState;
858 :
859 : eState = pParamSet->GetItemState( ATTR_PAGE_SCALE, false,
860 69 : (const SfxPoolItem**)&pScaleItem );
861 69 : if ( SFX_ITEM_DEFAULT == eState )
862 : pScaleItem = (const SfxUInt16Item*)
863 44 : &pParamSet->GetPool()->GetDefaultItem( ATTR_PAGE_SCALE );
864 :
865 : eState = pParamSet->GetItemState( ATTR_PAGE_SCALETO, false,
866 69 : (const SfxPoolItem**)&pScaleToItem );
867 69 : if ( SFX_ITEM_DEFAULT == eState )
868 : pScaleToItem = (const ScPageScaleToItem*)
869 69 : &pParamSet->GetPool()->GetDefaultItem( ATTR_PAGE_SCALETO );
870 :
871 : eState = pParamSet->GetItemState( ATTR_PAGE_SCALETOPAGES, false,
872 69 : (const SfxPoolItem**)&pScaleToPagesItem );
873 69 : if ( SFX_ITEM_DEFAULT == eState )
874 : pScaleToPagesItem = (const SfxUInt16Item*)
875 69 : &pParamSet->GetPool()->GetDefaultItem( ATTR_PAGE_SCALETOPAGES );
876 :
877 : OSL_ENSURE( pScaleItem && pScaleToItem && pScaleToPagesItem, "Missing ScaleItem! :-/" );
878 :
879 69 : aTableParam.bCellContent = sal_True;
880 69 : aTableParam.bNotes = GET_BOOL(pParamSet,ATTR_PAGE_NOTES);
881 69 : aTableParam.bGrid = GET_BOOL(pParamSet,ATTR_PAGE_GRID);
882 69 : aTableParam.bHeaders = GET_BOOL(pParamSet,ATTR_PAGE_HEADERS);
883 69 : aTableParam.bFormulas = GET_BOOL(pParamSet,ATTR_PAGE_FORMULAS);
884 69 : aTableParam.bNullVals = GET_BOOL(pParamSet,ATTR_PAGE_NULLVALS);
885 69 : aTableParam.bCharts = GET_SHOW(pParamSet,ATTR_PAGE_CHARTS);
886 69 : aTableParam.bObjects = GET_SHOW(pParamSet,ATTR_PAGE_OBJECTS);
887 69 : aTableParam.bDrawings = GET_SHOW(pParamSet,ATTR_PAGE_DRAWINGS);
888 69 : aTableParam.bTopDown = GET_BOOL(pParamSet,ATTR_PAGE_TOPDOWN);
889 69 : aTableParam.bLeftRight = !aTableParam.bLeftRight;
890 69 : aTableParam.nFirstPageNo = GET_USHORT(pParamSet,ATTR_PAGE_FIRSTPAGENO);
891 69 : if (!aTableParam.nFirstPageNo)
892 19 : aTableParam.nFirstPageNo = (sal_uInt16) nPageStart; // von vorheriger Tabelle
893 :
894 69 : if ( pScaleItem && pScaleToItem && pScaleToPagesItem )
895 : {
896 69 : sal_uInt16 nScaleAll = pScaleItem->GetValue();
897 69 : sal_uInt16 nScaleToPages = pScaleToPagesItem->GetValue();
898 :
899 69 : aTableParam.bScaleNone = (nScaleAll == 100);
900 69 : aTableParam.bScaleAll = (nScaleAll > 0 );
901 69 : aTableParam.bScaleTo = pScaleToItem->IsValid();
902 69 : aTableParam.bScalePageNum = (nScaleToPages > 0 );
903 69 : aTableParam.nScaleAll = nScaleAll;
904 69 : aTableParam.nScaleWidth = pScaleToItem->GetWidth();
905 69 : aTableParam.nScaleHeight = pScaleToItem->GetHeight();
906 69 : aTableParam.nScalePageNum = nScaleToPages;
907 : }
908 : else
909 : {
910 0 : aTableParam.bScaleNone = sal_True;
911 0 : aTableParam.bScaleAll = false;
912 0 : aTableParam.bScaleTo = false;
913 0 : aTableParam.bScalePageNum = false;
914 0 : aTableParam.nScaleAll = 0;
915 0 : aTableParam.nScaleWidth = 0;
916 0 : aTableParam.nScaleHeight = 0;
917 0 : aTableParam.nScalePageNum = 0;
918 : }
919 :
920 : // skip empty pages only if options with that flag are passed
921 69 : aTableParam.bSkipEmpty = pOptions && pOptions->GetSkipEmpty();
922 69 : if ( pPageData )
923 0 : aTableParam.bSkipEmpty = false;
924 : // Wenn pPageData gesetzt ist, interessieren fuer die Umbruch-Vorschau
925 : // nur die Umbrueche, leere Seiten werden nicht speziell behandelt
926 :
927 : //------------------------------------------------------
928 : // TabPage "Bereiche":
929 : //------------------------------------------------------
930 :
931 : //! alle PrintAreas der Tabelle durchgehen !!!
932 69 : const ScRange* pPrintArea = pDoc->GetPrintRange( nPrintTab, 0 );
933 69 : const ScRange* pRepeatCol = pDoc->GetRepeatColRange( nPrintTab );
934 69 : const ScRange* pRepeatRow = pDoc->GetRepeatRowRange( nPrintTab );
935 :
936 : // ATTR_PAGE_PRINTTABLES wird ignoriert
937 :
938 69 : if ( pUserArea ) // UserArea (Selektion) hat Vorrang
939 : {
940 : bPrintCurrentTable =
941 0 : aAreaParam.bPrintArea = sal_True; // Selektion
942 0 : aAreaParam.aPrintArea = *pUserArea;
943 :
944 : // Die Tabellen-Abfrage ist schon in DocShell::Print, hier immer
945 0 : aAreaParam.aPrintArea.aStart.SetTab(nPrintTab);
946 0 : aAreaParam.aPrintArea.aEnd.SetTab(nPrintTab);
947 : }
948 69 : else if ( pDoc->HasPrintRange() )
949 : {
950 69 : if ( pPrintArea ) // mindestens eine gesetzt ?
951 : {
952 : bPrintCurrentTable =
953 0 : aAreaParam.bPrintArea = sal_True;
954 0 : aAreaParam.aPrintArea = *pPrintArea;
955 :
956 0 : bMultiArea = ( pDoc->GetPrintRangeCount(nPrintTab) > 1 );
957 : }
958 : else
959 : {
960 : // do not print hidden sheets with "Print entire sheet" flag
961 69 : bPrintCurrentTable = pDoc->IsPrintEntireSheet( nPrintTab ) && pDoc->IsVisible( nPrintTab );
962 69 : aAreaParam.bPrintArea = !bPrintCurrentTable; // otherwise the table is always counted
963 : }
964 : }
965 : else
966 : {
967 : // don't print hidden tables if there's no print range defined there
968 0 : if ( pDoc->IsVisible( nPrintTab ) )
969 : {
970 0 : aAreaParam.bPrintArea = false;
971 0 : bPrintCurrentTable = sal_True;
972 : }
973 : else
974 : {
975 0 : aAreaParam.bPrintArea = sal_True; // otherwise the table is always counted
976 0 : bPrintCurrentTable = false;
977 : }
978 : }
979 :
980 69 : if ( pRepeatCol )
981 : {
982 0 : aAreaParam.bRepeatCol = sal_True;
983 0 : aAreaParam.aRepeatCol = *pRepeatCol;
984 0 : nRepeatStartCol = pRepeatCol->aStart.Col();
985 0 : nRepeatEndCol = pRepeatCol->aEnd .Col();
986 : }
987 : else
988 : {
989 69 : aAreaParam.bRepeatCol = false;
990 69 : nRepeatStartCol = nRepeatEndCol = SCCOL_REPEAT_NONE;
991 : }
992 :
993 69 : if ( pRepeatRow )
994 : {
995 0 : aAreaParam.bRepeatRow = sal_True;
996 0 : aAreaParam.aRepeatRow = *pRepeatRow;
997 0 : nRepeatStartRow = pRepeatRow->aStart.Row();
998 0 : nRepeatEndRow = pRepeatRow->aEnd .Row();
999 : }
1000 : else
1001 : {
1002 69 : aAreaParam.bRepeatRow = false;
1003 69 : nRepeatStartRow = nRepeatEndRow = SCROW_REPEAT_NONE;
1004 : }
1005 :
1006 : //
1007 : // Seiten aufteilen
1008 : //
1009 :
1010 69 : if (!bState)
1011 : {
1012 69 : nTabPages = CountPages(); // berechnet auch Zoom
1013 69 : nTotalPages = nTabPages;
1014 69 : nTotalPages += CountNotePages();
1015 : }
1016 : else
1017 : {
1018 0 : CalcPages(); // nur Umbrueche suchen
1019 0 : CountNotePages(); // Notizen zaehlen, auch wenn Seitenzahl schon bekannt
1020 : }
1021 :
1022 69 : if (nDocPages)
1023 0 : aFieldData.nTotalPages = nDocPages;
1024 : else
1025 69 : aFieldData.nTotalPages = nTotalPages;
1026 :
1027 69 : SetDateTime( Date( Date::SYSTEM ), Time( Time::SYSTEM ) );
1028 :
1029 69 : if( pDocShell->getDocProperties()->getTitle().getLength() != 0 )
1030 0 : aFieldData.aTitle = pDocShell->getDocProperties()->getTitle();
1031 : else
1032 69 : aFieldData.aTitle = pDocShell->GetTitle();
1033 :
1034 69 : const INetURLObject& rURLObj = pDocShell->GetMedium()->GetURLObject();
1035 69 : aFieldData.aLongDocName = rURLObj.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
1036 69 : if ( aFieldData.aLongDocName.Len() )
1037 69 : aFieldData.aShortDocName = rURLObj.GetName( INetURLObject::DECODE_UNAMBIGUOUS );
1038 : else
1039 0 : aFieldData.aShortDocName = aFieldData.aLongDocName = aFieldData.aTitle;
1040 :
1041 : // Druckereinstellungen (Orientation, Paper) jetzt erst bei DoPrint
1042 : }
1043 :
1044 0 : Size ScPrintFunc::GetDataSize() const
1045 : {
1046 0 : Size aSize = aPageSize;
1047 0 : aSize.Width() -= nLeftMargin + nRightMargin;
1048 0 : aSize.Height() -= nTopMargin + nBottomMargin;
1049 0 : aSize.Height() -= aHdr.nHeight + aFtr.nHeight;
1050 0 : return aSize;
1051 : }
1052 :
1053 0 : void ScPrintFunc::GetScaleData( Size& rPhysSize, long& rDocHdr, long& rDocFtr )
1054 : {
1055 0 : rPhysSize = aPageSize;
1056 0 : rPhysSize.Width() -= nLeftMargin + nRightMargin;
1057 0 : rPhysSize.Height() -= nTopMargin + nBottomMargin;
1058 :
1059 0 : rDocHdr = aHdr.nHeight;
1060 0 : rDocFtr = aFtr.nHeight;
1061 0 : }
1062 :
1063 69 : void ScPrintFunc::SetDateTime( const Date& rDate, const Time& rTime )
1064 : {
1065 69 : aFieldData.aDate = rDate;
1066 69 : aFieldData.aTime = rTime;
1067 69 : }
1068 :
1069 0 : static void lcl_DrawGraphic( const Graphic &rGraphic, OutputDevice *pOut,
1070 : const Rectangle &rGrf, const Rectangle &rOut )
1071 : {
1072 0 : const bool bNotInside = !rOut.IsInside( rGrf );
1073 0 : if ( bNotInside )
1074 : {
1075 0 : pOut->Push();
1076 0 : pOut->IntersectClipRegion( rOut );
1077 : }
1078 :
1079 0 : ((Graphic&)rGraphic).Draw( pOut, rGrf.TopLeft(), rGrf.GetSize() );
1080 :
1081 0 : if ( bNotInside )
1082 0 : pOut->Pop();
1083 0 : }
1084 :
1085 0 : static void lcl_DrawGraphic( const SvxBrushItem &rBrush, OutputDevice *pOut, OutputDevice* pRefDev,
1086 : const Rectangle &rOrg, const Rectangle &rOut )
1087 : {
1088 0 : Size aGrfSize(0,0);
1089 0 : const Graphic *pGraphic = rBrush.GetGraphic();
1090 : SvxGraphicPosition ePos;
1091 0 : if ( pGraphic && pGraphic->IsSupportedGraphic() )
1092 : {
1093 0 : const MapMode aMapMM( MAP_100TH_MM );
1094 0 : if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
1095 0 : aGrfSize = pRefDev->PixelToLogic( pGraphic->GetPrefSize(), aMapMM );
1096 : else
1097 : aGrfSize = OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
1098 0 : pGraphic->GetPrefMapMode(), aMapMM );
1099 0 : ePos = rBrush.GetGraphicPos();
1100 : }
1101 : else
1102 0 : ePos = GPOS_NONE;
1103 :
1104 0 : Point aPos;
1105 0 : Size aDrawSize = aGrfSize;
1106 :
1107 0 : bool bDraw = true;
1108 0 : switch ( ePos )
1109 : {
1110 0 : case GPOS_LT: aPos = rOrg.TopLeft();
1111 0 : break;
1112 0 : case GPOS_MT: aPos.Y() = rOrg.Top();
1113 0 : aPos.X() = rOrg.Left() + rOrg.GetSize().Width()/2 - aGrfSize.Width()/2;
1114 0 : break;
1115 0 : case GPOS_RT: aPos.Y() = rOrg.Top();
1116 0 : aPos.X() = rOrg.Right() - aGrfSize.Width();
1117 0 : break;
1118 :
1119 0 : case GPOS_LM: aPos.Y() = rOrg.Top() + rOrg.GetSize().Height()/2 - aGrfSize.Height()/2;
1120 0 : aPos.X() = rOrg.Left();
1121 0 : break;
1122 0 : case GPOS_MM: aPos.Y() = rOrg.Top() + rOrg.GetSize().Height()/2 - aGrfSize.Height()/2;
1123 0 : aPos.X() = rOrg.Left() + rOrg.GetSize().Width()/2 - aGrfSize.Width()/2;
1124 0 : break;
1125 0 : case GPOS_RM: aPos.Y() = rOrg.Top() + rOrg.GetSize().Height()/2 - aGrfSize.Height()/2;
1126 0 : aPos.X() = rOrg.Right() - aGrfSize.Width();
1127 0 : break;
1128 :
1129 0 : case GPOS_LB: aPos.Y() = rOrg.Bottom() - aGrfSize.Height();
1130 0 : aPos.X() = rOrg.Left();
1131 0 : break;
1132 0 : case GPOS_MB: aPos.Y() = rOrg.Bottom() - aGrfSize.Height();
1133 0 : aPos.X() = rOrg.Left() + rOrg.GetSize().Width()/2 - aGrfSize.Width()/2;
1134 0 : break;
1135 0 : case GPOS_RB: aPos.Y() = rOrg.Bottom() - aGrfSize.Height();
1136 0 : aPos.X() = rOrg.Right() - aGrfSize.Width();
1137 0 : break;
1138 :
1139 : case GPOS_AREA:
1140 0 : aPos = rOrg.TopLeft();
1141 0 : aDrawSize = rOrg.GetSize();
1142 0 : break;
1143 : case GPOS_TILED:
1144 : {
1145 : // use GraphicObject::DrawTiled instead of an own loop
1146 : // (pixel rounding is handled correctly, and a very small bitmap
1147 : // is duplicated into a bigger one for better performance)
1148 :
1149 0 : GraphicObject aObject( *pGraphic );
1150 :
1151 0 : if( pOut->GetPDFWriter() &&
1152 0 : (aObject.GetType() == GRAPHIC_BITMAP || aObject.GetType() == GRAPHIC_DEFAULT) )
1153 : {
1154 : // For PDF export, every draw
1155 : // operation for bitmaps takes a noticeable
1156 : // amount of place (~50 characters). Thus,
1157 : // optimize between tile bitmap size and
1158 : // number of drawing operations here.
1159 : //
1160 : // A_out
1161 : // n_chars = k1 * ---------- + k2 * A_bitmap
1162 : // A_bitmap
1163 : //
1164 : // minimum n_chars is obtained for (derive for
1165 : // A_bitmap, set to 0, take positive
1166 : // solution):
1167 : // k1
1168 : // A_bitmap = Sqrt( ---- A_out )
1169 : // k2
1170 : //
1171 : // where k1 is the number of chars per draw
1172 : // operation, and k2 is the number of chars
1173 : // per bitmap pixel. This is approximately 50
1174 : // and 7 for current PDF writer, respectively.
1175 : //
1176 0 : const double k1( 50 );
1177 0 : const double k2( 7 );
1178 0 : const Size aSize( rOrg.GetSize() );
1179 0 : const double Abitmap( k1/k2 * aSize.Width()*aSize.Height() );
1180 :
1181 : aObject.DrawTiled( pOut, rOrg, aGrfSize, Size(0,0),
1182 : NULL, GRFMGR_DRAW_STANDARD,
1183 0 : ::std::max( 128, static_cast<int>( sqrt(sqrt( Abitmap)) + .5 ) ) );
1184 : }
1185 : else
1186 : {
1187 0 : aObject.DrawTiled( pOut, rOrg, aGrfSize, Size(0,0) );
1188 : }
1189 :
1190 0 : bDraw = false;
1191 : }
1192 0 : break;
1193 :
1194 : case GPOS_NONE:
1195 0 : bDraw = false;
1196 0 : break;
1197 :
1198 : default: OSL_ENSURE( !pOut, "new Graphic position?" );
1199 : }
1200 0 : Rectangle aGrf( aPos,aDrawSize );
1201 0 : if ( bDraw && aGrf.IsOver( rOut ) )
1202 : {
1203 0 : lcl_DrawGraphic( *pGraphic, pOut, aGrf, rOut );
1204 : }
1205 0 : }
1206 :
1207 : // Rahmen wird nach innen gezeichnet
1208 :
1209 0 : void ScPrintFunc::DrawBorder( long nScrX, long nScrY, long nScrW, long nScrH,
1210 : const SvxBoxItem* pBorderData, const SvxBrushItem* pBackground,
1211 : const SvxShadowItem* pShadow )
1212 : {
1213 : //! direkte Ausgabe aus SvxBoxItem !!!
1214 :
1215 0 : if (pBorderData)
1216 0 : if ( !pBorderData->GetTop() && !pBorderData->GetBottom() && !pBorderData->GetLeft() &&
1217 0 : !pBorderData->GetRight() )
1218 0 : pBorderData = NULL;
1219 :
1220 0 : if (!pBorderData && !pBackground && !pShadow)
1221 : return; // nichts zu tun
1222 :
1223 0 : long nLeft = 0;
1224 0 : long nRight = 0;
1225 0 : long nTop = 0;
1226 0 : long nBottom = 0;
1227 :
1228 : // aFrameRect - aussen um die Umrandung, ohne Schatten
1229 0 : if ( pShadow && pShadow->GetLocation() != SVX_SHADOW_NONE )
1230 : {
1231 0 : nLeft += (long) ( pShadow->CalcShadowSpace(SHADOW_LEFT) * nScaleX );
1232 0 : nRight += (long) ( pShadow->CalcShadowSpace(SHADOW_RIGHT) * nScaleX );
1233 0 : nTop += (long) ( pShadow->CalcShadowSpace(SHADOW_TOP) * nScaleY );
1234 0 : nBottom += (long) ( pShadow->CalcShadowSpace(SHADOW_BOTTOM) * nScaleY );
1235 : }
1236 : Rectangle aFrameRect( Point(nScrX+nLeft, nScrY+nTop),
1237 0 : Size(nScrW-nLeft-nRight, nScrH-nTop-nBottom) );
1238 :
1239 : // Mitte der Umrandung, um Linien ueber OutputData zu zeichnen:
1240 0 : if (pBorderData)
1241 : {
1242 0 : nLeft += (long) ( lcl_LineTotal(pBorderData->GetLeft()) * nScaleX / 2 );
1243 0 : nRight += (long) ( lcl_LineTotal(pBorderData->GetRight()) * nScaleX / 2 );
1244 0 : nTop += (long) ( lcl_LineTotal(pBorderData->GetTop()) * nScaleY / 2 );
1245 0 : nBottom += (long) ( lcl_LineTotal(pBorderData->GetBottom()) * nScaleY / 2 );
1246 : }
1247 0 : long nEffHeight = nScrH - nTop - nBottom;
1248 0 : long nEffWidth = nScrW - nLeft - nRight;
1249 0 : if (nEffHeight<=0 || nEffWidth<=0)
1250 : return; // leer
1251 :
1252 0 : if ( pBackground )
1253 : {
1254 0 : if (pBackground->GetGraphicPos() != GPOS_NONE)
1255 : {
1256 : OutputDevice* pRefDev;
1257 0 : if ( bIsRender )
1258 0 : pRefDev = pDev; // don't use printer for PDF
1259 : else
1260 0 : pRefDev = pDoc->GetPrinter(); // use printer also for preview
1261 :
1262 0 : lcl_DrawGraphic( *pBackground, pDev, pRefDev, aFrameRect, aFrameRect );
1263 : }
1264 : else
1265 : {
1266 0 : pDev->SetFillColor(pBackground->GetColor());
1267 0 : pDev->SetLineColor();
1268 0 : pDev->DrawRect(aFrameRect);
1269 : }
1270 : }
1271 :
1272 0 : if ( pShadow && pShadow->GetLocation() != SVX_SHADOW_NONE )
1273 : {
1274 0 : pDev->SetFillColor(pShadow->GetColor());
1275 0 : pDev->SetLineColor();
1276 0 : long nShadowX = (long) ( pShadow->GetWidth() * nScaleX );
1277 0 : long nShadowY = (long) ( pShadow->GetWidth() * nScaleY );
1278 0 : switch (pShadow->GetLocation())
1279 : {
1280 : case SVX_SHADOW_TOPLEFT:
1281 : pDev->DrawRect( Rectangle(
1282 0 : aFrameRect.Left()-nShadowX, aFrameRect.Top()-nShadowY,
1283 0 : aFrameRect.Right()-nShadowX, aFrameRect.Top() ) );
1284 : pDev->DrawRect( Rectangle(
1285 0 : aFrameRect.Left()-nShadowX, aFrameRect.Top()-nShadowY,
1286 0 : aFrameRect.Left(), aFrameRect.Bottom()-nShadowY ) );
1287 0 : break;
1288 : case SVX_SHADOW_TOPRIGHT:
1289 : pDev->DrawRect( Rectangle(
1290 0 : aFrameRect.Left()+nShadowX, aFrameRect.Top()-nShadowY,
1291 0 : aFrameRect.Right()+nShadowX, aFrameRect.Top() ) );
1292 : pDev->DrawRect( Rectangle(
1293 0 : aFrameRect.Right(), aFrameRect.Top()-nShadowY,
1294 0 : aFrameRect.Right()+nShadowX, aFrameRect.Bottom()-nShadowY ) );
1295 0 : break;
1296 : case SVX_SHADOW_BOTTOMLEFT:
1297 : pDev->DrawRect( Rectangle(
1298 0 : aFrameRect.Left()-nShadowX, aFrameRect.Bottom(),
1299 0 : aFrameRect.Right()-nShadowX, aFrameRect.Bottom()+nShadowY ) );
1300 : pDev->DrawRect( Rectangle(
1301 0 : aFrameRect.Left()-nShadowX, aFrameRect.Top()+nShadowY,
1302 0 : aFrameRect.Left(), aFrameRect.Bottom()+nShadowY ) );
1303 0 : break;
1304 : case SVX_SHADOW_BOTTOMRIGHT:
1305 : pDev->DrawRect( Rectangle(
1306 0 : aFrameRect.Left()+nShadowX, aFrameRect.Bottom(),
1307 0 : aFrameRect.Right()+nShadowX, aFrameRect.Bottom()+nShadowY ) );
1308 : pDev->DrawRect( Rectangle(
1309 0 : aFrameRect.Right(), aFrameRect.Top()+nShadowY,
1310 0 : aFrameRect.Right()+nShadowX, aFrameRect.Bottom()+nShadowY ) );
1311 0 : break;
1312 : default:
1313 : {
1314 : // added to avoid warnings
1315 : }
1316 : }
1317 : }
1318 :
1319 0 : if (pBorderData)
1320 : {
1321 0 : ScDocument* pBorderDoc = new ScDocument( SCDOCMODE_UNDO );
1322 0 : pBorderDoc->InitUndo( pDoc, 0,0, sal_True,sal_True );
1323 0 : if (pBorderData)
1324 0 : pBorderDoc->ApplyAttr( 0,0,0, *pBorderData );
1325 :
1326 0 : ScTableInfo aTabInfo;
1327 : pBorderDoc->FillInfo( aTabInfo, 0,0, 0,0, 0,
1328 0 : nScaleX, nScaleY, false, false );
1329 : OSL_ENSURE(aTabInfo.mnArrCount,"nArrCount == 0");
1330 :
1331 0 : aTabInfo.mpRowInfo[1].nHeight = (sal_uInt16) nEffHeight;
1332 0 : aTabInfo.mpRowInfo[0].pCellInfo[1].nWidth =
1333 0 : aTabInfo.mpRowInfo[1].pCellInfo[1].nWidth = (sal_uInt16) nEffWidth;
1334 :
1335 : ScOutputData aOutputData( pDev, OUTTYPE_PRINTER, aTabInfo, pBorderDoc, 0,
1336 0 : nScrX+nLeft, nScrY+nTop, 0,0, 0,0, nScaleX, nScaleY );
1337 0 : aOutputData.SetUseStyleColor( bUseStyleColor );
1338 :
1339 0 : if (pBorderData)
1340 0 : aOutputData.DrawFrame();
1341 :
1342 0 : delete pBorderDoc;
1343 : }
1344 : }
1345 :
1346 0 : void ScPrintFunc::PrintColHdr( SCCOL nX1, SCCOL nX2, long nScrX, long nScrY )
1347 : {
1348 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nPrintTab );
1349 0 : long nLayoutSign = bLayoutRTL ? -1 : 1;
1350 :
1351 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
1352 0 : long nOneX = aOnePixel.Width();
1353 0 : long nOneY = aOnePixel.Height();
1354 : SCCOL nCol;
1355 :
1356 0 : long nHeight = (long) (PRINT_HEADER_HEIGHT * nScaleY);
1357 0 : long nEndY = nScrY + nHeight - nOneY;
1358 :
1359 0 : long nPosX = nScrX;
1360 0 : if ( bLayoutRTL )
1361 : {
1362 0 : for (nCol=nX1; nCol<=nX2; nCol++)
1363 0 : nPosX += (long)( pDoc->GetColWidth( nCol, nPrintTab ) * nScaleX );
1364 : }
1365 : else
1366 0 : nPosX -= nOneX;
1367 0 : long nPosY = nScrY - nOneY;
1368 0 : String aText;
1369 :
1370 0 : for (nCol=nX1; nCol<=nX2; nCol++)
1371 : {
1372 0 : sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nPrintTab );
1373 0 : if (nDocW)
1374 : {
1375 0 : long nWidth = (long) (nDocW * nScaleX);
1376 0 : long nEndX = nPosX + nWidth * nLayoutSign;
1377 :
1378 0 : pDev->DrawRect( Rectangle( nPosX,nPosY,nEndX,nEndY ) );
1379 :
1380 0 : aText = ::ScColToAlpha( nCol);
1381 0 : long nTextWidth = pDev->GetTextWidth(aText);
1382 0 : long nTextHeight = pDev->GetTextHeight();
1383 0 : long nAddX = ( nWidth - nTextWidth ) / 2;
1384 0 : long nAddY = ( nHeight - nTextHeight ) / 2;
1385 0 : long nTextPosX = nPosX+nAddX;
1386 0 : if ( bLayoutRTL )
1387 0 : nTextPosX -= nWidth;
1388 0 : pDev->DrawText( Point( nTextPosX,nPosY+nAddY ), aText );
1389 :
1390 0 : nPosX = nEndX;
1391 : }
1392 0 : }
1393 0 : }
1394 :
1395 0 : void ScPrintFunc::PrintRowHdr( SCROW nY1, SCROW nY2, long nScrX, long nScrY )
1396 : {
1397 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
1398 0 : long nOneX = aOnePixel.Width();
1399 0 : long nOneY = aOnePixel.Height();
1400 :
1401 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nPrintTab );
1402 :
1403 0 : long nWidth = (long) (PRINT_HEADER_WIDTH * nScaleX);
1404 0 : long nEndX = nScrX + nWidth;
1405 0 : long nPosX = nScrX;
1406 0 : if ( !bLayoutRTL )
1407 : {
1408 0 : nEndX -= nOneX;
1409 0 : nPosX -= nOneX;
1410 : }
1411 0 : long nPosY = nScrY - nOneY;
1412 0 : String aText;
1413 :
1414 0 : for (SCROW nRow=nY1; nRow<=nY2; nRow++)
1415 : {
1416 0 : sal_uInt16 nDocH = pDoc->GetRowHeight( nRow, nPrintTab );
1417 0 : if (nDocH)
1418 : {
1419 0 : long nHeight = (long) (nDocH * nScaleY);
1420 0 : long nEndY = nPosY + nHeight;
1421 :
1422 0 : pDev->DrawRect( Rectangle( nPosX,nPosY,nEndX,nEndY ) );
1423 :
1424 0 : aText = String::CreateFromInt32( nRow+1 );
1425 0 : long nTextWidth = pDev->GetTextWidth(aText);
1426 0 : long nTextHeight = pDev->GetTextHeight();
1427 0 : long nAddX = ( nWidth - nTextWidth ) / 2;
1428 0 : long nAddY = ( nHeight - nTextHeight ) / 2;
1429 0 : pDev->DrawText( Point( nPosX+nAddX,nPosY+nAddY ), aText );
1430 :
1431 0 : nPosY = nEndY;
1432 : }
1433 0 : }
1434 0 : }
1435 :
1436 0 : void ScPrintFunc::LocateColHdr( SCCOL nX1, SCCOL nX2, long nScrX, long nScrY,
1437 : sal_Bool bRepCol, ScPreviewLocationData& rLocationData )
1438 : {
1439 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
1440 0 : long nOneX = aOnePixel.Width();
1441 0 : long nOneY = aOnePixel.Height();
1442 :
1443 0 : long nHeight = (long) (PRINT_HEADER_HEIGHT * nScaleY);
1444 0 : long nEndY = nScrY + nHeight - nOneY;
1445 :
1446 0 : long nPosX = nScrX - nOneX;
1447 0 : for (SCCOL nCol=nX1; nCol<=nX2; nCol++)
1448 : {
1449 0 : sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nPrintTab );
1450 0 : if (nDocW)
1451 0 : nPosX += (long) (nDocW * nScaleX);
1452 : }
1453 0 : Rectangle aCellRect( nScrX, nScrY, nPosX, nEndY );
1454 0 : rLocationData.AddColHeaders( aCellRect, nX1, nX2, bRepCol );
1455 0 : }
1456 :
1457 0 : void ScPrintFunc::LocateRowHdr( SCROW nY1, SCROW nY2, long nScrX, long nScrY,
1458 : sal_Bool bRepRow, ScPreviewLocationData& rLocationData )
1459 : {
1460 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
1461 0 : long nOneX = aOnePixel.Width();
1462 0 : long nOneY = aOnePixel.Height();
1463 :
1464 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nPrintTab );
1465 :
1466 0 : long nWidth = (long) (PRINT_HEADER_WIDTH * nScaleX);
1467 0 : long nEndX = nScrX + nWidth;
1468 0 : if ( !bLayoutRTL )
1469 0 : nEndX -= nOneX;
1470 :
1471 0 : long nPosY = nScrY - nOneY;
1472 0 : nPosY += pDoc->GetScaledRowHeight( nY1, nY2, nPrintTab, nScaleY);
1473 0 : Rectangle aCellRect( nScrX, nScrY, nEndX, nPosY );
1474 0 : rLocationData.AddRowHeaders( aCellRect, nY1, nY2, bRepRow );
1475 0 : }
1476 :
1477 0 : void ScPrintFunc::LocateArea( SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2,
1478 : long nScrX, long nScrY, sal_Bool bRepCol, sal_Bool bRepRow,
1479 : ScPreviewLocationData& rLocationData )
1480 : {
1481 : // get MapMode for drawing objects (same MapMode as in ScOutputData::PrintDrawingLayer)
1482 :
1483 0 : Point aLogPos = OutputDevice::LogicToLogic(Point(nScrX,nScrY), aOffsetMode, aLogicMode);
1484 0 : long nLogStX = aLogPos.X();
1485 0 : long nLogStY = aLogPos.Y();
1486 :
1487 : SCCOL nCol;
1488 0 : Point aTwipOffset;
1489 0 : for (nCol=0; nCol<nX1; nCol++)
1490 0 : aTwipOffset.X() -= pDoc->GetColWidth( nCol, nPrintTab );
1491 0 : aTwipOffset.Y() -= pDoc->GetRowHeight( 0, nY1-1, nPrintTab );
1492 :
1493 0 : Point aMMOffset( aTwipOffset );
1494 0 : aMMOffset.X() = (long)(aMMOffset.X() * HMM_PER_TWIPS);
1495 0 : aMMOffset.Y() = (long)(aMMOffset.Y() * HMM_PER_TWIPS);
1496 0 : aMMOffset += Point( nLogStX, nLogStY );
1497 0 : MapMode aDrawMapMode( MAP_100TH_MM, aMMOffset, aLogicMode.GetScaleX(), aLogicMode.GetScaleY() );
1498 :
1499 : // get pixel rectangle
1500 :
1501 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
1502 0 : long nOneX = aOnePixel.Width();
1503 0 : long nOneY = aOnePixel.Height();
1504 :
1505 0 : long nPosX = nScrX - nOneX;
1506 0 : for (nCol=nX1; nCol<=nX2; nCol++)
1507 : {
1508 0 : sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nPrintTab );
1509 0 : if (nDocW)
1510 0 : nPosX += (long) (nDocW * nScaleX);
1511 : }
1512 :
1513 0 : long nPosY = nScrY - nOneY;
1514 0 : nPosY += pDoc->GetScaledRowHeight( nY1, nY2, nPrintTab, nScaleY);
1515 0 : Rectangle aCellRect( nScrX, nScrY, nPosX, nPosY );
1516 : rLocationData.AddCellRange( aCellRect, ScRange( nX1,nY1,nPrintTab, nX2,nY2,nPrintTab ),
1517 0 : bRepCol, bRepRow, aDrawMapMode );
1518 0 : }
1519 :
1520 0 : void ScPrintFunc::PrintArea( SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2,
1521 : long nScrX, long nScrY,
1522 : sal_Bool bShLeft, sal_Bool bShTop, sal_Bool bShRight, sal_Bool bShBottom )
1523 : {
1524 : // #i47547# nothing to do if the end of the print area is before the end of
1525 : // the repeat columns/rows (don't use negative size for ScOutputData)
1526 0 : if ( nX2 < nX1 || nY2 < nY1 )
1527 0 : return;
1528 :
1529 : //! Flag bei FillInfo uebergeben !!!!!
1530 0 : ScRange aERange;
1531 0 : sal_Bool bEmbed = pDoc->IsEmbedded();
1532 0 : if (bEmbed)
1533 : {
1534 0 : pDoc->GetEmbedded(aERange);
1535 0 : pDoc->ResetEmbedded();
1536 : }
1537 :
1538 0 : Point aPos = OutputDevice::LogicToLogic(Point(nScrX,nScrY), aOffsetMode, aLogicMode);
1539 0 : long nLogStX = aPos.X();
1540 0 : long nLogStY = aPos.Y();
1541 :
1542 : // Daten zusammenstellen
1543 :
1544 0 : ScTableInfo aTabInfo;
1545 : pDoc->FillInfo( aTabInfo, nX1, nY1, nX2, nY2, nPrintTab,
1546 0 : nScaleX, nScaleY, sal_True, aTableParam.bFormulas );
1547 0 : lcl_HidePrint( aTabInfo, nX1, nX2 );
1548 :
1549 0 : if (bEmbed)
1550 0 : pDoc->SetEmbedded(aERange);
1551 :
1552 : ScOutputData aOutputData( pDev, OUTTYPE_PRINTER, aTabInfo, pDoc, nPrintTab,
1553 0 : nScrX, nScrY, nX1, nY1, nX2, nY2, nScaleX, nScaleY );
1554 :
1555 : // #114135#
1556 0 : aOutputData.SetDrawView( pDrawView );
1557 :
1558 : // test if all paint parts are hidden, then a paint is not necessary at all
1559 0 : const Point aMMOffset(aOutputData.PrePrintDrawingLayer(nLogStX, nLogStY));
1560 0 : const bool bHideAllDrawingLayer( pDrawView && pDrawView->getHideOle() && pDrawView->getHideChart()
1561 0 : && pDrawView->getHideDraw() && pDrawView->getHideFormControl() );
1562 :
1563 0 : if(!bHideAllDrawingLayer)
1564 : {
1565 0 : pDev->SetMapMode(aLogicMode);
1566 : // hier kein Clipping setzen (Mapmode wird verschoben)
1567 :
1568 : // #i72502#
1569 0 : aOutputData.PrintDrawingLayer(SC_LAYER_BACK, aMMOffset);
1570 : }
1571 :
1572 0 : pDev->SetMapMode(aOffsetMode);
1573 :
1574 0 : aOutputData.SetShowFormulas( aTableParam.bFormulas );
1575 0 : aOutputData.SetShowNullValues( aTableParam.bNullVals );
1576 0 : aOutputData.SetUseStyleColor( bUseStyleColor );
1577 :
1578 0 : Color aGridColor( COL_BLACK );
1579 0 : if ( bUseStyleColor )
1580 0 : aGridColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor );
1581 0 : aOutputData.SetGridColor( aGridColor );
1582 :
1583 0 : if ( !pPrinter )
1584 : {
1585 0 : OutputDevice* pRefDev = pDoc->GetPrinter(); // auch fuer Preview den Drucker nehmen
1586 0 : Fraction aPrintFrac( nZoom, 100 ); // ohne nManualZoom
1587 : // MapMode, wie er beim Drucken herauskommen wuerde:
1588 0 : pRefDev->SetMapMode( MapMode( MAP_100TH_MM, Point(), aPrintFrac, aPrintFrac ) );
1589 :
1590 : // when rendering (PDF), don't use printer as ref device, but printer's MapMode
1591 : // has to be set anyway, as charts still use it (#106409#)
1592 0 : if ( !bIsRender )
1593 0 : aOutputData.SetRefDevice( pRefDev );
1594 : }
1595 :
1596 0 : if( aTableParam.bCellContent )
1597 0 : aOutputData.DrawBackground();
1598 :
1599 0 : pDev->SetClipRegion( Rectangle( aPos, Size( aOutputData.GetScrW(), aOutputData.GetScrH() ) ) );
1600 0 : pDev->SetClipRegion();
1601 :
1602 0 : if( aTableParam.bCellContent )
1603 : {
1604 0 : aOutputData.DrawExtraShadow( bShLeft, bShTop, bShRight, bShBottom );
1605 0 : aOutputData.DrawFrame();
1606 0 : aOutputData.DrawStrings();
1607 0 : aOutputData.DrawEdit(false);
1608 : }
1609 :
1610 0 : if (aTableParam.bGrid)
1611 0 : aOutputData.DrawGrid( sal_True, false ); // keine Seitenumbrueche
1612 :
1613 0 : aOutputData.AddPDFNotes(); // has no effect if not rendering PDF with notes enabled
1614 :
1615 : // test if all paint parts are hidden, then a paint is not necessary at all
1616 0 : if(!bHideAllDrawingLayer)
1617 : {
1618 : // #i72502#
1619 0 : aOutputData.PrintDrawingLayer(SC_LAYER_FRONT, aMMOffset);
1620 : }
1621 :
1622 : // #i72502#
1623 0 : aOutputData.PrintDrawingLayer(SC_LAYER_INTERN, aMMOffset);
1624 0 : aOutputData.PostPrintDrawingLayer(aMMOffset); // #i74768#
1625 : }
1626 :
1627 0 : sal_Bool ScPrintFunc::IsMirror( long nPageNo ) // Raender spiegeln ?
1628 : {
1629 0 : SvxPageUsage eUsage = (SvxPageUsage) ( nPageUsage & 0x000f );
1630 0 : return ( eUsage == SVX_PAGE_MIRROR && (nPageNo & 1) );
1631 : }
1632 :
1633 0 : sal_Bool ScPrintFunc::IsLeft( long nPageNo ) // linke Fussnoten ?
1634 : {
1635 0 : SvxPageUsage eUsage = (SvxPageUsage) ( nPageUsage & 0x000f );
1636 : sal_Bool bLeft;
1637 0 : if (eUsage == SVX_PAGE_LEFT)
1638 0 : bLeft = sal_True;
1639 0 : else if (eUsage == SVX_PAGE_RIGHT)
1640 0 : bLeft = false;
1641 : else
1642 0 : bLeft = (nPageNo & 1) != 0;
1643 0 : return bLeft;
1644 : }
1645 :
1646 0 : void ScPrintFunc::MakeTableString()
1647 : {
1648 0 : rtl::OUString aTmp;
1649 0 : pDoc->GetName(nPrintTab, aTmp);
1650 0 : aFieldData.aTabName = aTmp;
1651 0 : }
1652 :
1653 152 : void ScPrintFunc::MakeEditEngine()
1654 : {
1655 152 : if (!pEditEngine)
1656 : {
1657 : // can't use document's edit engine pool here,
1658 : // because pool must have twips as default metric
1659 63 : pEditEngine = new ScHeaderEditEngine( EditEngine::CreatePool(), sal_True );
1660 :
1661 63 : pEditEngine->EnableUndo(false);
1662 : //fdo#45869 we want text to be positioned as it would be for the the
1663 : //high dpi printed output, not as would be ideal for the 96dpi preview
1664 : //window itself
1665 63 : pEditEngine->SetRefDevice(pPrinter ? pPrinter : pDoc->GetRefDevice());
1666 : pEditEngine->SetWordDelimiters(
1667 63 : ScEditUtil::ModifyDelimiters( pEditEngine->GetWordDelimiters() ) );
1668 63 : pEditEngine->SetControlWord( pEditEngine->GetControlWord() & ~EE_CNTRL_RTFSTYLESHEETS );
1669 63 : pDoc->ApplyAsianEditSettings( *pEditEngine );
1670 63 : pEditEngine->EnableAutoColor( bUseStyleColor );
1671 :
1672 : // Default-Set fuer Ausrichtung
1673 63 : pEditDefaults = new SfxItemSet( pEditEngine->GetEmptyItemSet() );
1674 :
1675 63 : const ScPatternAttr& rPattern = (const ScPatternAttr&)pDoc->GetPool()->GetDefaultItem(ATTR_PATTERN);
1676 63 : rPattern.FillEditItemSet( pEditDefaults );
1677 : // FillEditItemSet adjusts font height to 1/100th mm,
1678 : // but for header/footer twips is needed, as in the PatternAttr:
1679 63 : pEditDefaults->Put( rPattern.GetItem(ATTR_FONT_HEIGHT), EE_CHAR_FONTHEIGHT );
1680 63 : pEditDefaults->Put( rPattern.GetItem(ATTR_CJK_FONT_HEIGHT), EE_CHAR_FONTHEIGHT_CJK );
1681 63 : pEditDefaults->Put( rPattern.GetItem(ATTR_CTL_FONT_HEIGHT), EE_CHAR_FONTHEIGHT_CTL );
1682 : // dont use font color, because background color is not used
1683 : //! there's no way to set the background for note pages
1684 63 : pEditDefaults->ClearItem( EE_CHAR_COLOR );
1685 63 : if (ScGlobal::IsSystemRTL())
1686 0 : pEditDefaults->Put( SvxFrameDirectionItem( FRMDIR_HORI_RIGHT_TOP, EE_PARA_WRITINGDIR ) );
1687 : }
1688 :
1689 152 : pEditEngine->SetData( aFieldData ); // Seitennummer etc. setzen
1690 152 : }
1691 :
1692 : // nStartY = logic
1693 0 : void ScPrintFunc::PrintHF( long nPageNo, sal_Bool bHeader, long nStartY,
1694 : sal_Bool bDoPrint, ScPreviewLocationData* pLocationData )
1695 : {
1696 0 : const ScPrintHFParam& rParam = bHeader ? aHdr : aFtr;
1697 :
1698 0 : pDev->SetMapMode( aTwipMode ); // Kopf-/Fusszeilen in Twips
1699 :
1700 0 : sal_Bool bLeft = IsLeft(nPageNo) && !rParam.bShared;
1701 0 : const ScPageHFItem* pHFItem = bLeft ? rParam.pLeft : rParam.pRight;
1702 :
1703 0 : long nLineStartX = aPageRect.Left() + rParam.nLeft;
1704 0 : long nLineEndX = aPageRect.Right() - rParam.nRight;
1705 0 : long nLineWidth = nLineEndX - nLineStartX + 1;
1706 :
1707 : // Edit-Engine
1708 :
1709 0 : Point aStart( nLineStartX, nStartY );
1710 0 : Size aPaperSize( nLineWidth, rParam.nHeight-rParam.nDistance );
1711 0 : if ( rParam.pBorder )
1712 : {
1713 0 : long nLeft = lcl_LineTotal( rParam.pBorder->GetLeft() ) + rParam.pBorder->GetDistance(BOX_LINE_LEFT);
1714 0 : long nTop = lcl_LineTotal( rParam.pBorder->GetTop() ) + rParam.pBorder->GetDistance(BOX_LINE_TOP);
1715 0 : aStart.X() += nLeft;
1716 0 : aStart.Y() += nTop;
1717 0 : aPaperSize.Width() -= nLeft + lcl_LineTotal( rParam.pBorder->GetRight() ) + rParam.pBorder->GetDistance(BOX_LINE_RIGHT);
1718 0 : aPaperSize.Height() -= nTop + lcl_LineTotal( rParam.pBorder->GetBottom() ) + rParam.pBorder->GetDistance(BOX_LINE_BOTTOM);
1719 : }
1720 :
1721 0 : if ( rParam.pShadow && rParam.pShadow->GetLocation() != SVX_SHADOW_NONE )
1722 : {
1723 0 : long nLeft = rParam.pShadow->CalcShadowSpace(SHADOW_LEFT);
1724 0 : long nTop = rParam.pShadow->CalcShadowSpace(SHADOW_TOP);
1725 0 : aStart.X() += nLeft;
1726 0 : aStart.Y() += nTop;
1727 0 : aPaperSize.Width() -= nLeft + rParam.pShadow->CalcShadowSpace(SHADOW_RIGHT);
1728 0 : aPaperSize.Height() -= nTop + rParam.pShadow->CalcShadowSpace(SHADOW_BOTTOM);
1729 : }
1730 :
1731 0 : aFieldData.nPageNo = nPageNo+aTableParam.nFirstPageNo;
1732 0 : MakeEditEngine();
1733 :
1734 0 : pEditEngine->SetPaperSize(aPaperSize);
1735 : const EditTextObject* pObject;
1736 :
1737 : // Rahmen / Hintergrund
1738 :
1739 0 : Point aBorderStart( nLineStartX, nStartY );
1740 0 : Size aBorderSize( nLineWidth, rParam.nHeight-rParam.nDistance );
1741 0 : if ( rParam.bDynamic )
1742 : {
1743 : // hier nochmal anpassen, wegen geraden/ungeraden Kopf/Fusszeilen
1744 : // und evtl. anderen Umbruechen durch Variablen (Seitennummer etc.)
1745 :
1746 0 : long nMaxHeight = 0;
1747 0 : nMaxHeight = Max( nMaxHeight, TextHeight( pHFItem->GetLeftArea() ) );
1748 0 : nMaxHeight = Max( nMaxHeight, TextHeight( pHFItem->GetCenterArea() ) );
1749 0 : nMaxHeight = Max( nMaxHeight, TextHeight( pHFItem->GetRightArea() ) );
1750 0 : if (rParam.pBorder)
1751 0 : nMaxHeight += lcl_LineTotal( rParam.pBorder->GetTop() ) +
1752 0 : lcl_LineTotal( rParam.pBorder->GetBottom() ) +
1753 0 : rParam.pBorder->GetDistance(BOX_LINE_TOP) +
1754 0 : rParam.pBorder->GetDistance(BOX_LINE_BOTTOM);
1755 0 : if (rParam.pShadow && rParam.pShadow->GetLocation() != SVX_SHADOW_NONE)
1756 0 : nMaxHeight += rParam.pShadow->CalcShadowSpace(SHADOW_TOP) +
1757 0 : rParam.pShadow->CalcShadowSpace(SHADOW_BOTTOM);
1758 :
1759 0 : if (nMaxHeight < rParam.nManHeight-rParam.nDistance)
1760 0 : nMaxHeight = rParam.nManHeight-rParam.nDistance; // eingestelltes Minimum
1761 :
1762 0 : aBorderSize.Height() = nMaxHeight;
1763 : }
1764 :
1765 0 : if ( bDoPrint )
1766 : {
1767 0 : double nOldScaleX = nScaleX;
1768 0 : double nOldScaleY = nScaleY;
1769 0 : nScaleX = nScaleY = 1.0; // direkt in Twips ausgeben
1770 0 : DrawBorder( aBorderStart.X(), aBorderStart.Y(), aBorderSize.Width(), aBorderSize.Height(),
1771 0 : rParam.pBorder, rParam.pBack, rParam.pShadow );
1772 0 : nScaleX = nOldScaleX;
1773 0 : nScaleY = nOldScaleY;
1774 :
1775 : // Clipping fuer Text
1776 :
1777 0 : pDev->SetClipRegion( Rectangle( aStart, aPaperSize ) );
1778 :
1779 : // links
1780 :
1781 0 : pObject = pHFItem->GetLeftArea();
1782 0 : if (pObject)
1783 : {
1784 0 : pEditDefaults->Put( SvxAdjustItem( SVX_ADJUST_LEFT, EE_PARA_JUST ) );
1785 0 : pEditEngine->SetTextNewDefaults( *pObject, *pEditDefaults, false );
1786 0 : Point aDraw = aStart;
1787 0 : long nDif = aPaperSize.Height() - (long) pEditEngine->GetTextHeight();
1788 0 : if (nDif > 0)
1789 0 : aDraw.Y() += nDif / 2;
1790 0 : pEditEngine->Draw( pDev, aDraw, 0 );
1791 : }
1792 :
1793 : // Mitte
1794 :
1795 0 : pObject = pHFItem->GetCenterArea();
1796 0 : if (pObject)
1797 : {
1798 0 : pEditDefaults->Put( SvxAdjustItem( SVX_ADJUST_CENTER, EE_PARA_JUST ) );
1799 0 : pEditEngine->SetTextNewDefaults( *pObject, *pEditDefaults, false );
1800 0 : Point aDraw = aStart;
1801 0 : long nDif = aPaperSize.Height() - (long) pEditEngine->GetTextHeight();
1802 0 : if (nDif > 0)
1803 0 : aDraw.Y() += nDif / 2;
1804 0 : pEditEngine->Draw( pDev, aDraw, 0 );
1805 : }
1806 :
1807 : // rechts
1808 :
1809 0 : pObject = pHFItem->GetRightArea();
1810 0 : if (pObject)
1811 : {
1812 0 : pEditDefaults->Put( SvxAdjustItem( SVX_ADJUST_RIGHT, EE_PARA_JUST ) );
1813 0 : pEditEngine->SetTextNewDefaults( *pObject, *pEditDefaults, false );
1814 0 : Point aDraw = aStart;
1815 0 : long nDif = aPaperSize.Height() - (long) pEditEngine->GetTextHeight();
1816 0 : if (nDif > 0)
1817 0 : aDraw.Y() += nDif / 2;
1818 0 : pEditEngine->Draw( pDev, aDraw, 0 );
1819 : }
1820 :
1821 0 : pDev->SetClipRegion();
1822 : }
1823 :
1824 0 : if ( pLocationData )
1825 : {
1826 0 : Rectangle aHeaderRect( aBorderStart, aBorderSize );
1827 0 : pLocationData->AddHeaderFooter( aHeaderRect, bHeader, bLeft );
1828 : }
1829 0 : }
1830 :
1831 0 : long ScPrintFunc::DoNotes( long nNoteStart, sal_Bool bDoPrint, ScPreviewLocationData* pLocationData )
1832 : {
1833 0 : if (bDoPrint)
1834 0 : pDev->SetMapMode(aTwipMode);
1835 :
1836 0 : MakeEditEngine();
1837 0 : pEditDefaults->Put( SvxAdjustItem( SVX_ADJUST_LEFT, EE_PARA_JUST ) );
1838 0 : pEditEngine->SetDefaults( *pEditDefaults );
1839 :
1840 0 : Font aMarkFont;
1841 0 : ScAutoFontColorMode eColorMode = bUseStyleColor ? SC_AUTOCOL_DISPLAY : SC_AUTOCOL_PRINT;
1842 0 : ((const ScPatternAttr&)pDoc->GetPool()->GetDefaultItem(ATTR_PATTERN)).GetFont( aMarkFont, eColorMode );
1843 0 : pDev->SetFont( aMarkFont );
1844 0 : long nMarkLen = pDev->GetTextWidth(rtl::OUString("GW99999:"));
1845 : // ohne Space, weil's eh selten so weit kommt
1846 :
1847 0 : Size aDataSize = aPageRect.GetSize();
1848 0 : if ( nMarkLen > aDataSize.Width() / 2 ) // alles viel zu klein?
1849 0 : nMarkLen = aDataSize.Width() / 2; // Seite bruederlich aufteilen
1850 0 : aDataSize.Width() -= nMarkLen;
1851 :
1852 0 : pEditEngine->SetPaperSize( aDataSize );
1853 0 : long nPosX = aPageRect.Left() + nMarkLen;
1854 0 : long nPosY = aPageRect.Top();
1855 :
1856 0 : long nCount = 0;
1857 0 : long nSize = aNotePosList.size();
1858 : sal_Bool bOk;
1859 0 : do
1860 : {
1861 0 : bOk = false;
1862 0 : if ( nNoteStart + nCount < nSize)
1863 : {
1864 0 : ScAddress &rPos = aNotePosList[ nNoteStart + nCount ];
1865 :
1866 0 : if( const ScPostIt* pNote = pDoc->GetNotes(rPos.Tab())->findByAddress( rPos ) )
1867 : {
1868 0 : if(const EditTextObject *pEditText = pNote->GetEditTextObject())
1869 0 : pEditEngine->SetText(*pEditText);
1870 0 : long nTextHeight = pEditEngine->GetTextHeight();
1871 0 : if ( nPosY + nTextHeight < aPageRect.Bottom() )
1872 : {
1873 0 : if (bDoPrint)
1874 : {
1875 0 : pEditEngine->Draw( pDev, Point( nPosX, nPosY ), 0 );
1876 :
1877 0 : String aMarkStr;
1878 0 : rPos.Format( aMarkStr, SCA_VALID, pDoc, pDoc->GetAddressConvention() );
1879 0 : aMarkStr += ':';
1880 :
1881 : // Zellposition auch per EditEngine, damit die Position stimmt
1882 0 : pEditEngine->SetText(aMarkStr);
1883 0 : pEditEngine->Draw( pDev, Point( aPageRect.Left(), nPosY ), 0 );
1884 : }
1885 :
1886 0 : if ( pLocationData )
1887 : {
1888 0 : Rectangle aTextRect( Point( nPosX, nPosY ), Size( aDataSize.Width(), nTextHeight ) );
1889 0 : pLocationData->AddNoteText( aTextRect, rPos );
1890 0 : Rectangle aMarkRect( Point( aPageRect.Left(), nPosY ), Size( nMarkLen, nTextHeight ) );
1891 0 : pLocationData->AddNoteMark( aMarkRect, rPos );
1892 : }
1893 :
1894 0 : nPosY += nTextHeight;
1895 0 : nPosY += 200; // Abstand
1896 0 : ++nCount;
1897 0 : bOk = sal_True;
1898 : }
1899 : }
1900 : }
1901 : }
1902 : while (bOk);
1903 :
1904 0 : return nCount;
1905 : }
1906 :
1907 0 : long ScPrintFunc::PrintNotes( long nPageNo, long nNoteStart, sal_Bool bDoPrint, ScPreviewLocationData* pLocationData )
1908 : {
1909 0 : if ( nNoteStart >= (long) aNotePosList.size() || !aTableParam.bNotes )
1910 0 : return 0;
1911 :
1912 0 : if ( bDoPrint && bClearWin )
1913 : {
1914 : //! mit PrintPage zusammenfassen !!!
1915 :
1916 0 : Color aBackgroundColor( COL_WHITE );
1917 0 : if ( bUseStyleColor )
1918 0 : aBackgroundColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor );
1919 :
1920 0 : pDev->SetMapMode(aOffsetMode);
1921 0 : pDev->SetLineColor();
1922 0 : pDev->SetFillColor(aBackgroundColor);
1923 : pDev->DrawRect(Rectangle(Point(),
1924 0 : Size((long)(aPageSize.Width() * nScaleX * 100 / nZoom),
1925 0 : (long)(aPageSize.Height() * nScaleY * 100 / nZoom))));
1926 : }
1927 :
1928 :
1929 : // aPageRect auf linke / rechte Seiten anpassen
1930 :
1931 0 : Rectangle aTempRect = Rectangle( Point(), aPageSize );
1932 0 : if (IsMirror(nPageNo))
1933 : {
1934 0 : aPageRect.Left() = ( aTempRect.Left() + nRightMargin ) * 100 / nZoom;
1935 0 : aPageRect.Right() = ( aTempRect.Right() - nLeftMargin ) * 100 / nZoom;
1936 : }
1937 : else
1938 : {
1939 0 : aPageRect.Left() = ( aTempRect.Left() + nLeftMargin ) * 100 / nZoom;
1940 0 : aPageRect.Right() = ( aTempRect.Right() - nRightMargin ) * 100 / nZoom;
1941 : }
1942 :
1943 0 : if ( pPrinter && bDoPrint )
1944 : {
1945 : OSL_FAIL( "StartPage does not exist anymore" );
1946 : }
1947 :
1948 0 : if ( bDoPrint || pLocationData )
1949 : {
1950 : // Kopf- und Fusszeilen
1951 :
1952 0 : if (aHdr.bEnable)
1953 : {
1954 0 : long nHeaderY = aPageRect.Top()-aHdr.nHeight;
1955 0 : PrintHF( nPageNo, sal_True, nHeaderY, bDoPrint, pLocationData );
1956 : }
1957 0 : if (aFtr.bEnable)
1958 : {
1959 0 : long nFooterY = aPageRect.Bottom()+aFtr.nDistance;
1960 0 : PrintHF( nPageNo, false, nFooterY, bDoPrint, pLocationData );
1961 : }
1962 : }
1963 :
1964 0 : long nCount = DoNotes( nNoteStart, bDoPrint, pLocationData );
1965 :
1966 0 : if ( pPrinter && bDoPrint )
1967 : {
1968 : OSL_FAIL( "EndPage does not exist anymore" );
1969 : }
1970 :
1971 0 : return nCount;
1972 : }
1973 :
1974 0 : void ScPrintFunc::PrintPage( long nPageNo, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2,
1975 : sal_Bool bDoPrint, ScPreviewLocationData* pLocationData )
1976 : {
1977 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nPrintTab );
1978 0 : long nLayoutSign = bLayoutRTL ? -1 : 1;
1979 :
1980 : // nPageNo is the page number within all sheets of one "start page" setting
1981 :
1982 0 : if ( bClearWin && bDoPrint )
1983 : {
1984 : // muss genau zum Zeichnen des Rahmens in preview.cxx passen !!!
1985 :
1986 0 : Color aBackgroundColor( COL_WHITE );
1987 0 : if ( bUseStyleColor )
1988 0 : aBackgroundColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor );
1989 :
1990 0 : pDev->SetMapMode(aOffsetMode);
1991 0 : pDev->SetLineColor();
1992 0 : pDev->SetFillColor(aBackgroundColor);
1993 : pDev->DrawRect(Rectangle(Point(),
1994 0 : Size((long)(aPageSize.Width() * nScaleX * 100 / nZoom),
1995 0 : (long)(aPageSize.Height() * nScaleY * 100 / nZoom))));
1996 : }
1997 :
1998 :
1999 : // aPageRect auf linke / rechte Seiten anpassen
2000 :
2001 0 : Rectangle aTempRect = Rectangle( Point(), aPageSize );
2002 0 : if (IsMirror(nPageNo))
2003 : {
2004 0 : aPageRect.Left() = ( aTempRect.Left() + nRightMargin ) * 100 / nZoom;
2005 0 : aPageRect.Right() = ( aTempRect.Right() - nLeftMargin ) * 100 / nZoom;
2006 : }
2007 : else
2008 : {
2009 0 : aPageRect.Left() = ( aTempRect.Left() + nLeftMargin ) * 100 / nZoom;
2010 0 : aPageRect.Right() = ( aTempRect.Right() - nRightMargin ) * 100 / nZoom;
2011 : }
2012 :
2013 0 : if ( aAreaParam.bRepeatCol )
2014 0 : if ( nX1 > nRepeatStartCol && nX1 <= nRepeatEndCol )
2015 0 : nX1 = nRepeatEndCol + 1;
2016 0 : sal_Bool bDoRepCol = (aAreaParam.bRepeatCol && nX1 > nRepeatEndCol);
2017 0 : if ( aAreaParam.bRepeatRow )
2018 0 : if ( nY1 > nRepeatStartRow && nY1 <= nRepeatEndRow )
2019 0 : nY1 = nRepeatEndRow + 1;
2020 0 : sal_Bool bDoRepRow = (aAreaParam.bRepeatRow && nY1 > nRepeatEndRow);
2021 :
2022 : // use new object hide flags in SdrPaintView
2023 0 : if(pDrawView)
2024 : {
2025 0 : pDrawView->setHideOle(!aTableParam.bObjects);
2026 0 : pDrawView->setHideChart(!aTableParam.bCharts);
2027 0 : pDrawView->setHideDraw(!aTableParam.bDrawings);
2028 0 : pDrawView->setHideFormControl(!aTableParam.bDrawings);
2029 : }
2030 :
2031 0 : if ( pPrinter && bDoPrint )
2032 : {
2033 : OSL_FAIL( "StartPage does not exist anymore" );
2034 : }
2035 :
2036 : // Kopf- und Fusszeilen (ohne Zentrierung)
2037 :
2038 0 : if (aHdr.bEnable)
2039 : {
2040 0 : long nHeaderY = aPageRect.Top()-aHdr.nHeight;
2041 0 : PrintHF( nPageNo, sal_True, nHeaderY, bDoPrint, pLocationData );
2042 : }
2043 0 : if (aFtr.bEnable)
2044 : {
2045 0 : long nFooterY = aPageRect.Bottom()+aFtr.nDistance;
2046 0 : PrintHF( nPageNo, false, nFooterY, bDoPrint, pLocationData );
2047 : }
2048 :
2049 : // Position ( Raender / zentrieren )
2050 :
2051 0 : long nLeftSpace = aPageRect.Left(); // Document-Twips
2052 0 : long nTopSpace = aPageRect.Top();
2053 0 : if ( bCenterHor || bLayoutRTL )
2054 : {
2055 0 : long nDataWidth = 0;
2056 : SCCOL i;
2057 0 : for (i=nX1; i<=nX2; i++)
2058 0 : nDataWidth += pDoc->GetColWidth( i,nPrintTab );
2059 0 : if (bDoRepCol)
2060 0 : for (i=nRepeatStartCol; i<=nRepeatEndCol; i++)
2061 0 : nDataWidth += pDoc->GetColWidth( i,nPrintTab );
2062 0 : if (aTableParam.bHeaders)
2063 0 : nDataWidth += (long) PRINT_HEADER_WIDTH;
2064 0 : if (pBorderItem)
2065 0 : nDataWidth += pBorderItem->GetDistance(BOX_LINE_LEFT) +
2066 0 : pBorderItem->GetDistance(BOX_LINE_RIGHT); //! Line width?
2067 0 : if (pShadowItem && pShadowItem->GetLocation() != SVX_SHADOW_NONE)
2068 0 : nDataWidth += pShadowItem->CalcShadowSpace(SHADOW_LEFT) +
2069 0 : pShadowItem->CalcShadowSpace(SHADOW_RIGHT);
2070 0 : if ( bCenterHor )
2071 : {
2072 0 : nLeftSpace += ( aPageRect.GetWidth() - nDataWidth ) / 2; // LTR or RTL
2073 0 : if (pBorderItem)
2074 0 : nLeftSpace -= lcl_LineTotal(pBorderItem->GetLeft());
2075 : }
2076 0 : else if ( bLayoutRTL )
2077 0 : nLeftSpace += aPageRect.GetWidth() - nDataWidth; // align to the right edge of the page
2078 : }
2079 0 : if ( bCenterVer )
2080 : {
2081 0 : long nDataHeight = pDoc->GetRowHeight( nY1, nY2, nPrintTab);
2082 0 : if (bDoRepRow)
2083 : nDataHeight += pDoc->GetRowHeight( nRepeatStartRow,
2084 0 : nRepeatEndRow, nPrintTab);
2085 0 : if (aTableParam.bHeaders)
2086 0 : nDataHeight += (long) PRINT_HEADER_HEIGHT;
2087 0 : if (pBorderItem)
2088 0 : nDataHeight += pBorderItem->GetDistance(BOX_LINE_TOP) +
2089 0 : pBorderItem->GetDistance(BOX_LINE_BOTTOM); //! Line width?
2090 0 : if (pShadowItem && pShadowItem->GetLocation() != SVX_SHADOW_NONE)
2091 0 : nDataHeight += pShadowItem->CalcShadowSpace(SHADOW_TOP) +
2092 0 : pShadowItem->CalcShadowSpace(SHADOW_BOTTOM);
2093 0 : nTopSpace += ( aPageRect.GetHeight() - nDataHeight ) / 2;
2094 0 : if (pBorderItem)
2095 0 : nTopSpace -= lcl_LineTotal(pBorderItem->GetTop());
2096 : }
2097 :
2098 : // calculate sizes of the elements for partitioning
2099 : // (header, repeat, data)
2100 :
2101 0 : long nHeaderWidth = 0;
2102 0 : long nHeaderHeight = 0;
2103 0 : long nRepeatWidth = 0;
2104 0 : long nRepeatHeight = 0;
2105 0 : long nContentWidth = 0; // scaled - not the same as nDataWidth above
2106 0 : long nContentHeight = 0;
2107 0 : if (aTableParam.bHeaders)
2108 : {
2109 0 : nHeaderWidth = (long) (PRINT_HEADER_WIDTH * nScaleX);
2110 0 : nHeaderHeight = (long) (PRINT_HEADER_HEIGHT * nScaleY);
2111 : }
2112 0 : if (bDoRepCol)
2113 0 : for (SCCOL i=nRepeatStartCol; i<=nRepeatEndCol; i++)
2114 0 : nRepeatWidth += (long) (pDoc->GetColWidth(i,nPrintTab) * nScaleX);
2115 0 : if (bDoRepRow)
2116 : nRepeatHeight += pDoc->GetScaledRowHeight( nRepeatStartRow,
2117 0 : nRepeatEndRow, nPrintTab, nScaleY);
2118 0 : for (SCCOL i=nX1; i<=nX2; i++)
2119 0 : nContentWidth += (long) (pDoc->GetColWidth(i,nPrintTab) * nScaleX);
2120 : nContentHeight += pDoc->GetScaledRowHeight( nY1, nY2, nPrintTab,
2121 0 : nScaleY);
2122 :
2123 : // partition the page
2124 :
2125 0 : long nStartX = ((long) ( nLeftSpace * nScaleX ));
2126 0 : long nStartY = ((long) ( nTopSpace * nScaleY ));
2127 0 : long nInnerStartX = nStartX;
2128 0 : long nInnerStartY = nStartY;
2129 0 : if (pBorderItem)
2130 : {
2131 0 : nInnerStartX += (long) ( ( lcl_LineTotal(pBorderItem->GetLeft()) +
2132 0 : pBorderItem->GetDistance(BOX_LINE_LEFT) ) * nScaleX );
2133 0 : nInnerStartY += (long) ( ( lcl_LineTotal(pBorderItem->GetTop()) +
2134 0 : pBorderItem->GetDistance(BOX_LINE_TOP) ) * nScaleY );
2135 : }
2136 0 : if (pShadowItem && pShadowItem->GetLocation() != SVX_SHADOW_NONE)
2137 : {
2138 0 : nInnerStartX += (long) ( pShadowItem->CalcShadowSpace(SHADOW_LEFT) * nScaleX );
2139 0 : nInnerStartY += (long) ( pShadowItem->CalcShadowSpace(SHADOW_TOP) * nScaleY );
2140 : }
2141 :
2142 0 : if ( bLayoutRTL )
2143 : {
2144 : // arrange elements starting from the right edge
2145 0 : nInnerStartX += nHeaderWidth + nRepeatWidth + nContentWidth;
2146 :
2147 : // make rounding easier so the elements are really next to each other in preview
2148 0 : Size aOffsetOnePixel = pDev->PixelToLogic( Size(1,1), aOffsetMode );
2149 0 : long nOffsetOneX = aOffsetOnePixel.Width();
2150 0 : nInnerStartX += nOffsetOneX / 2;
2151 : }
2152 :
2153 0 : long nFrameStartX = nInnerStartX;
2154 0 : long nFrameStartY = nInnerStartY;
2155 :
2156 0 : long nRepStartX = nInnerStartX + nHeaderWidth * nLayoutSign; // widths/heights are 0 if not used
2157 0 : long nRepStartY = nInnerStartY + nHeaderHeight;
2158 0 : long nDataX = nRepStartX + nRepeatWidth * nLayoutSign;
2159 0 : long nDataY = nRepStartY + nRepeatHeight;
2160 0 : long nEndX = nDataX + nContentWidth * nLayoutSign;
2161 0 : long nEndY = nDataY + nContentHeight;
2162 0 : long nFrameEndX = nEndX;
2163 0 : long nFrameEndY = nEndY;
2164 :
2165 0 : if ( bLayoutRTL )
2166 : {
2167 : // each element's start position is its left edge
2168 : //! subtract one pixel less?
2169 0 : nInnerStartX -= nHeaderWidth; // used for header
2170 0 : nRepStartX -= nRepeatWidth;
2171 0 : nDataX -= nContentWidth;
2172 :
2173 : // continue right of the main elements again
2174 0 : nEndX += nHeaderWidth + nRepeatWidth + nContentWidth;
2175 : }
2176 :
2177 : // Seiten-Rahmen / Hintergrund
2178 :
2179 : //! nEndX/Y anpassen
2180 :
2181 0 : long nBorderEndX = nEndX;
2182 0 : long nBorderEndY = nEndY;
2183 0 : if (pBorderItem)
2184 : {
2185 0 : nBorderEndX += (long) ( ( lcl_LineTotal(pBorderItem->GetRight()) +
2186 0 : pBorderItem->GetDistance(BOX_LINE_RIGHT) ) * nScaleX );
2187 0 : nBorderEndY += (long) ( ( lcl_LineTotal(pBorderItem->GetBottom()) +
2188 0 : pBorderItem->GetDistance(BOX_LINE_BOTTOM) ) * nScaleY );
2189 : }
2190 0 : if (pShadowItem && pShadowItem->GetLocation() != SVX_SHADOW_NONE)
2191 : {
2192 0 : nBorderEndX += (long) ( pShadowItem->CalcShadowSpace(SHADOW_RIGHT) * nScaleX );
2193 0 : nBorderEndY += (long) ( pShadowItem->CalcShadowSpace(SHADOW_BOTTOM) * nScaleY );
2194 : }
2195 :
2196 0 : if ( bDoPrint )
2197 : {
2198 0 : pDev->SetMapMode( aOffsetMode );
2199 : DrawBorder( nStartX, nStartY, nBorderEndX-nStartX, nBorderEndY-nStartY,
2200 0 : pBorderItem, pBackgroundItem, pShadowItem );
2201 :
2202 0 : pDev->SetMapMode( aTwipMode );
2203 : }
2204 :
2205 0 : pDev->SetMapMode( aOffsetMode );
2206 :
2207 : // Wiederholungszeilen/Spalten ausgeben
2208 :
2209 0 : if (bDoRepCol && bDoRepRow)
2210 : {
2211 0 : if ( bDoPrint )
2212 : PrintArea( nRepeatStartCol,nRepeatStartRow, nRepeatEndCol,nRepeatEndRow,
2213 0 : nRepStartX,nRepStartY, sal_True,sal_True,false,false );
2214 0 : if ( pLocationData )
2215 : LocateArea( nRepeatStartCol,nRepeatStartRow, nRepeatEndCol,nRepeatEndRow,
2216 0 : nRepStartX,nRepStartY, sal_True,sal_True, *pLocationData );
2217 : }
2218 0 : if (bDoRepCol)
2219 : {
2220 0 : if ( bDoPrint )
2221 : PrintArea( nRepeatStartCol,nY1, nRepeatEndCol,nY2, nRepStartX,nDataY,
2222 0 : sal_True,!bDoRepRow,false,sal_True );
2223 0 : if ( pLocationData )
2224 0 : LocateArea( nRepeatStartCol,nY1, nRepeatEndCol,nY2, nRepStartX,nDataY, sal_True,false, *pLocationData );
2225 : }
2226 0 : if (bDoRepRow)
2227 : {
2228 0 : if ( bDoPrint )
2229 : PrintArea( nX1,nRepeatStartRow, nX2,nRepeatEndRow, nDataX,nRepStartY,
2230 0 : !bDoRepCol,sal_True,sal_True,false );
2231 0 : if ( pLocationData )
2232 0 : LocateArea( nX1,nRepeatStartRow, nX2,nRepeatEndRow, nDataX,nRepStartY, false,sal_True, *pLocationData );
2233 : }
2234 :
2235 : // Daten ausgeben
2236 :
2237 0 : if ( bDoPrint )
2238 0 : PrintArea( nX1,nY1, nX2,nY2, nDataX,nDataY, !bDoRepCol,!bDoRepRow,sal_True,sal_True );
2239 0 : if ( pLocationData )
2240 0 : LocateArea( nX1,nY1, nX2,nY2, nDataX,nDataY, false,false, *pLocationData );
2241 :
2242 : // Spalten-/Zeilenkoepfe ausgeben
2243 : // nach den Daten (ueber evtl. weitergezeichneten Schatten)
2244 :
2245 0 : Color aGridColor( COL_BLACK );
2246 0 : if ( bUseStyleColor )
2247 0 : aGridColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor );
2248 :
2249 0 : if (aTableParam.bHeaders)
2250 : {
2251 0 : if ( bDoPrint )
2252 : {
2253 0 : pDev->SetLineColor( aGridColor );
2254 0 : pDev->SetFillColor();
2255 0 : pDev->SetMapMode(aOffsetMode);
2256 : }
2257 :
2258 0 : ScPatternAttr aPattern( pDoc->GetPool() );
2259 0 : Font aFont;
2260 0 : ScAutoFontColorMode eColorMode = bUseStyleColor ? SC_AUTOCOL_DISPLAY : SC_AUTOCOL_PRINT;
2261 0 : aPattern.GetFont( aFont, eColorMode, pDev );
2262 0 : pDev->SetFont( aFont );
2263 :
2264 0 : if (bDoRepCol)
2265 : {
2266 0 : if ( bDoPrint )
2267 0 : PrintColHdr( nRepeatStartCol,nRepeatEndCol, nRepStartX,nInnerStartY );
2268 0 : if ( pLocationData )
2269 0 : LocateColHdr( nRepeatStartCol,nRepeatEndCol, nRepStartX,nInnerStartY, sal_True, *pLocationData );
2270 : }
2271 0 : if ( bDoPrint )
2272 0 : PrintColHdr( nX1,nX2, nDataX,nInnerStartY );
2273 0 : if ( pLocationData )
2274 0 : LocateColHdr( nX1,nX2, nDataX,nInnerStartY, false, *pLocationData );
2275 0 : if (bDoRepRow)
2276 : {
2277 0 : if ( bDoPrint )
2278 0 : PrintRowHdr( nRepeatStartRow,nRepeatEndRow, nInnerStartX,nRepStartY );
2279 0 : if ( pLocationData )
2280 0 : LocateRowHdr( nRepeatStartRow,nRepeatEndRow, nInnerStartX,nRepStartY, sal_True, *pLocationData );
2281 : }
2282 0 : if ( bDoPrint )
2283 0 : PrintRowHdr( nY1,nY2, nInnerStartX,nDataY );
2284 0 : if ( pLocationData )
2285 0 : LocateRowHdr( nY1,nY2, nInnerStartX,nDataY, false, *pLocationData );
2286 : }
2287 :
2288 : // einfacher Rahmen
2289 :
2290 0 : if ( bDoPrint && ( aTableParam.bGrid || aTableParam.bHeaders ) )
2291 : {
2292 0 : Size aOnePixel = pDev->PixelToLogic(Size(1,1));
2293 0 : long nOneX = aOnePixel.Width();
2294 0 : long nOneY = aOnePixel.Height();
2295 :
2296 0 : long nLeftX = nFrameStartX;
2297 0 : long nTopY = nFrameStartY - nOneY;
2298 0 : long nRightX = nFrameEndX;
2299 0 : long nBottomY = nFrameEndY - nOneY;
2300 0 : if ( !bLayoutRTL )
2301 : {
2302 0 : nLeftX -= nOneX;
2303 0 : nRightX -= nOneX;
2304 : }
2305 0 : pDev->SetMapMode(aOffsetMode);
2306 0 : pDev->SetLineColor( aGridColor );
2307 0 : pDev->SetFillColor();
2308 0 : pDev->DrawRect( Rectangle( nLeftX, nTopY, nRightX, nBottomY ) );
2309 : // nEndX/Y ohne Rahmen-Anpassung
2310 : }
2311 :
2312 0 : if ( pPrinter && bDoPrint )
2313 : {
2314 : OSL_FAIL( "EndPage does not exist anymore" );
2315 : }
2316 :
2317 0 : aLastSourceRange = ScRange( nX1, nY1, nPrintTab, nX2, nY2, nPrintTab );
2318 0 : bSourceRangeValid = sal_True;
2319 0 : }
2320 :
2321 0 : void ScPrintFunc::SetOffset( const Point& rOfs )
2322 : {
2323 0 : aSrcOffset = rOfs;
2324 0 : }
2325 :
2326 0 : void ScPrintFunc::SetManualZoom( sal_uInt16 nNewZoom )
2327 : {
2328 0 : nManualZoom = nNewZoom;
2329 0 : }
2330 :
2331 0 : void ScPrintFunc::SetClearFlag( sal_Bool bFlag )
2332 : {
2333 0 : bClearWin = bFlag;
2334 0 : }
2335 :
2336 0 : void ScPrintFunc::SetUseStyleColor( sal_Bool bFlag )
2337 : {
2338 0 : bUseStyleColor = bFlag;
2339 0 : if (pEditEngine)
2340 0 : pEditEngine->EnableAutoColor( bUseStyleColor );
2341 0 : }
2342 :
2343 0 : void ScPrintFunc::SetRenderFlag( sal_Bool bFlag )
2344 : {
2345 0 : bIsRender = bFlag; // set when using XRenderable (PDF)
2346 0 : }
2347 :
2348 0 : void ScPrintFunc::SetExclusivelyDrawOleAndDrawObjects()
2349 : {
2350 0 : aTableParam.bCellContent = false;
2351 0 : aTableParam.bNotes = false;
2352 0 : aTableParam.bGrid = false;
2353 0 : aTableParam.bHeaders = false;
2354 0 : aTableParam.bFormulas = false;
2355 0 : aTableParam.bNullVals = false;
2356 0 : }
2357 :
2358 : //
2359 : // UpdatePages wird nur von aussen gerufen, um die Umbrueche fuer die Anzeige
2360 : // richtig zu setzen - immer ohne UserArea
2361 : //
2362 :
2363 69 : sal_Bool ScPrintFunc::UpdatePages()
2364 : {
2365 69 : if (!pParamSet)
2366 0 : return false;
2367 :
2368 : // Zoom
2369 :
2370 69 : nZoom = 100;
2371 69 : if (aTableParam.bScalePageNum || aTableParam.bScaleTo)
2372 0 : nZoom = ZOOM_MIN; // stimmt fuer Umbrueche
2373 69 : else if (aTableParam.bScaleAll)
2374 : {
2375 69 : nZoom = aTableParam.nScaleAll;
2376 69 : if ( nZoom <= ZOOM_MIN )
2377 0 : nZoom = ZOOM_MIN;
2378 : }
2379 :
2380 69 : rtl::OUString aName = pDoc->GetPageStyle( nPrintTab );
2381 69 : SCTAB nTabCount = pDoc->GetTableCount();
2382 180 : for (SCTAB nTab=0; nTab<nTabCount; nTab++)
2383 111 : if ( nTab==nPrintTab || pDoc->GetPageStyle(nTab)==aName )
2384 : {
2385 : // Wiederholungszeilen / Spalten
2386 69 : pDoc->SetRepeatArea( nTab, nRepeatStartCol,nRepeatEndCol, nRepeatStartRow,nRepeatEndRow );
2387 :
2388 : // Umbrueche setzen
2389 69 : ResetBreaks(nTab);
2390 69 : pDocShell->PostPaint(0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID);
2391 : }
2392 :
2393 69 : return sal_True;
2394 : }
2395 :
2396 69 : long ScPrintFunc::CountPages() // setzt auch nPagesX, nPagesY
2397 : {
2398 69 : sal_Bool bAreaOk = false;
2399 :
2400 69 : if (pDoc->HasTable( nPrintTab ))
2401 : {
2402 69 : if (aAreaParam.bPrintArea) // Druckbereich angegeben?
2403 : {
2404 0 : if ( bPrintCurrentTable )
2405 : {
2406 0 : ScRange& rRange = aAreaParam.aPrintArea;
2407 :
2408 : // hier kein Vergleich der Tabellen mehr, die Area gilt immer fuer diese Tabelle
2409 : // wenn hier verglichen werden soll, muss die Tabelle der Druckbereiche beim
2410 : // Einfuegen von Tabellen etc. angepasst werden !
2411 :
2412 0 : nStartCol = rRange.aStart.Col();
2413 0 : nStartRow = rRange.aStart.Row();
2414 0 : nEndCol = rRange.aEnd .Col();
2415 0 : nEndRow = rRange.aEnd .Row();
2416 0 : bAreaOk = AdjustPrintArea(false); // begrenzen
2417 : }
2418 : else
2419 0 : bAreaOk = false;
2420 : }
2421 : else // aus Dokument suchen
2422 69 : bAreaOk = AdjustPrintArea(sal_True);
2423 : }
2424 :
2425 69 : if (bAreaOk)
2426 : {
2427 17 : long nPages = 0;
2428 : size_t nY;
2429 17 : if (bMultiArea)
2430 : {
2431 0 : sal_uInt16 nRCount = pDoc->GetPrintRangeCount( nPrintTab );
2432 0 : for (sal_uInt16 i=0; i<nRCount; i++)
2433 : {
2434 0 : CalcZoom(i);
2435 0 : if ( aTableParam.bSkipEmpty )
2436 0 : for (nY=0; nY<nPagesY; nY++)
2437 0 : nPages += pPageRows[nY].CountVisible();
2438 : else
2439 0 : nPages += ((long) nPagesX) * nPagesY;
2440 0 : if ( pPageData )
2441 0 : FillPageData();
2442 : }
2443 : }
2444 : else
2445 : {
2446 17 : CalcZoom(RANGENO_NORANGE); // Zoom berechnen
2447 17 : if ( aTableParam.bSkipEmpty )
2448 0 : for (nY=0; nY<nPagesY; nY++)
2449 0 : nPages += pPageRows[nY].CountVisible();
2450 : else
2451 17 : nPages += ((long) nPagesX) * nPagesY;
2452 17 : if ( pPageData )
2453 0 : FillPageData();
2454 : }
2455 17 : return nPages;
2456 : }
2457 : else
2458 : {
2459 52 : nPagesX = nPagesY = nTotalY = 0;
2460 52 : return 0;
2461 : }
2462 : }
2463 :
2464 69 : long ScPrintFunc::CountNotePages()
2465 : {
2466 69 : if ( !aTableParam.bNotes || !bPrintCurrentTable )
2467 69 : return 0;
2468 :
2469 0 : long nCount=0;
2470 :
2471 0 : sal_Bool bError = false;
2472 0 : if (!aAreaParam.bPrintArea)
2473 0 : bError = !AdjustPrintArea(sal_True); // komplett aus Dok suchen
2474 :
2475 0 : sal_uInt16 nRepeats = 1; // wie oft durchgehen ?
2476 0 : if (bMultiArea)
2477 0 : nRepeats = pDoc->GetPrintRangeCount(nPrintTab);
2478 0 : if (bError)
2479 0 : nRepeats = 0;
2480 :
2481 0 : for (sal_uInt16 nStep=0; nStep<nRepeats; nStep++)
2482 : {
2483 0 : sal_Bool bDoThis = sal_True;
2484 0 : if (bMultiArea) // alle Areas durchgehen
2485 : {
2486 0 : const ScRange* pThisRange = pDoc->GetPrintRange( nPrintTab, nStep );
2487 0 : if ( pThisRange )
2488 : {
2489 0 : nStartCol = pThisRange->aStart.Col();
2490 0 : nStartRow = pThisRange->aStart.Row();
2491 0 : nEndCol = pThisRange->aEnd .Col();
2492 0 : nEndRow = pThisRange->aEnd .Row();
2493 0 : bDoThis = AdjustPrintArea(false);
2494 : }
2495 : }
2496 :
2497 0 : if (bDoThis)
2498 : {
2499 0 : ScNotes::const_iterator itr = pDoc->GetNotes(nPrintTab)->begin();
2500 0 : ScNotes::const_iterator itrEnd = pDoc->GetNotes(nPrintTab)->end();
2501 0 : for (; itr != itrEnd; ++itr)
2502 : {
2503 0 : SCCOL nCol = itr->first.first;
2504 0 : SCROW nRow = itr->first.second;
2505 0 : if (nCol > nEndCol || nRow > nEndRow)
2506 0 : continue;
2507 :
2508 0 : if (nCol < nStartCol || nRow < nStartRow)
2509 0 : continue;
2510 :
2511 0 : aNotePosList.push_back( ScAddress( nCol, nRow, nPrintTab ) );
2512 0 : ++nCount;
2513 : }
2514 : }
2515 : }
2516 :
2517 0 : long nPages = 0;
2518 0 : long nNoteNr = 0;
2519 : long nNoteAdd;
2520 0 : do
2521 : {
2522 0 : nNoteAdd = PrintNotes( nPages, nNoteNr, false, NULL );
2523 0 : if (nNoteAdd)
2524 : {
2525 0 : nNoteNr += nNoteAdd;
2526 0 : ++nPages;
2527 : }
2528 : }
2529 : while (nNoteAdd);
2530 :
2531 0 : return nPages;
2532 : }
2533 :
2534 86 : void ScPrintFunc::InitModes() // aus nZoom etc. die MapModes setzen
2535 : {
2536 86 : aOffset = Point( aSrcOffset.X()*100/nZoom, aSrcOffset.Y()*100/nZoom );
2537 :
2538 86 : long nEffZoom = nZoom * (long) nManualZoom;
2539 86 : nScaleX = nScaleY = HMM_PER_TWIPS; // Ausgabe in 1/100 mm
2540 :
2541 86 : Fraction aZoomFract( nEffZoom,10000 );
2542 86 : Fraction aHorFract = aZoomFract;
2543 :
2544 86 : if ( !pPrinter && !bIsRender ) // adjust scale for preview
2545 : {
2546 0 : double nFact = pDocShell->GetOutputFactor();
2547 0 : aHorFract = Fraction( (long)( nEffZoom / nFact ), 10000 );
2548 : }
2549 :
2550 86 : aLogicMode = MapMode( MAP_100TH_MM, Point(), aHorFract, aZoomFract );
2551 :
2552 86 : Point aLogicOfs( -aOffset.X(), -aOffset.Y() );
2553 86 : aOffsetMode = MapMode( MAP_100TH_MM, aLogicOfs, aHorFract, aZoomFract );
2554 :
2555 86 : Point aTwipsOfs( (long) ( -aOffset.X() / nScaleX + 0.5 ), (long) ( -aOffset.Y() / nScaleY + 0.5 ) );
2556 86 : aTwipMode = MapMode( MAP_TWIP, aTwipsOfs, aHorFract, aZoomFract );
2557 86 : }
2558 :
2559 : //--------------------------------------------------------------------
2560 :
2561 0 : void ScPrintFunc::ApplyPrintSettings()
2562 : {
2563 0 : if ( pPrinter )
2564 : {
2565 : //
2566 : // Printer zum Drucken umstellen
2567 : //
2568 :
2569 0 : Size aEnumSize = aPageSize;
2570 :
2571 :
2572 0 : pPrinter->SetOrientation( bLandscape ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT );
2573 0 : if ( bLandscape )
2574 : {
2575 : // landscape is always interpreted as a rotation by 90 degrees !
2576 : // this leads to non WYSIWIG but at least it prints!
2577 : // #i21775#
2578 0 : long nTemp = aEnumSize.Width();
2579 0 : aEnumSize.Width() = aEnumSize.Height();
2580 0 : aEnumSize.Height() = nTemp;
2581 : }
2582 0 : Paper ePaper = SvxPaperInfo::GetSvxPaper( aEnumSize, MAP_TWIP, sal_True );
2583 0 : sal_uInt16 nPaperBin = ((const SvxPaperBinItem&)pParamSet->Get(ATTR_PAGE_PAPERBIN)).GetValue();
2584 :
2585 0 : pPrinter->SetPaper( ePaper );
2586 0 : if ( PAPER_USER == ePaper )
2587 : {
2588 0 : MapMode aPrinterMode = pPrinter->GetMapMode();
2589 0 : MapMode aLocalMode( MAP_TWIP );
2590 0 : pPrinter->SetMapMode( aLocalMode );
2591 0 : pPrinter->SetPaperSizeUser( aEnumSize );
2592 0 : pPrinter->SetMapMode( aPrinterMode );
2593 : }
2594 :
2595 0 : pPrinter->SetPaperBin( nPaperBin );
2596 : }
2597 0 : }
2598 :
2599 : //--------------------------------------------------------------------
2600 : // rPageRanges = range for all tables
2601 : // nStartPage = rPageRanges starts at nStartPage
2602 : // nDisplayStart = continious number for displaying the page number
2603 :
2604 0 : long ScPrintFunc::DoPrint( const MultiSelection& rPageRanges,
2605 : long nStartPage, long nDisplayStart, bool bDoPrint,
2606 : ScPreviewLocationData* pLocationData )
2607 : {
2608 : OSL_ENSURE(pDev,"Device == NULL");
2609 0 : if (!pParamSet)
2610 0 : return 0;
2611 :
2612 0 : if ( pPrinter && bDoPrint )
2613 0 : ApplyPrintSettings();
2614 :
2615 : //--------------------------------------------------------------------
2616 :
2617 0 : InitModes();
2618 0 : if ( pLocationData )
2619 : {
2620 0 : pLocationData->SetCellMapMode( aOffsetMode );
2621 0 : pLocationData->SetPrintTab( nPrintTab );
2622 : }
2623 :
2624 0 : MakeTableString();
2625 :
2626 : //--------------------------------------------------------------------
2627 :
2628 0 : long nPageNo = 0;
2629 0 : long nPrinted = 0;
2630 0 : long nEndPage = rPageRanges.GetTotalRange().Max();
2631 :
2632 0 : sal_uInt16 nRepeats = 1;
2633 0 : if (bMultiArea)
2634 0 : nRepeats = pDoc->GetPrintRangeCount(nPrintTab);
2635 0 : for (sal_uInt16 nStep=0; nStep<nRepeats; nStep++)
2636 : {
2637 0 : if (bMultiArea) // replace area
2638 : {
2639 0 : CalcZoom(nStep); // also sets nStartCol etc. new
2640 0 : InitModes();
2641 : }
2642 :
2643 : SCCOL nX1;
2644 : SCROW nY1;
2645 : SCCOL nX2;
2646 : SCROW nY2;
2647 : size_t nCountX;
2648 : size_t nCountY;
2649 :
2650 0 : if (aTableParam.bTopDown) // top-bottom
2651 : {
2652 0 : nX1 = nStartCol;
2653 0 : for (nCountX=0; nCountX<nPagesX; nCountX++)
2654 : {
2655 0 : nX2 = pPageEndX[nCountX];
2656 0 : for (nCountY=0; nCountY<nPagesY; nCountY++)
2657 : {
2658 0 : nY1 = pPageRows[nCountY].GetStartRow();
2659 0 : nY2 = pPageRows[nCountY].GetEndRow();
2660 0 : if ( !aTableParam.bSkipEmpty || !pPageRows[nCountY].IsHidden(nCountX) )
2661 : {
2662 0 : if ( rPageRanges.IsSelected( nPageNo+nStartPage+1 ) )
2663 : {
2664 : PrintPage( nPageNo+nDisplayStart, nX1, nY1, nX2, nY2,
2665 0 : bDoPrint, pLocationData );
2666 0 : ++nPrinted;
2667 : }
2668 0 : ++nPageNo;
2669 : }
2670 : }
2671 0 : nX1 = nX2 + 1;
2672 : }
2673 : }
2674 : else // left to right
2675 : {
2676 0 : for (nCountY=0; nCountY<nPagesY; nCountY++)
2677 : {
2678 0 : nY1 = pPageRows[nCountY].GetStartRow();
2679 0 : nY2 = pPageRows[nCountY].GetEndRow();
2680 0 : nX1 = nStartCol;
2681 0 : for (nCountX=0; nCountX<nPagesX; nCountX++)
2682 : {
2683 0 : nX2 = pPageEndX[nCountX];
2684 0 : if ( !aTableParam.bSkipEmpty || !pPageRows[nCountY].IsHidden(nCountX) )
2685 : {
2686 0 : if ( rPageRanges.IsSelected( nPageNo+nStartPage+1 ) )
2687 : {
2688 : PrintPage( nPageNo+nDisplayStart, nX1, nY1, nX2, nY2,
2689 0 : bDoPrint, pLocationData );
2690 0 : ++nPrinted;
2691 : }
2692 0 : ++nPageNo;
2693 : }
2694 0 : nX1 = nX2 + 1;
2695 : }
2696 : }
2697 : }
2698 : }
2699 :
2700 0 : aFieldData.aTabName = ScGlobal::GetRscString( STR_NOTES );
2701 :
2702 0 : long nNoteNr = 0;
2703 : long nNoteAdd;
2704 0 : do
2705 : {
2706 0 : if ( nPageNo+nStartPage <= nEndPage )
2707 : {
2708 0 : sal_Bool bPageSelected = rPageRanges.IsSelected( nPageNo+nStartPage+1 );
2709 : nNoteAdd = PrintNotes( nPageNo+nStartPage, nNoteNr, bDoPrint && bPageSelected,
2710 0 : ( bPageSelected ? pLocationData : NULL ) );
2711 0 : if ( nNoteAdd )
2712 : {
2713 0 : nNoteNr += nNoteAdd;
2714 0 : if (bPageSelected)
2715 : {
2716 0 : ++nPrinted;
2717 0 : bSourceRangeValid = false; // last page was no cell range
2718 : }
2719 0 : ++nPageNo;
2720 : }
2721 : }
2722 : else
2723 0 : nNoteAdd = 0;
2724 : }
2725 : while (nNoteAdd);
2726 :
2727 0 : if ( bMultiArea )
2728 0 : ResetBreaks(nPrintTab); //breaks correct for displaying
2729 :
2730 0 : return nPrinted;
2731 : }
2732 :
2733 17 : void ScPrintFunc::CalcZoom( sal_uInt16 nRangeNo ) // calculate zoom
2734 : {
2735 17 : sal_uInt16 nRCount = pDoc->GetPrintRangeCount( nPrintTab );
2736 17 : const ScRange* pThisRange = NULL;
2737 17 : if ( nRangeNo != RANGENO_NORANGE || nRangeNo < nRCount )
2738 0 : pThisRange = pDoc->GetPrintRange( nPrintTab, nRangeNo );
2739 17 : if ( pThisRange )
2740 : {
2741 0 : nStartCol = pThisRange->aStart.Col();
2742 0 : nStartRow = pThisRange->aStart.Row();
2743 0 : nEndCol = pThisRange->aEnd .Col();
2744 0 : nEndRow = pThisRange->aEnd .Row();
2745 : }
2746 :
2747 17 : if (!AdjustPrintArea(false)) // empty
2748 : {
2749 0 : nZoom = 100;
2750 0 : nPagesX = nPagesY = nTotalY = 0;
2751 17 : return;
2752 : }
2753 :
2754 17 : pDoc->SetRepeatArea( nPrintTab, nRepeatStartCol,nRepeatEndCol, nRepeatStartRow,nRepeatEndRow );
2755 :
2756 17 : if (aTableParam.bScalePageNum)
2757 : {
2758 0 : nZoom = 100;
2759 0 : sal_uInt16 nPagesToFit = aTableParam.nScalePageNum;
2760 :
2761 0 : sal_uInt16 nLastFitZoom = 0, nLastNonFitZoom = 0;
2762 0 : while (true)
2763 : {
2764 0 : if (nZoom <= ZOOM_MIN)
2765 0 : break;
2766 :
2767 0 : CalcPages();
2768 0 : bool bFitsPage = (nPagesX * nPagesY <= nPagesToFit);
2769 :
2770 0 : if (bFitsPage)
2771 : {
2772 0 : if (nZoom == 100)
2773 : // If it fits at 100 %, it's good enough for me.
2774 0 : break;
2775 :
2776 0 : nLastFitZoom = nZoom;
2777 0 : nZoom = (nLastNonFitZoom + nZoom) / 2;
2778 :
2779 0 : if (nLastFitZoom == nZoom)
2780 : // It converged. Use this zoom level.
2781 0 : break;
2782 : }
2783 : else
2784 : {
2785 0 : if (nZoom - nLastFitZoom <= 1)
2786 : {
2787 0 : nZoom = nLastFitZoom;
2788 0 : CalcPages();
2789 0 : break;
2790 : }
2791 :
2792 0 : nLastNonFitZoom = nZoom;
2793 0 : nZoom = (nLastFitZoom + nZoom) / 2;
2794 : }
2795 : }
2796 : }
2797 17 : else if (aTableParam.bScaleTo)
2798 : {
2799 0 : nZoom = 100;
2800 0 : sal_uInt16 nW = aTableParam.nScaleWidth;
2801 0 : sal_uInt16 nH = aTableParam.nScaleHeight;
2802 :
2803 0 : sal_uInt16 nLastFitZoom = 0, nLastNonFitZoom = 0;
2804 0 : while (true)
2805 : {
2806 0 : if (nZoom <= ZOOM_MIN)
2807 0 : break;
2808 :
2809 0 : CalcPages();
2810 0 : bool bFitsPage = ((!nW || (nPagesX <= nW)) && (!nH || (nPagesY <= nH)));
2811 :
2812 0 : if (bFitsPage)
2813 : {
2814 0 : if (nZoom == 100)
2815 : // If it fits at 100 %, it's good enough for me.
2816 0 : break;
2817 :
2818 0 : nLastFitZoom = nZoom;
2819 0 : nZoom = (nLastNonFitZoom + nZoom) / 2;
2820 :
2821 0 : if (nLastFitZoom == nZoom)
2822 : // It converged. Use this zoom level.
2823 0 : break;
2824 : }
2825 : else
2826 : {
2827 0 : if (nZoom - nLastFitZoom <= 1)
2828 : {
2829 0 : nZoom = nLastFitZoom;
2830 0 : CalcPages();
2831 0 : break;
2832 : }
2833 :
2834 0 : nLastNonFitZoom = nZoom;
2835 0 : nZoom = (nLastFitZoom + nZoom) / 2;
2836 : }
2837 : }
2838 : }
2839 17 : else if (aTableParam.bScaleAll)
2840 : {
2841 17 : nZoom = aTableParam.nScaleAll;
2842 17 : if ( nZoom <= ZOOM_MIN )
2843 0 : nZoom = ZOOM_MIN;
2844 17 : CalcPages();
2845 : }
2846 : else
2847 : {
2848 : OSL_ENSURE( aTableParam.bScaleNone, "kein Scale-Flag gesetzt" );
2849 0 : nZoom = 100;
2850 0 : CalcPages();
2851 : }
2852 : }
2853 :
2854 86 : Size ScPrintFunc::GetDocPageSize()
2855 : {
2856 : // Hoehe Kopf-/Fusszeile anpassen
2857 :
2858 86 : InitModes(); // aTwipMode aus nZoom initialisieren
2859 86 : pDev->SetMapMode( aTwipMode ); // Kopf-/Fusszeilen in Twips
2860 86 : UpdateHFHeight( aHdr );
2861 86 : UpdateHFHeight( aFtr );
2862 :
2863 : // Seitengroesse in Document-Twips
2864 : // Berechnung Left / Right auch in PrintPage
2865 :
2866 86 : aPageRect = Rectangle( Point(), aPageSize );
2867 86 : aPageRect.Left() = ( aPageRect.Left() + nLeftMargin ) * 100 / nZoom;
2868 86 : aPageRect.Right() = ( aPageRect.Right() - nRightMargin ) * 100 / nZoom;
2869 86 : aPageRect.Top() = ( aPageRect.Top() + nTopMargin ) * 100 / nZoom + aHdr.nHeight;
2870 86 : aPageRect.Bottom() = ( aPageRect.Bottom() - nBottomMargin ) * 100 / nZoom - aFtr.nHeight;
2871 :
2872 86 : Size aDocPageSize = aPageRect.GetSize();
2873 86 : if (aTableParam.bHeaders)
2874 : {
2875 0 : aDocPageSize.Width() -= (long) PRINT_HEADER_WIDTH;
2876 0 : aDocPageSize.Height() -= (long) PRINT_HEADER_HEIGHT;
2877 : }
2878 86 : if (pBorderItem)
2879 : {
2880 172 : aDocPageSize.Width() -= lcl_LineTotal(pBorderItem->GetLeft()) +
2881 86 : lcl_LineTotal(pBorderItem->GetRight()) +
2882 86 : pBorderItem->GetDistance(BOX_LINE_LEFT) +
2883 258 : pBorderItem->GetDistance(BOX_LINE_RIGHT);
2884 172 : aDocPageSize.Height() -= lcl_LineTotal(pBorderItem->GetTop()) +
2885 86 : lcl_LineTotal(pBorderItem->GetBottom()) +
2886 86 : pBorderItem->GetDistance(BOX_LINE_TOP) +
2887 258 : pBorderItem->GetDistance(BOX_LINE_BOTTOM);
2888 : }
2889 86 : if (pShadowItem && pShadowItem->GetLocation() != SVX_SHADOW_NONE)
2890 : {
2891 0 : aDocPageSize.Width() -= pShadowItem->CalcShadowSpace(SHADOW_LEFT) +
2892 0 : pShadowItem->CalcShadowSpace(SHADOW_RIGHT);
2893 0 : aDocPageSize.Height() -= pShadowItem->CalcShadowSpace(SHADOW_TOP) +
2894 0 : pShadowItem->CalcShadowSpace(SHADOW_BOTTOM);
2895 : }
2896 86 : return aDocPageSize;
2897 : }
2898 :
2899 69 : void ScPrintFunc::ResetBreaks( SCTAB nTab ) // Breaks fuer Anzeige richtig setzen
2900 : {
2901 69 : pDoc->SetPageSize( nTab, GetDocPageSize() );
2902 69 : pDoc->UpdatePageBreaks( nTab, NULL );
2903 69 : }
2904 :
2905 0 : static void lcl_SetHidden( ScDocument* pDoc, SCTAB nPrintTab, ScPageRowEntry& rPageRowEntry,
2906 : SCCOL nStartCol, const SCCOL* pPageEndX )
2907 : {
2908 0 : size_t nPagesX = rPageRowEntry.GetPagesX();
2909 0 : SCROW nStartRow = rPageRowEntry.GetStartRow();
2910 0 : SCROW nEndRow = rPageRowEntry.GetEndRow();
2911 :
2912 0 : sal_Bool bLeftIsEmpty = false;
2913 0 : ScRange aTempRange;
2914 0 : Rectangle aTempRect = pDoc->GetMMRect( 0,0, 0,0, 0 );
2915 :
2916 0 : for (size_t i=0; i<nPagesX; i++)
2917 : {
2918 0 : SCCOL nEndCol = pPageEndX[i];
2919 0 : if ( pDoc->IsPrintEmpty( nPrintTab, nStartCol, nStartRow, nEndCol, nEndRow,
2920 0 : bLeftIsEmpty, &aTempRange, &aTempRect ) )
2921 : {
2922 0 : rPageRowEntry.SetHidden(i);
2923 0 : bLeftIsEmpty = sal_True;
2924 : }
2925 : else
2926 0 : bLeftIsEmpty = false;
2927 :
2928 0 : nStartCol = nEndCol+1;
2929 : }
2930 0 : }
2931 :
2932 17 : void ScPrintFunc::CalcPages() // berechnet aPageRect und Seiten aus nZoom
2933 : {
2934 17 : if (!pPageEndX) pPageEndX = new SCCOL[MAXCOL+1];
2935 17 : if (!pPageEndY) pPageEndY = new SCROW[MAXROW+1];
2936 17 : if (!pPageRows) pPageRows = new ScPageRowEntry[MAXROW+1]; //! vorher zaehlen !!!!
2937 :
2938 17 : pDoc->SetPageSize( nPrintTab, GetDocPageSize() );
2939 17 : if (aAreaParam.bPrintArea)
2940 : {
2941 0 : ScRange aRange( nStartCol, nStartRow, nPrintTab, nEndCol, nEndRow, nPrintTab );
2942 0 : pDoc->UpdatePageBreaks( nPrintTab, &aRange );
2943 : }
2944 : else
2945 17 : pDoc->UpdatePageBreaks( nPrintTab, NULL ); // sonst wird das Ende markiert
2946 :
2947 : //
2948 : // Seiteneinteilung nach Umbruechen in Col/RowFlags
2949 : // Von mehreren Umbruechen in einem ausgeblendeten Bereich zaehlt nur einer.
2950 : //
2951 :
2952 17 : nPagesX = 0;
2953 17 : nPagesY = 0;
2954 17 : nTotalY = 0;
2955 :
2956 17 : bool bVisCol = false;
2957 279 : for (SCCOL i=nStartCol; i<=nEndCol; i++)
2958 : {
2959 262 : bool bHidden = pDoc->ColHidden(i, nPrintTab);
2960 262 : bool bPageBreak = (pDoc->HasColBreak(i, nPrintTab) & BREAK_PAGE);
2961 262 : if ( i>nStartCol && bVisCol && bPageBreak )
2962 : {
2963 30 : pPageEndX[nPagesX] = i-1;
2964 30 : ++nPagesX;
2965 30 : bVisCol = false;
2966 : }
2967 262 : if (!bHidden)
2968 262 : bVisCol = true;
2969 : }
2970 17 : if (bVisCol) // auch am Ende keine leeren Seiten
2971 : {
2972 17 : pPageEndX[nPagesX] = nEndCol;
2973 17 : ++nPagesX;
2974 : }
2975 :
2976 17 : bool bVisRow = false;
2977 17 : SCROW nPageStartRow = nStartRow;
2978 17 : SCROW nLastVisibleRow = -1;
2979 :
2980 17 : ::boost::scoped_ptr<ScRowBreakIterator> pRowBreakIter(pDoc->GetRowBreakIterator(nPrintTab));
2981 17 : SCROW nNextPageBreak = pRowBreakIter->first();
2982 34 : while (nNextPageBreak != ScRowBreakIterator::NOT_FOUND && nNextPageBreak < nStartRow)
2983 : // Skip until the page break position is at the start row or greater.
2984 0 : nNextPageBreak = pRowBreakIter->next();
2985 :
2986 181 : for (SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow)
2987 : {
2988 164 : bool bPageBreak = (nNextPageBreak == nRow);
2989 164 : if (bPageBreak)
2990 0 : nNextPageBreak = pRowBreakIter->next();
2991 :
2992 164 : if (nRow > nStartRow && bVisRow && bPageBreak )
2993 : {
2994 0 : pPageEndY[nTotalY] = nRow-1;
2995 0 : ++nTotalY;
2996 :
2997 0 : if ( !aTableParam.bSkipEmpty ||
2998 0 : !pDoc->IsPrintEmpty( nPrintTab, nStartCol, nPageStartRow, nEndCol, nRow-1 ) )
2999 : {
3000 0 : pPageRows[nPagesY].SetStartRow( nPageStartRow );
3001 0 : pPageRows[nPagesY].SetEndRow( nRow-1 );
3002 0 : pPageRows[nPagesY].SetPagesX( nPagesX );
3003 0 : if (aTableParam.bSkipEmpty)
3004 0 : lcl_SetHidden( pDoc, nPrintTab, pPageRows[nPagesY], nStartCol, pPageEndX );
3005 0 : ++nPagesY;
3006 : }
3007 :
3008 0 : nPageStartRow = nRow;
3009 0 : bVisRow = false;
3010 : }
3011 :
3012 164 : if (nRow <= nLastVisibleRow)
3013 : {
3014 : // This row is still visible. Don't bother calling RowHidden() to
3015 : // find out, for speed optimization.
3016 147 : bVisRow = true;
3017 147 : continue;
3018 : }
3019 :
3020 17 : SCROW nLastRow = -1;
3021 17 : if (!pDoc->RowHidden(nRow, nPrintTab, NULL, &nLastRow))
3022 : {
3023 17 : bVisRow = true;
3024 17 : nLastVisibleRow = nLastRow;
3025 : }
3026 : else
3027 : // skip all hidden rows.
3028 0 : nRow = nLastRow;
3029 : }
3030 :
3031 17 : if (bVisRow)
3032 : {
3033 17 : pPageEndY[nTotalY] = nEndRow;
3034 17 : ++nTotalY;
3035 :
3036 17 : if ( !aTableParam.bSkipEmpty ||
3037 0 : !pDoc->IsPrintEmpty( nPrintTab, nStartCol, nPageStartRow, nEndCol, nEndRow ) )
3038 : {
3039 17 : pPageRows[nPagesY].SetStartRow( nPageStartRow );
3040 17 : pPageRows[nPagesY].SetEndRow( nEndRow );
3041 17 : pPageRows[nPagesY].SetPagesX( nPagesX );
3042 17 : if (aTableParam.bSkipEmpty)
3043 0 : lcl_SetHidden( pDoc, nPrintTab, pPageRows[nPagesY], nStartCol, pPageEndX );
3044 17 : ++nPagesY;
3045 : }
3046 17 : }
3047 32 : }
3048 :
3049 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
