1efeef26fSAndrew Rist /**************************************************************
260d78278Smseidel *
3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5efeef26fSAndrew Rist * distributed with this work for additional information
6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
1060d78278Smseidel *
11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1260d78278Smseidel *
13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14efeef26fSAndrew Rist * software distributed under the License is distributed on an
15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17efeef26fSAndrew Rist * specific language governing permissions and limitations
18efeef26fSAndrew Rist * under the License.
1960d78278Smseidel *
20efeef26fSAndrew Rist *************************************************************/
21efeef26fSAndrew Rist
22cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
23cdf0e10cSrcweir #include "precompiled_sw.hxx"
24cdf0e10cSrcweir #include <pagepreviewlayout.hxx>
25cdf0e10cSrcweir #ifndef _PREVWPAGE_HXX
26cdf0e10cSrcweir #include <prevwpage.hxx>
27cdf0e10cSrcweir #endif
28cdf0e10cSrcweir
29cdf0e10cSrcweir #include <algorithm>
30cdf0e10cSrcweir #include <vcl/window.hxx>
31cdf0e10cSrcweir #include <rootfrm.hxx>
32cdf0e10cSrcweir #include <pagefrm.hxx>
33cdf0e10cSrcweir #include <viewsh.hxx>
34cdf0e10cSrcweir #include <viewimp.hxx>
35cdf0e10cSrcweir #include <viewopt.hxx>
36cdf0e10cSrcweir #include <swregion.hxx>
37cdf0e10cSrcweir #ifndef _COMCORE_HRC
38cdf0e10cSrcweir #include <comcore.hrc>
39cdf0e10cSrcweir #endif
40cdf0e10cSrcweir // OD 19.02.2003 #107369# - method <SwAlignRect(..)>
41cdf0e10cSrcweir #include <frmtool.hxx>
42cdf0e10cSrcweir // OD 24.09.2003 #i19975#
43cdf0e10cSrcweir #include <svx/zoomitem.hxx>
44cdf0e10cSrcweir #include <printdata.hxx>
45cdf0e10cSrcweir
46cdf0e10cSrcweir #include <IDocumentDeviceAccess.hxx>
47cdf0e10cSrcweir
48cdf0e10cSrcweir // OD 20.02.2003 #107369# - method to update statics for paint
49cdf0e10cSrcweir // Note: method defined in '/sw/source/core/layout/paintfrm.cxx'
50cdf0e10cSrcweir extern void SwCalcPixStatics( OutputDevice *pOut );
51cdf0e10cSrcweir
52cdf0e10cSrcweir // =============================================================================
53cdf0e10cSrcweir // methods to initialize page preview layout
54cdf0e10cSrcweir // =============================================================================
SwPagePreviewLayout(ViewShell & _rParentViewShell,const SwRootFrm & _rLayoutRootFrm)55cdf0e10cSrcweir SwPagePreviewLayout::SwPagePreviewLayout( ViewShell& _rParentViewShell,
56cdf0e10cSrcweir const SwRootFrm& _rLayoutRootFrm )
57694fcf58Smseidel : mnXFree ( 3 * 142 ),
58b76f2c32Smseidel mnYFree ( 3 * 142 ),
59cdf0e10cSrcweir mrParentViewShell( _rParentViewShell ),
60cdf0e10cSrcweir mrLayoutRootFrm ( _rLayoutRootFrm )
61cdf0e10cSrcweir {
62cdf0e10cSrcweir _Clear();
63cdf0e10cSrcweir
64cdf0e10cSrcweir // OD 2004-03-05 #i18143#
65cdf0e10cSrcweir mbBookPreview = false;
66cdf0e10cSrcweir mbBookPreviewModeToggled = false;
67cdf0e10cSrcweir
68cdf0e10cSrcweir mbPrintEmptyPages = mrParentViewShell.getIDocumentDeviceAccess()->getPrintData().IsPrintEmptyPages();
69cdf0e10cSrcweir }
70cdf0e10cSrcweir
_Clear()71cdf0e10cSrcweir void SwPagePreviewLayout::_Clear()
72cdf0e10cSrcweir {
73cdf0e10cSrcweir mbLayoutInfoValid = mbLayoutSizesValid = mbPaintInfoValid = false;
74cdf0e10cSrcweir
75cdf0e10cSrcweir maWinSize.Width() = 0;
76cdf0e10cSrcweir maWinSize.Height() = 0;
77cdf0e10cSrcweir mnCols = mnRows = 0;
78cdf0e10cSrcweir
79cdf0e10cSrcweir _ClearPrevwLayoutSizes();
80cdf0e10cSrcweir
81cdf0e10cSrcweir mbDoesLayoutRowsFitIntoWindow = false;
82cdf0e10cSrcweir mbDoesLayoutColsFitIntoWindow = false;
83cdf0e10cSrcweir
84cdf0e10cSrcweir mnPaintPhyStartPageNum = 0;
85cdf0e10cSrcweir mnPaintStartCol = mnPaintStartRow = 0;
86cdf0e10cSrcweir mbNoPageVisible = false;
87cdf0e10cSrcweir maPaintStartPageOffset.X() = 0;
88cdf0e10cSrcweir maPaintStartPageOffset.Y() = 0;
89cdf0e10cSrcweir maPaintPreviewDocOffset.X() = 0;
90cdf0e10cSrcweir maPaintPreviewDocOffset.Y() = 0;
91cdf0e10cSrcweir maAdditionalPaintOffset.X() = 0;
92cdf0e10cSrcweir maAdditionalPaintOffset.Y() = 0;
93cdf0e10cSrcweir maPaintedPrevwDocRect.Left() = 0;
94cdf0e10cSrcweir maPaintedPrevwDocRect.Top() = 0;
95cdf0e10cSrcweir maPaintedPrevwDocRect.Right() = 0;
96cdf0e10cSrcweir maPaintedPrevwDocRect.Bottom() = 0;
97cdf0e10cSrcweir mnSelectedPageNum = 0;
98cdf0e10cSrcweir _ClearPrevwPageData();
99cdf0e10cSrcweir
100cdf0e10cSrcweir // OD 07.11.2003 #i22014#
101cdf0e10cSrcweir mbInPaint = false;
102cdf0e10cSrcweir mbNewLayoutDuringPaint = false;
103cdf0e10cSrcweir }
104cdf0e10cSrcweir
_ClearPrevwLayoutSizes()105cdf0e10cSrcweir void SwPagePreviewLayout::_ClearPrevwLayoutSizes()
106cdf0e10cSrcweir {
107cdf0e10cSrcweir mnPages = 0;
108cdf0e10cSrcweir
109cdf0e10cSrcweir maMaxPageSize.Width() = 0;
110cdf0e10cSrcweir maMaxPageSize.Height() = 0;
111cdf0e10cSrcweir maPreviewDocRect.Left() = maPreviewDocRect.Top() = 0;
112cdf0e10cSrcweir maPreviewDocRect.Right() = maPreviewDocRect.Bottom() = 0;
113cdf0e10cSrcweir mnColWidth = mnRowHeight = 0;
114cdf0e10cSrcweir mnPrevwLayoutWidth = mnPrevwLayoutHeight = 0;
115cdf0e10cSrcweir }
116cdf0e10cSrcweir
_ClearPrevwPageData()117cdf0e10cSrcweir void SwPagePreviewLayout::_ClearPrevwPageData()
118cdf0e10cSrcweir {
119cdf0e10cSrcweir for ( std::vector<PrevwPage*>::iterator aPageDelIter = maPrevwPages.begin();
120cdf0e10cSrcweir aPageDelIter != maPrevwPages.end();
121cdf0e10cSrcweir ++aPageDelIter )
122cdf0e10cSrcweir {
123cdf0e10cSrcweir delete (*aPageDelIter);
124cdf0e10cSrcweir }
125cdf0e10cSrcweir maPrevwPages.clear();
126cdf0e10cSrcweir }
127cdf0e10cSrcweir
128cdf0e10cSrcweir /** calculate page preview layout sizes
129cdf0e10cSrcweir
130cdf0e10cSrcweir OD 18.12.2002 #103492#
131cdf0e10cSrcweir
132cdf0e10cSrcweir @author OD
133cdf0e10cSrcweir */
_CalcPrevwLayoutSizes()134cdf0e10cSrcweir void SwPagePreviewLayout::_CalcPrevwLayoutSizes()
135cdf0e10cSrcweir {
136cdf0e10cSrcweir // calculate maximal page size; calculate also number of pages
137cdf0e10cSrcweir
138cdf0e10cSrcweir const SwPageFrm* pPage = static_cast<const SwPageFrm*>(mrLayoutRootFrm.Lower());
139cdf0e10cSrcweir while ( pPage )
140cdf0e10cSrcweir {
141cdf0e10cSrcweir if ( !mbBookPreview && !mbPrintEmptyPages && pPage->IsEmptyPage() )
142cdf0e10cSrcweir {
143cdf0e10cSrcweir pPage = static_cast<const SwPageFrm*>(pPage->GetNext());
144cdf0e10cSrcweir continue;
145cdf0e10cSrcweir }
146cdf0e10cSrcweir
147cdf0e10cSrcweir ++mnPages;
148cdf0e10cSrcweir pPage->Calc();
149cdf0e10cSrcweir const Size& rPageSize = pPage->Frm().SSize();
150cdf0e10cSrcweir if ( rPageSize.Width() > maMaxPageSize.Width() )
151cdf0e10cSrcweir maMaxPageSize.Width() = rPageSize.Width();
152cdf0e10cSrcweir if ( rPageSize.Height() > maMaxPageSize.Height() )
153cdf0e10cSrcweir maMaxPageSize.Height() = rPageSize.Height();
154cdf0e10cSrcweir pPage = static_cast<const SwPageFrm*>(pPage->GetNext());
155cdf0e10cSrcweir }
156cdf0e10cSrcweir // calculate and set column width and row height
157cdf0e10cSrcweir mnColWidth = maMaxPageSize.Width() + mnXFree;
158cdf0e10cSrcweir mnRowHeight = maMaxPageSize.Height() + mnYFree;
159cdf0e10cSrcweir
160cdf0e10cSrcweir // calculate and set preview layout width and height
161cdf0e10cSrcweir mnPrevwLayoutWidth = mnCols * mnColWidth + mnXFree;
162cdf0e10cSrcweir mnPrevwLayoutHeight = mnRows * mnRowHeight + mnYFree;
163cdf0e10cSrcweir
164cdf0e10cSrcweir // calculate document rectangle in preview layout
165cdf0e10cSrcweir {
166cdf0e10cSrcweir Size aDocSize;
167cdf0e10cSrcweir // document width
168cdf0e10cSrcweir aDocSize.Width() = mnPrevwLayoutWidth;
169cdf0e10cSrcweir
170cdf0e10cSrcweir // document height
171cdf0e10cSrcweir // determine number of rows needed for <nPages> in preview layout
172cdf0e10cSrcweir // OD 19.02.2003 #107369# - use method <GetRowOfPage(..)>.
173cdf0e10cSrcweir sal_uInt16 nDocRows = GetRowOfPage( mnPages );
174cdf0e10cSrcweir aDocSize.Height() = nDocRows * maMaxPageSize.Height() +
175cdf0e10cSrcweir (nDocRows+1) * mnYFree;
176cdf0e10cSrcweir maPreviewDocRect.SetPos( Point( 0, 0 ) );
177cdf0e10cSrcweir maPreviewDocRect.SetSize( aDocSize );
178cdf0e10cSrcweir }
179cdf0e10cSrcweir }
180cdf0e10cSrcweir
181cdf0e10cSrcweir /** init page preview layout
182cdf0e10cSrcweir
183cdf0e10cSrcweir OD 11.12.2002 #103492#
184cdf0e10cSrcweir initialize the page preview settings for a given layout.
185cdf0e10cSrcweir side effects:
186cdf0e10cSrcweir (1) If parameter <_bCalcScale> is true, mapping mode with calculated
187cdf0e10cSrcweir scaling is set at the output device and the zoom at the view options of
188cdf0e10cSrcweir the given view shell is set with the calculated scaling.
189cdf0e10cSrcweir
190cdf0e10cSrcweir @author OD
191cdf0e10cSrcweir */
Init(const sal_uInt16 _nCols,const sal_uInt16 _nRows,const Size & _rPxWinSize,const bool _bCalcScale)192cdf0e10cSrcweir bool SwPagePreviewLayout::Init( const sal_uInt16 _nCols,
193cdf0e10cSrcweir const sal_uInt16 _nRows,
194cdf0e10cSrcweir const Size& _rPxWinSize,
195cdf0e10cSrcweir const bool _bCalcScale
196cdf0e10cSrcweir )
197cdf0e10cSrcweir {
198cdf0e10cSrcweir // check environment and parameters
199cdf0e10cSrcweir {
200cdf0e10cSrcweir bool bColsRowsValid = (_nCols != 0) && (_nRows != 0);
201cdf0e10cSrcweir ASSERT( bColsRowsValid, "preview layout parameters not correct - preview layout can *not* be initialized" );
202cdf0e10cSrcweir if ( !bColsRowsValid )
203cdf0e10cSrcweir return false;
204cdf0e10cSrcweir
205cdf0e10cSrcweir bool bPxWinSizeValid = (_rPxWinSize.Width() >= 0) &&
206cdf0e10cSrcweir (_rPxWinSize.Height() >= 0);
207cdf0e10cSrcweir ASSERT( bPxWinSizeValid, "no window size - preview layout can *not* be initialized" );
208cdf0e10cSrcweir if ( !bPxWinSizeValid )
209cdf0e10cSrcweir return false;
210cdf0e10cSrcweir }
211cdf0e10cSrcweir
21260d78278Smseidel // environment and parameters OK
213cdf0e10cSrcweir
214cdf0e10cSrcweir // clear existing preview settings
215cdf0e10cSrcweir _Clear();
216cdf0e10cSrcweir
217cdf0e10cSrcweir // set layout information columns and rows
218cdf0e10cSrcweir mnCols = _nCols;
219cdf0e10cSrcweir mnRows = _nRows;
220cdf0e10cSrcweir
221cdf0e10cSrcweir _CalcPrevwLayoutSizes();
222cdf0e10cSrcweir
223cdf0e10cSrcweir // validate layout information
224cdf0e10cSrcweir mbLayoutInfoValid = true;
225cdf0e10cSrcweir
226cdf0e10cSrcweir if ( _bCalcScale )
227cdf0e10cSrcweir {
228cdf0e10cSrcweir // calculate scaling
229cdf0e10cSrcweir MapMode aMapMode( MAP_TWIP );
230cdf0e10cSrcweir Size aWinSize = mrParentViewShell.GetOut()->PixelToLogic( _rPxWinSize, aMapMode );
231cdf0e10cSrcweir Fraction aXScale( aWinSize.Width(), mnPrevwLayoutWidth );
232cdf0e10cSrcweir Fraction aYScale( aWinSize.Height(), mnPrevwLayoutHeight );
233cdf0e10cSrcweir if( aXScale < aYScale )
234cdf0e10cSrcweir aYScale = aXScale;
235cdf0e10cSrcweir {
236cdf0e10cSrcweir // adjust scaling for Drawing layer.
237cdf0e10cSrcweir aYScale *= Fraction( 1000, 1 );
238cdf0e10cSrcweir long nNewNuminator = aYScale.operator long();
239cdf0e10cSrcweir if( nNewNuminator < 1 )
240cdf0e10cSrcweir nNewNuminator = 1;
241cdf0e10cSrcweir aYScale = Fraction( nNewNuminator, 1000 );
242cdf0e10cSrcweir // propagate scaling as zoom percentage to view options for font cache
243cdf0e10cSrcweir _ApplyNewZoomAtViewShell( static_cast<sal_uInt8>(nNewNuminator/10) );
244cdf0e10cSrcweir }
245cdf0e10cSrcweir aMapMode.SetScaleY( aYScale );
246cdf0e10cSrcweir aMapMode.SetScaleX( aYScale );
247cdf0e10cSrcweir // set created mapping mode with calculated scaling at output device.
248cdf0e10cSrcweir mrParentViewShell.GetOut()->SetMapMode( aMapMode );
249cdf0e10cSrcweir // OD 20.02.2003 #107369# - update statics for paint.
250cdf0e10cSrcweir ::SwCalcPixStatics( mrParentViewShell.GetOut() );
251cdf0e10cSrcweir }
252cdf0e10cSrcweir
253cdf0e10cSrcweir // set window size in twips
254cdf0e10cSrcweir maWinSize = mrParentViewShell.GetOut()->PixelToLogic( _rPxWinSize );
255cdf0e10cSrcweir // validate layout sizes
256cdf0e10cSrcweir mbLayoutSizesValid = true;
257cdf0e10cSrcweir
258cdf0e10cSrcweir return true;
259cdf0e10cSrcweir }
260cdf0e10cSrcweir
261cdf0e10cSrcweir /** apply new zoom at given view shell
262cdf0e10cSrcweir
263cdf0e10cSrcweir OD 11.12.2002 #103492# - implementation of <_ApplyNewZoomAtViewShell>
264cdf0e10cSrcweir
265cdf0e10cSrcweir @author OD
266cdf0e10cSrcweir */
_ApplyNewZoomAtViewShell(sal_uInt8 _aNewZoom)267cdf0e10cSrcweir void SwPagePreviewLayout::_ApplyNewZoomAtViewShell( sal_uInt8 _aNewZoom )
268cdf0e10cSrcweir {
269cdf0e10cSrcweir SwViewOption aNewViewOptions = *(mrParentViewShell.GetViewOptions());
270cdf0e10cSrcweir if ( aNewViewOptions.GetZoom() != _aNewZoom )
271cdf0e10cSrcweir {
272cdf0e10cSrcweir aNewViewOptions.SetZoom( _aNewZoom );
273cdf0e10cSrcweir // OD 24.09.2003 #i19975# - consider zoom type.
274cdf0e10cSrcweir enum SvxZoomType eZoomType = SVX_ZOOM_PERCENT;
275cdf0e10cSrcweir aNewViewOptions.SetZoomType( eZoomType );
276cdf0e10cSrcweir mrParentViewShell.ApplyViewOptions( aNewViewOptions );
277cdf0e10cSrcweir }
278cdf0e10cSrcweir }
279cdf0e10cSrcweir
280cdf0e10cSrcweir /** method to adjust page preview layout to document changes
281cdf0e10cSrcweir
282cdf0e10cSrcweir OD 18.12.2002 #103492#
283cdf0e10cSrcweir
284cdf0e10cSrcweir @author OD
285cdf0e10cSrcweir */
ReInit()286cdf0e10cSrcweir bool SwPagePreviewLayout::ReInit()
287cdf0e10cSrcweir {
288cdf0e10cSrcweir // check environment and parameters
289cdf0e10cSrcweir {
290cdf0e10cSrcweir bool bLayoutSettingsValid = mbLayoutInfoValid && mbLayoutSizesValid;
291cdf0e10cSrcweir ASSERT( bLayoutSettingsValid,
292cdf0e10cSrcweir "no valid preview layout info/sizes - no re-init of page preview layout");
293cdf0e10cSrcweir if ( !bLayoutSettingsValid )
294cdf0e10cSrcweir return false;
295cdf0e10cSrcweir }
296cdf0e10cSrcweir
297cdf0e10cSrcweir _ClearPrevwLayoutSizes();
298cdf0e10cSrcweir _CalcPrevwLayoutSizes();
299cdf0e10cSrcweir
300cdf0e10cSrcweir return true;
301cdf0e10cSrcweir }
302cdf0e10cSrcweir
303cdf0e10cSrcweir // =============================================================================
304cdf0e10cSrcweir // methods to prepare paint of page preview
305cdf0e10cSrcweir // =============================================================================
306cdf0e10cSrcweir /** prepare paint of page preview
307cdf0e10cSrcweir
308cdf0e10cSrcweir OD 12.12.2002 #103492#
309cdf0e10cSrcweir OD 21.03.2003 #108282# - delete parameter _onStartPageVirtNum
310cdf0e10cSrcweir
311cdf0e10cSrcweir @author OD, _nProposedStartPageNum, _onStartPageNum are absolute
312cdf0e10cSrcweir */
Prepare(const sal_uInt16 _nProposedStartPageNum,const Point _aProposedStartPos,const Size & _rPxWinSize,sal_uInt16 & _onStartPageNum,Rectangle & _orDocPreviewPaintRect,const bool _bStartWithPageAtFirstCol)313cdf0e10cSrcweir bool SwPagePreviewLayout::Prepare( const sal_uInt16 _nProposedStartPageNum,
314cdf0e10cSrcweir const Point _aProposedStartPos,
315cdf0e10cSrcweir const Size& _rPxWinSize,
316cdf0e10cSrcweir sal_uInt16& _onStartPageNum,
317cdf0e10cSrcweir Rectangle& _orDocPreviewPaintRect,
318cdf0e10cSrcweir const bool _bStartWithPageAtFirstCol
319cdf0e10cSrcweir )
320cdf0e10cSrcweir {
321cdf0e10cSrcweir sal_uInt16 nProposedStartPageNum = ConvertAbsoluteToRelativePageNum( _nProposedStartPageNum );
322cdf0e10cSrcweir // check environment and parameters
323cdf0e10cSrcweir {
324cdf0e10cSrcweir bool bLayoutSettingsValid = mbLayoutInfoValid && mbLayoutSizesValid;
325cdf0e10cSrcweir ASSERT( bLayoutSettingsValid,
326cdf0e10cSrcweir "no valid preview layout info/sizes - no prepare of preview paint");
327cdf0e10cSrcweir if ( !bLayoutSettingsValid )
328cdf0e10cSrcweir return false;
329cdf0e10cSrcweir
330cdf0e10cSrcweir bool bStartPageRangeValid = nProposedStartPageNum <= mnPages;
331cdf0e10cSrcweir ASSERT( bStartPageRangeValid,
332cdf0e10cSrcweir "proposed start page not existing - no prepare of preview paint");
333cdf0e10cSrcweir if ( !bStartPageRangeValid )
334cdf0e10cSrcweir return false;
335cdf0e10cSrcweir
336cdf0e10cSrcweir bool bStartPosRangeValid =
337cdf0e10cSrcweir _aProposedStartPos.X() >= 0 && _aProposedStartPos.Y() >= 0 &&
338cdf0e10cSrcweir _aProposedStartPos.X() <= maPreviewDocRect.Right() &&
339cdf0e10cSrcweir _aProposedStartPos.Y() <= maPreviewDocRect.Bottom();
340cdf0e10cSrcweir ASSERT( bStartPosRangeValid,
341cdf0e10cSrcweir "proposed start position out of range - no prepare of preview paint");
342cdf0e10cSrcweir if ( !bStartPosRangeValid )
343cdf0e10cSrcweir return false;
344cdf0e10cSrcweir
345cdf0e10cSrcweir bool bWinSizeValid = _rPxWinSize.Width() != 0 && _rPxWinSize.Height() != 0;
346cdf0e10cSrcweir ASSERT ( bWinSizeValid, "no window size - no prepare of preview paint");
347cdf0e10cSrcweir if ( !bWinSizeValid )
348cdf0e10cSrcweir return false;
349cdf0e10cSrcweir
350cdf0e10cSrcweir bool bStartInfoValid = _nProposedStartPageNum > 0 ||
351cdf0e10cSrcweir _aProposedStartPos != Point(0,0);
352cdf0e10cSrcweir if ( !bStartInfoValid )
353cdf0e10cSrcweir nProposedStartPageNum = 1;
354cdf0e10cSrcweir }
355cdf0e10cSrcweir
35660d78278Smseidel // environment and parameter OK
357cdf0e10cSrcweir
358cdf0e10cSrcweir // update window size at preview setting data
359cdf0e10cSrcweir maWinSize = mrParentViewShell.GetOut()->PixelToLogic( _rPxWinSize );
360cdf0e10cSrcweir
361cdf0e10cSrcweir mbNoPageVisible = false;
362cdf0e10cSrcweir if ( nProposedStartPageNum > 0 )
363cdf0e10cSrcweir {
364cdf0e10cSrcweir // determine column and row of proposed start page in virtual preview layout
365cdf0e10cSrcweir sal_uInt16 nColOfProposed = GetColOfPage( nProposedStartPageNum );
366cdf0e10cSrcweir sal_uInt16 nRowOfProposed = GetRowOfPage( nProposedStartPageNum );
367cdf0e10cSrcweir // determine start page
368cdf0e10cSrcweir if ( _bStartWithPageAtFirstCol )
369cdf0e10cSrcweir {
370cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is
371cdf0e10cSrcweir // controlled by <mbBookPreview>.
372cdf0e10cSrcweir if ( mbBookPreview &&
373cdf0e10cSrcweir ( nProposedStartPageNum == 1 || nRowOfProposed == 1 )
374cdf0e10cSrcweir )
375cdf0e10cSrcweir mnPaintPhyStartPageNum = 1;
376cdf0e10cSrcweir else
377cdf0e10cSrcweir mnPaintPhyStartPageNum = nProposedStartPageNum - (nColOfProposed-1);
378cdf0e10cSrcweir }
379cdf0e10cSrcweir else
380cdf0e10cSrcweir mnPaintPhyStartPageNum = nProposedStartPageNum;
381cdf0e10cSrcweir
382cdf0e10cSrcweir mnPaintPhyStartPageNum = ConvertRelativeToAbsolutePageNum( mnPaintPhyStartPageNum );
383cdf0e10cSrcweir
384cdf0e10cSrcweir // set starting column
385cdf0e10cSrcweir if ( _bStartWithPageAtFirstCol )
386cdf0e10cSrcweir mnPaintStartCol = 1;
387cdf0e10cSrcweir else
388cdf0e10cSrcweir mnPaintStartCol = nColOfProposed;
389cdf0e10cSrcweir // set starting row
390cdf0e10cSrcweir mnPaintStartRow = nRowOfProposed;
391cdf0e10cSrcweir // page offset == (-1,-1), indicating no offset and paint of free space.
392cdf0e10cSrcweir maPaintStartPageOffset.X() = -1;
393cdf0e10cSrcweir maPaintStartPageOffset.Y() = -1;
394cdf0e10cSrcweir // virtual preview document offset.
395cdf0e10cSrcweir if ( _bStartWithPageAtFirstCol )
396cdf0e10cSrcweir maPaintPreviewDocOffset.X() = 0;
397cdf0e10cSrcweir else
398cdf0e10cSrcweir maPaintPreviewDocOffset.X() = (nColOfProposed-1) * mnColWidth;
399cdf0e10cSrcweir maPaintPreviewDocOffset.Y() = (nRowOfProposed-1) * mnRowHeight;
400cdf0e10cSrcweir }
401cdf0e10cSrcweir else
402cdf0e10cSrcweir {
403cdf0e10cSrcweir // determine column and row of proposed start position.
404cdf0e10cSrcweir // Note: paint starts at point (0,0)
405cdf0e10cSrcweir sal_uInt16 nColOfProposed =
406cdf0e10cSrcweir static_cast<sal_uInt16>(_aProposedStartPos.X() / mnColWidth) + 1;
407cdf0e10cSrcweir sal_uInt16 nRowOfProposed =
408cdf0e10cSrcweir static_cast<sal_uInt16>(_aProposedStartPos.Y() / mnRowHeight) + 1;
409cdf0e10cSrcweir // determine start page == page at proposed start position
410cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is
411cdf0e10cSrcweir // controlled by <mbBookPreview>.
412cdf0e10cSrcweir if ( mbBookPreview &&
413cdf0e10cSrcweir ( nRowOfProposed == 1 && nColOfProposed == 1 )
414cdf0e10cSrcweir )
415cdf0e10cSrcweir mnPaintPhyStartPageNum = 1;
416cdf0e10cSrcweir else
417cdf0e10cSrcweir {
418cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is
419cdf0e10cSrcweir // controlled by <mbBookPreview>.
420cdf0e10cSrcweir mnPaintPhyStartPageNum = (nRowOfProposed-1) * mnCols + nColOfProposed;
421cdf0e10cSrcweir if ( mbBookPreview )
422cdf0e10cSrcweir --mnPaintPhyStartPageNum;
423cdf0e10cSrcweir if ( mnPaintPhyStartPageNum > mnPages )
424cdf0e10cSrcweir {
425cdf0e10cSrcweir // no page will be visible, because shown part of document
426cdf0e10cSrcweir // preview is the last row to the right of the last page
427cdf0e10cSrcweir mnPaintPhyStartPageNum = mnPages;
428cdf0e10cSrcweir mbNoPageVisible = true;
429cdf0e10cSrcweir }
430cdf0e10cSrcweir }
431cdf0e10cSrcweir // set starting column and starting row
432cdf0e10cSrcweir mnPaintStartCol = nColOfProposed;
433cdf0e10cSrcweir mnPaintStartRow = nRowOfProposed;
434cdf0e10cSrcweir // page offset
435cdf0e10cSrcweir maPaintStartPageOffset.X() =
436cdf0e10cSrcweir (_aProposedStartPos.X() % mnColWidth) - mnXFree;
437cdf0e10cSrcweir maPaintStartPageOffset.Y() =
438cdf0e10cSrcweir (_aProposedStartPos.Y() % mnRowHeight) - mnYFree;
439cdf0e10cSrcweir // virtual preview document offset.
440cdf0e10cSrcweir maPaintPreviewDocOffset = _aProposedStartPos;
441cdf0e10cSrcweir }
442cdf0e10cSrcweir
443cdf0e10cSrcweir // determine additional paint offset, if preview layout fits into window.
444cdf0e10cSrcweir _CalcAdditionalPaintOffset();
445cdf0e10cSrcweir
446cdf0e10cSrcweir // determine rectangle to be painted from document preview
447cdf0e10cSrcweir _CalcDocPrevwPaintRect();
448cdf0e10cSrcweir _orDocPreviewPaintRect = maPaintedPrevwDocRect;
449cdf0e10cSrcweir
450cdf0e10cSrcweir // OD 20.01.2003 #103492# - shift visible preview document area to the left,
451cdf0e10cSrcweir // if on the right is an area left blank.
452cdf0e10cSrcweir if ( !mbDoesLayoutColsFitIntoWindow &&
453cdf0e10cSrcweir maPaintedPrevwDocRect.GetWidth() < maWinSize.Width() )
454cdf0e10cSrcweir {
455cdf0e10cSrcweir maPaintedPrevwDocRect.Move(
456cdf0e10cSrcweir -(maWinSize.Width() - maPaintedPrevwDocRect.GetWidth()), 0 );
457cdf0e10cSrcweir Prepare( 0, maPaintedPrevwDocRect.TopLeft(),
458cdf0e10cSrcweir _rPxWinSize, _onStartPageNum,
459cdf0e10cSrcweir _orDocPreviewPaintRect, _bStartWithPageAtFirstCol );
460cdf0e10cSrcweir }
461cdf0e10cSrcweir
462cdf0e10cSrcweir // OD 20.01.2003 #103492# - shift visible preview document area to the top,
46360d78278Smseidel // if at the bottom is an area left blank.
464cdf0e10cSrcweir if ( mbBookPreviewModeToggled &&
465cdf0e10cSrcweir maPaintedPrevwDocRect.Bottom() == maPreviewDocRect.Bottom() &&
466cdf0e10cSrcweir maPaintedPrevwDocRect.GetHeight() < maWinSize.Height() )
467cdf0e10cSrcweir {
468cdf0e10cSrcweir if ( mbDoesLayoutRowsFitIntoWindow )
469cdf0e10cSrcweir {
470cdf0e10cSrcweir if ( maPaintedPrevwDocRect.GetHeight() < mnPrevwLayoutHeight)
471cdf0e10cSrcweir {
472cdf0e10cSrcweir maPaintedPrevwDocRect.Move(
473cdf0e10cSrcweir 0, -(mnPrevwLayoutHeight - maPaintedPrevwDocRect.GetHeight()) );
474cdf0e10cSrcweir Prepare( 0, maPaintedPrevwDocRect.TopLeft(),
475cdf0e10cSrcweir _rPxWinSize, _onStartPageNum,
476cdf0e10cSrcweir _orDocPreviewPaintRect, _bStartWithPageAtFirstCol );
477cdf0e10cSrcweir }
478cdf0e10cSrcweir }
479cdf0e10cSrcweir else
480cdf0e10cSrcweir {
481cdf0e10cSrcweir maPaintedPrevwDocRect.Move(
482cdf0e10cSrcweir 0, -(maWinSize.Height() - maPaintedPrevwDocRect.GetHeight()) );
483cdf0e10cSrcweir Prepare( 0, maPaintedPrevwDocRect.TopLeft(),
484cdf0e10cSrcweir _rPxWinSize, _onStartPageNum,
485cdf0e10cSrcweir _orDocPreviewPaintRect, _bStartWithPageAtFirstCol );
486cdf0e10cSrcweir }
487cdf0e10cSrcweir }
488cdf0e10cSrcweir
489cdf0e10cSrcweir // determine preview pages - visible pages with needed data for paint and
490cdf0e10cSrcweir // accessible pages with needed data.
491cdf0e10cSrcweir _CalcPreviewPages();
492cdf0e10cSrcweir
493cdf0e10cSrcweir // OD 07.11.2003 #i22014# - indicate new layout, if print preview is in paint
494cdf0e10cSrcweir if ( mbInPaint )
495cdf0e10cSrcweir {
496cdf0e10cSrcweir mbNewLayoutDuringPaint = true;
497cdf0e10cSrcweir }
498cdf0e10cSrcweir
499cdf0e10cSrcweir // validate paint data
500cdf0e10cSrcweir mbPaintInfoValid = true;
501cdf0e10cSrcweir
502cdf0e10cSrcweir // return start page
503cdf0e10cSrcweir _onStartPageNum = mnPaintPhyStartPageNum;
504cdf0e10cSrcweir
505cdf0e10cSrcweir return true;
506cdf0e10cSrcweir }
507cdf0e10cSrcweir
508cdf0e10cSrcweir /** calculate additional paint offset
509cdf0e10cSrcweir
510cdf0e10cSrcweir OD 12.12.2002 #103492#
511cdf0e10cSrcweir
512cdf0e10cSrcweir @author OD
513cdf0e10cSrcweir */
_CalcAdditionalPaintOffset()514cdf0e10cSrcweir void SwPagePreviewLayout::_CalcAdditionalPaintOffset()
515cdf0e10cSrcweir {
516cdf0e10cSrcweir if ( mnPrevwLayoutWidth <= maWinSize.Width() &&
517cdf0e10cSrcweir maPaintStartPageOffset.X() <= 0 )
518cdf0e10cSrcweir {
519cdf0e10cSrcweir mbDoesLayoutColsFitIntoWindow = true;
520cdf0e10cSrcweir maAdditionalPaintOffset.X() = (maWinSize.Width() - mnPrevwLayoutWidth) / 2;
521cdf0e10cSrcweir }
522cdf0e10cSrcweir else
523cdf0e10cSrcweir {
524cdf0e10cSrcweir mbDoesLayoutColsFitIntoWindow = false;
525cdf0e10cSrcweir maAdditionalPaintOffset.X() = 0;
526cdf0e10cSrcweir }
527cdf0e10cSrcweir
528cdf0e10cSrcweir if ( mnPrevwLayoutHeight <= maWinSize.Height() &&
529cdf0e10cSrcweir maPaintStartPageOffset.Y() <= 0 )
530cdf0e10cSrcweir {
531cdf0e10cSrcweir mbDoesLayoutRowsFitIntoWindow = true;
532cdf0e10cSrcweir maAdditionalPaintOffset.Y() = (maWinSize.Height() - mnPrevwLayoutHeight) / 2;
533cdf0e10cSrcweir }
534cdf0e10cSrcweir else
535cdf0e10cSrcweir {
536cdf0e10cSrcweir mbDoesLayoutRowsFitIntoWindow = false;
537cdf0e10cSrcweir maAdditionalPaintOffset.Y() = 0;
538cdf0e10cSrcweir }
539cdf0e10cSrcweir }
540cdf0e10cSrcweir
541cdf0e10cSrcweir /** calculate painted preview document rectangle
542cdf0e10cSrcweir
543cdf0e10cSrcweir OD 12.12.2002 #103492#
544cdf0e10cSrcweir
545cdf0e10cSrcweir @author OD
546cdf0e10cSrcweir */
_CalcDocPrevwPaintRect()547cdf0e10cSrcweir void SwPagePreviewLayout::_CalcDocPrevwPaintRect()
548cdf0e10cSrcweir {
549cdf0e10cSrcweir Point aTopLeftPos = maPaintPreviewDocOffset;
550cdf0e10cSrcweir maPaintedPrevwDocRect.SetPos( aTopLeftPos );
551cdf0e10cSrcweir
552cdf0e10cSrcweir Size aSize;
553cdf0e10cSrcweir if ( mbDoesLayoutColsFitIntoWindow )
554cdf0e10cSrcweir //aSize.Width() = mnPrevwLayoutWidth;
555cdf0e10cSrcweir aSize.Width() = Min( mnPrevwLayoutWidth,
556cdf0e10cSrcweir maPreviewDocRect.GetWidth() - aTopLeftPos.X() );
557cdf0e10cSrcweir else
558cdf0e10cSrcweir aSize.Width() = Min( maPreviewDocRect.GetWidth() - aTopLeftPos.X(),
559cdf0e10cSrcweir maWinSize.Width() - maAdditionalPaintOffset.X() );
560cdf0e10cSrcweir if ( mbDoesLayoutRowsFitIntoWindow )
561cdf0e10cSrcweir //aSize.Height() = mnPrevwLayoutHeight;
562cdf0e10cSrcweir aSize.Height() = Min( mnPrevwLayoutHeight,
563cdf0e10cSrcweir maPreviewDocRect.GetHeight() - aTopLeftPos.Y() );
564cdf0e10cSrcweir else
565cdf0e10cSrcweir aSize.Height() = Min( maPreviewDocRect.GetHeight() - aTopLeftPos.Y(),
566cdf0e10cSrcweir maWinSize.Height() - maAdditionalPaintOffset.Y() );
567cdf0e10cSrcweir maPaintedPrevwDocRect.SetSize( aSize );
568cdf0e10cSrcweir }
569cdf0e10cSrcweir
570cdf0e10cSrcweir /** calculate preview pages
571cdf0e10cSrcweir
572cdf0e10cSrcweir OD 12.12.2002 #103492#
573cdf0e10cSrcweir
574cdf0e10cSrcweir @author OD
575cdf0e10cSrcweir */
_CalcPreviewPages()576cdf0e10cSrcweir void SwPagePreviewLayout::_CalcPreviewPages()
577cdf0e10cSrcweir {
578cdf0e10cSrcweir _ClearPrevwPageData();
579cdf0e10cSrcweir
580cdf0e10cSrcweir if ( mbNoPageVisible )
581cdf0e10cSrcweir return;
582cdf0e10cSrcweir
583cdf0e10cSrcweir // determine start page frame
584cdf0e10cSrcweir const SwPageFrm* pStartPage = mrLayoutRootFrm.GetPageByPageNum( mnPaintPhyStartPageNum );
585cdf0e10cSrcweir
586cdf0e10cSrcweir // calculate initial paint offset
587cdf0e10cSrcweir Point aInitialPaintOffset;
588cdf0e10cSrcweir if ( maPaintStartPageOffset != Point( -1, -1 ) )
589cdf0e10cSrcweir aInitialPaintOffset = Point(0,0) - maPaintStartPageOffset;
590cdf0e10cSrcweir else
591cdf0e10cSrcweir aInitialPaintOffset = Point( mnXFree, mnYFree );
592cdf0e10cSrcweir aInitialPaintOffset += maAdditionalPaintOffset;
593cdf0e10cSrcweir
594cdf0e10cSrcweir // prepare loop data
595cdf0e10cSrcweir const SwPageFrm* pPage = pStartPage;
596cdf0e10cSrcweir sal_uInt16 nCurrCol = mnPaintStartCol;
597cdf0e10cSrcweir sal_uInt16 nConsideredRows = 0;
598cdf0e10cSrcweir Point aCurrPaintOffset = aInitialPaintOffset;
59960d78278Smseidel // loop on pages to determine preview background rectangles
600cdf0e10cSrcweir while ( pPage &&
601cdf0e10cSrcweir (!mbDoesLayoutRowsFitIntoWindow || nConsideredRows < mnRows) &&
602cdf0e10cSrcweir aCurrPaintOffset.Y() < maWinSize.Height()
603cdf0e10cSrcweir )
604cdf0e10cSrcweir {
605cdf0e10cSrcweir if ( !mbBookPreview && !mbPrintEmptyPages && pPage->IsEmptyPage() )
606cdf0e10cSrcweir {
607cdf0e10cSrcweir pPage = static_cast<const SwPageFrm*>(pPage->GetNext());
608cdf0e10cSrcweir continue;
609cdf0e10cSrcweir }
610cdf0e10cSrcweir
611cdf0e10cSrcweir pPage->Calc();
612cdf0e10cSrcweir
613cdf0e10cSrcweir // consider only pages, which have to be painted.
614cdf0e10cSrcweir if ( nCurrCol < mnPaintStartCol )
615cdf0e10cSrcweir {
61660d78278Smseidel // calculate data of invisible page needed for accessibility
617cdf0e10cSrcweir PrevwPage* pPrevwPage = new PrevwPage;
618cdf0e10cSrcweir Point aCurrAccOffset = aCurrPaintOffset -
619cdf0e10cSrcweir Point( (mnPaintStartCol-nCurrCol) * mnColWidth, 0 );
620cdf0e10cSrcweir _CalcPreviewDataForPage( *(pPage), aCurrAccOffset, pPrevwPage );
621cdf0e10cSrcweir pPrevwPage->bVisible = false;
622cdf0e10cSrcweir maPrevwPages.push_back( pPrevwPage );
623cdf0e10cSrcweir // continue with next page and next column
624cdf0e10cSrcweir pPage = static_cast<const SwPageFrm*>(pPage->GetNext());
625cdf0e10cSrcweir ++nCurrCol;
626cdf0e10cSrcweir continue;
627cdf0e10cSrcweir }
628cdf0e10cSrcweir if ( aCurrPaintOffset.X() < maWinSize.Width() )
629cdf0e10cSrcweir {
630cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is
631cdf0e10cSrcweir // controlled by <mbBookPreview>.
632cdf0e10cSrcweir if ( mbBookPreview && pPage->GetPhyPageNum() == 1 && mnCols != 1 && nCurrCol == 1
633cdf0e10cSrcweir )
634cdf0e10cSrcweir {
635cdf0e10cSrcweir // first page in 2nd column
636cdf0e10cSrcweir // --> continue with increased paint offset and next column
637cdf0e10cSrcweir aCurrPaintOffset.X() += mnColWidth;
638cdf0e10cSrcweir ++nCurrCol;
639cdf0e10cSrcweir continue;
640cdf0e10cSrcweir }
641cdf0e10cSrcweir
642cdf0e10cSrcweir // calculate data of visible page
643cdf0e10cSrcweir PrevwPage* pPrevwPage = new PrevwPage;
644cdf0e10cSrcweir _CalcPreviewDataForPage( *(pPage), aCurrPaintOffset, pPrevwPage );
645cdf0e10cSrcweir pPrevwPage->bVisible = true;
646cdf0e10cSrcweir maPrevwPages.push_back( pPrevwPage );
647cdf0e10cSrcweir }
648cdf0e10cSrcweir else
649cdf0e10cSrcweir {
65060d78278Smseidel // calculate data of invisible page needed for accessibility
651cdf0e10cSrcweir PrevwPage* pPrevwPage = new PrevwPage;
652cdf0e10cSrcweir _CalcPreviewDataForPage( *(pPage), aCurrPaintOffset, pPrevwPage );
653cdf0e10cSrcweir pPrevwPage->bVisible = false;
654cdf0e10cSrcweir maPrevwPages.push_back( pPrevwPage );
655cdf0e10cSrcweir }
656cdf0e10cSrcweir
657cdf0e10cSrcweir // prepare data for next loop
658cdf0e10cSrcweir pPage = static_cast<const SwPageFrm*>(pPage->GetNext());
659cdf0e10cSrcweir
660cdf0e10cSrcweir aCurrPaintOffset.X() += mnColWidth;
661cdf0e10cSrcweir ++nCurrCol;
662cdf0e10cSrcweir if ( nCurrCol > mnCols )
663cdf0e10cSrcweir {
664cdf0e10cSrcweir ++nConsideredRows;
665cdf0e10cSrcweir aCurrPaintOffset.X() = aInitialPaintOffset.X();
666cdf0e10cSrcweir nCurrCol = 1;
667cdf0e10cSrcweir aCurrPaintOffset.Y() += mnRowHeight;
668cdf0e10cSrcweir }
669cdf0e10cSrcweir }
670cdf0e10cSrcweir }
671cdf0e10cSrcweir
672cdf0e10cSrcweir /** determines preview data for a given page and a given preview offset
673cdf0e10cSrcweir
674cdf0e10cSrcweir OD 13.12.2002 #103492#
675cdf0e10cSrcweir
676cdf0e10cSrcweir @author OD
677cdf0e10cSrcweir */
_CalcPreviewDataForPage(const SwPageFrm & _rPage,const Point & _rPrevwOffset,PrevwPage * _opPrevwPage)678cdf0e10cSrcweir bool SwPagePreviewLayout::_CalcPreviewDataForPage( const SwPageFrm& _rPage,
679cdf0e10cSrcweir const Point& _rPrevwOffset,
680cdf0e10cSrcweir PrevwPage* _opPrevwPage )
681cdf0e10cSrcweir {
682cdf0e10cSrcweir // page frame
683cdf0e10cSrcweir _opPrevwPage->pPage = &_rPage;
684cdf0e10cSrcweir // size of page frame
685cdf0e10cSrcweir if ( _rPage.IsEmptyPage() )
686cdf0e10cSrcweir {
687cdf0e10cSrcweir if ( _rPage.GetPhyPageNum() % 2 == 0 )
688cdf0e10cSrcweir _opPrevwPage->aPageSize = _rPage.GetPrev()->Frm().SSize();
689cdf0e10cSrcweir else
690cdf0e10cSrcweir _opPrevwPage->aPageSize = _rPage.GetNext()->Frm().SSize();
691cdf0e10cSrcweir }
692cdf0e10cSrcweir else
693cdf0e10cSrcweir _opPrevwPage->aPageSize = _rPage.Frm().SSize();
694cdf0e10cSrcweir // position of page in preview window
695cdf0e10cSrcweir Point aPrevwWinOffset( _rPrevwOffset );
696cdf0e10cSrcweir if ( _opPrevwPage->aPageSize.Width() < maMaxPageSize.Width() )
697cdf0e10cSrcweir aPrevwWinOffset.X() += ( maMaxPageSize.Width() - _opPrevwPage->aPageSize.Width() ) / 2;
698cdf0e10cSrcweir if ( _opPrevwPage->aPageSize.Height() < maMaxPageSize.Height() )
699cdf0e10cSrcweir aPrevwWinOffset.Y() += ( maMaxPageSize.Height() - _opPrevwPage->aPageSize.Height() ) / 2;
700cdf0e10cSrcweir _opPrevwPage->aPrevwWinPos = aPrevwWinOffset;
701cdf0e10cSrcweir // logic position of page and mapping offset for paint
702cdf0e10cSrcweir if ( _rPage.IsEmptyPage() )
703cdf0e10cSrcweir {
704cdf0e10cSrcweir _opPrevwPage->aLogicPos = _opPrevwPage->aPrevwWinPos;
705cdf0e10cSrcweir _opPrevwPage->aMapOffset = Point( 0, 0 );
706cdf0e10cSrcweir }
707cdf0e10cSrcweir else
708cdf0e10cSrcweir {
709cdf0e10cSrcweir _opPrevwPage->aLogicPos = _rPage.Frm().Pos();
710cdf0e10cSrcweir _opPrevwPage->aMapOffset = _opPrevwPage->aPrevwWinPos - _opPrevwPage->aLogicPos;
711cdf0e10cSrcweir }
712cdf0e10cSrcweir
713cdf0e10cSrcweir return true;
714cdf0e10cSrcweir }
715cdf0e10cSrcweir
716cdf0e10cSrcweir /** enable/disable book preview
717cdf0e10cSrcweir
718cdf0e10cSrcweir OD 2004-03-04 #i18143#
719cdf0e10cSrcweir
720cdf0e10cSrcweir @author OD
721cdf0e10cSrcweir */
SetBookPreviewMode(const bool _bEnableBookPreview,sal_uInt16 & _onStartPageNum,Rectangle & _orDocPreviewPaintRect)722cdf0e10cSrcweir bool SwPagePreviewLayout::SetBookPreviewMode( const bool _bEnableBookPreview,
723cdf0e10cSrcweir sal_uInt16& _onStartPageNum,
724cdf0e10cSrcweir Rectangle& _orDocPreviewPaintRect )
725cdf0e10cSrcweir {
726cdf0e10cSrcweir bool bRet = false;
727cdf0e10cSrcweir
728cdf0e10cSrcweir if ( mbBookPreview != _bEnableBookPreview)
729cdf0e10cSrcweir {
730cdf0e10cSrcweir mbBookPreview = _bEnableBookPreview;
731cdf0e10cSrcweir // re-initialize page preview layout
732cdf0e10cSrcweir ReInit();
733cdf0e10cSrcweir // re-prepare page preview layout
734cdf0e10cSrcweir {
735cdf0e10cSrcweir mbBookPreviewModeToggled = true;
736cdf0e10cSrcweir Point aProposedStartPos( maPaintPreviewDocOffset );
737cdf0e10cSrcweir // if proposed start position is below virtual preview document
738cdf0e10cSrcweir // bottom, adjust it to the virtual preview document bottom
739cdf0e10cSrcweir if ( aProposedStartPos.Y() > maPreviewDocRect.Bottom() )
740cdf0e10cSrcweir {
741cdf0e10cSrcweir aProposedStartPos.Y() = maPreviewDocRect.Bottom();
742cdf0e10cSrcweir }
743cdf0e10cSrcweir Prepare( 0, aProposedStartPos,
744cdf0e10cSrcweir mrParentViewShell.GetOut()->LogicToPixel( maWinSize ),
745cdf0e10cSrcweir _onStartPageNum, _orDocPreviewPaintRect );
746cdf0e10cSrcweir mbBookPreviewModeToggled = false;
747cdf0e10cSrcweir }
748cdf0e10cSrcweir
749cdf0e10cSrcweir bRet = true;
750cdf0e10cSrcweir }
751cdf0e10cSrcweir
752cdf0e10cSrcweir return bRet;
753cdf0e10cSrcweir }
754cdf0e10cSrcweir
755cdf0e10cSrcweir // =============================================================================
756cdf0e10cSrcweir // methods to determine new data for changing the current shown part of the
757cdf0e10cSrcweir // document preview.
758cdf0e10cSrcweir // =============================================================================
759cdf0e10cSrcweir /** calculate start position for new scale
760cdf0e10cSrcweir
761cdf0e10cSrcweir OD 12.12.2002 #103492#
762cdf0e10cSrcweir
763cdf0e10cSrcweir @author OD
764cdf0e10cSrcweir */
GetPreviewStartPosForNewScale(const Fraction & _aNewScale,const Fraction & _aOldScale,const Size & _aNewWinSize) const765cdf0e10cSrcweir Point SwPagePreviewLayout::GetPreviewStartPosForNewScale(
766cdf0e10cSrcweir const Fraction& _aNewScale,
767cdf0e10cSrcweir const Fraction& _aOldScale,
768cdf0e10cSrcweir const Size& _aNewWinSize ) const
769cdf0e10cSrcweir {
770cdf0e10cSrcweir Point aNewPaintStartPos = maPaintedPrevwDocRect.TopLeft();
771cdf0e10cSrcweir if ( _aNewScale < _aOldScale )
772cdf0e10cSrcweir {
773cdf0e10cSrcweir // increase paint width by moving start point to left.
774cdf0e10cSrcweir if ( mnPrevwLayoutWidth < _aNewWinSize.Width() )
775cdf0e10cSrcweir aNewPaintStartPos.X() = 0;
776cdf0e10cSrcweir else if ( maPaintedPrevwDocRect.GetWidth() < _aNewWinSize.Width() )
777cdf0e10cSrcweir {
778cdf0e10cSrcweir aNewPaintStartPos.X() -=
779cdf0e10cSrcweir (_aNewWinSize.Width() - maPaintedPrevwDocRect.GetWidth()) / 2;
780cdf0e10cSrcweir if ( aNewPaintStartPos.X() < 0)
781cdf0e10cSrcweir aNewPaintStartPos.X() = 0;
782cdf0e10cSrcweir }
783cdf0e10cSrcweir
784cdf0e10cSrcweir if ( !mbDoesLayoutRowsFitIntoWindow )
785cdf0e10cSrcweir {
786cdf0e10cSrcweir // increase paint height by moving start point to top.
787cdf0e10cSrcweir if ( mnPrevwLayoutHeight < _aNewWinSize.Height() )
788cdf0e10cSrcweir {
789cdf0e10cSrcweir aNewPaintStartPos.Y() =
790cdf0e10cSrcweir ( (mnPaintStartRow - 1) * mnRowHeight );
791cdf0e10cSrcweir }
792cdf0e10cSrcweir else if ( maPaintedPrevwDocRect.GetHeight() < _aNewWinSize.Height() )
793cdf0e10cSrcweir {
794cdf0e10cSrcweir aNewPaintStartPos.Y() -=
795cdf0e10cSrcweir (_aNewWinSize.Height() - maPaintedPrevwDocRect.GetHeight()) / 2;
796cdf0e10cSrcweir if ( aNewPaintStartPos.Y() < 0)
797cdf0e10cSrcweir aNewPaintStartPos.Y() = 0;
798cdf0e10cSrcweir }
799cdf0e10cSrcweir }
800cdf0e10cSrcweir }
801cdf0e10cSrcweir else
802cdf0e10cSrcweir {
803cdf0e10cSrcweir // decrease paint width by moving start point to right
804cdf0e10cSrcweir if ( maPaintedPrevwDocRect.GetWidth() > _aNewWinSize.Width() )
805cdf0e10cSrcweir aNewPaintStartPos.X() +=
806cdf0e10cSrcweir (maPaintedPrevwDocRect.GetWidth() - _aNewWinSize.Width()) / 2;
807cdf0e10cSrcweir // decrease paint height by moving start point to bottom
808cdf0e10cSrcweir if ( maPaintedPrevwDocRect.GetHeight() > _aNewWinSize.Height() )
809cdf0e10cSrcweir {
810cdf0e10cSrcweir aNewPaintStartPos.Y() +=
811cdf0e10cSrcweir (maPaintedPrevwDocRect.GetHeight() - _aNewWinSize.Height()) / 2;
812cdf0e10cSrcweir // check, if new y-position is outside document preview
813cdf0e10cSrcweir if ( aNewPaintStartPos.Y() > maPreviewDocRect.Bottom() )
814cdf0e10cSrcweir aNewPaintStartPos.Y() =
815cdf0e10cSrcweir Max( 0L, maPreviewDocRect.Bottom() - mnPrevwLayoutHeight );
816cdf0e10cSrcweir }
817cdf0e10cSrcweir }
818cdf0e10cSrcweir
819cdf0e10cSrcweir return aNewPaintStartPos;
820cdf0e10cSrcweir }
821cdf0e10cSrcweir
822cdf0e10cSrcweir /** determines, if page with given page number is visible in preview
823cdf0e10cSrcweir
824cdf0e10cSrcweir OD 12.12.2002 #103492#
825cdf0e10cSrcweir
82660d78278Smseidel @author OD, _nPageNum is absolute!
827cdf0e10cSrcweir */
IsPageVisible(const sal_uInt16 _nPageNum) const828cdf0e10cSrcweir bool SwPagePreviewLayout::IsPageVisible( const sal_uInt16 _nPageNum ) const
829cdf0e10cSrcweir {
830cdf0e10cSrcweir const PrevwPage* pPrevwPage = _GetPrevwPageByPageNum( _nPageNum );
831cdf0e10cSrcweir return pPrevwPage && pPrevwPage->bVisible;
832cdf0e10cSrcweir }
833cdf0e10cSrcweir
834cdf0e10cSrcweir /** calculate data to bring new selected page into view.
835cdf0e10cSrcweir
836cdf0e10cSrcweir OD 12.12.2002 #103492#
837cdf0e10cSrcweir
838cdf0e10cSrcweir @author OD, IN/OUT parameters are absolute page numbers!!!
839cdf0e10cSrcweir */
CalcStartValuesForSelectedPageMove(const sal_Int16 _nHoriMove,const sal_Int16 _nVertMove,sal_uInt16 & _orNewSelectedPage,sal_uInt16 & _orNewStartPage,Point & _orNewStartPos) const840cdf0e10cSrcweir bool SwPagePreviewLayout::CalcStartValuesForSelectedPageMove(
841cdf0e10cSrcweir const sal_Int16 _nHoriMove,
842cdf0e10cSrcweir const sal_Int16 _nVertMove,
843cdf0e10cSrcweir sal_uInt16& _orNewSelectedPage,
844cdf0e10cSrcweir sal_uInt16& _orNewStartPage,
845cdf0e10cSrcweir Point& _orNewStartPos ) const
846cdf0e10cSrcweir {
847cdf0e10cSrcweir // determine position of current selected page
848cdf0e10cSrcweir sal_uInt16 nTmpRelSelPageNum = ConvertAbsoluteToRelativePageNum( mnSelectedPageNum );
849cdf0e10cSrcweir sal_uInt16 nNewRelSelectedPageNum = nTmpRelSelPageNum;
850cdf0e10cSrcweir
851cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is controlled
852cdf0e10cSrcweir // by <mbBookPreview>.
853cdf0e10cSrcweir if ( mbBookPreview )
854cdf0e10cSrcweir {
855cdf0e10cSrcweir // Note: consider that left-top-corner is left blank --> +1
856cdf0e10cSrcweir ++nTmpRelSelPageNum;
857cdf0e10cSrcweir }
858cdf0e10cSrcweir sal_uInt16 nTmpCol = nTmpRelSelPageNum % mnCols;
859cdf0e10cSrcweir sal_uInt16 nCurrRow = nTmpRelSelPageNum / mnCols;
860cdf0e10cSrcweir if ( nTmpCol > 0 )
861cdf0e10cSrcweir ++nCurrRow;
862cdf0e10cSrcweir
863cdf0e10cSrcweir // determine new selected page number
864cdf0e10cSrcweir {
865cdf0e10cSrcweir if ( _nHoriMove != 0 )
866cdf0e10cSrcweir {
867cdf0e10cSrcweir if ( (nNewRelSelectedPageNum + _nHoriMove) < 1 )
868cdf0e10cSrcweir nNewRelSelectedPageNum = 1;
869cdf0e10cSrcweir else if ( (nNewRelSelectedPageNum + _nHoriMove) > mnPages )
870cdf0e10cSrcweir nNewRelSelectedPageNum = mnPages;
871cdf0e10cSrcweir else
872cdf0e10cSrcweir nNewRelSelectedPageNum = nNewRelSelectedPageNum + _nHoriMove;
873cdf0e10cSrcweir }
874cdf0e10cSrcweir if ( _nVertMove != 0 )
875cdf0e10cSrcweir {
876cdf0e10cSrcweir if ( (nNewRelSelectedPageNum + (_nVertMove * mnCols)) < 1 )
877cdf0e10cSrcweir nNewRelSelectedPageNum = 1;
878cdf0e10cSrcweir else if ( (nNewRelSelectedPageNum + (_nVertMove * mnCols)) > mnPages )
879cdf0e10cSrcweir nNewRelSelectedPageNum = mnPages;
880cdf0e10cSrcweir else
881cdf0e10cSrcweir nNewRelSelectedPageNum += ( _nVertMove * mnCols );
882cdf0e10cSrcweir }
883cdf0e10cSrcweir }
884cdf0e10cSrcweir
885cdf0e10cSrcweir sal_uInt16 nNewStartPage = mnPaintPhyStartPageNum;
886cdf0e10cSrcweir Point aNewStartPos = Point(0,0);
887cdf0e10cSrcweir
888cdf0e10cSrcweir sal_uInt16 nNewAbsSelectedPageNum = ConvertRelativeToAbsolutePageNum( nNewRelSelectedPageNum );
889cdf0e10cSrcweir if ( !IsPageVisible( nNewAbsSelectedPageNum ) )
890cdf0e10cSrcweir {
891cdf0e10cSrcweir if ( _nHoriMove != 0 && _nVertMove != 0 )
892cdf0e10cSrcweir {
893cdf0e10cSrcweir ASSERT( false, "missing implementation for moving preview selected page horizontal AND vertical");
894cdf0e10cSrcweir return false;
895cdf0e10cSrcweir }
896cdf0e10cSrcweir
897cdf0e10cSrcweir // new selected page has to be brought into view considering current
898cdf0e10cSrcweir // visible preview.
899cdf0e10cSrcweir sal_Int16 nTotalRows = GetRowOfPage( mnPages );
900cdf0e10cSrcweir if ( (_nHoriMove > 0 || _nVertMove > 0) &&
901cdf0e10cSrcweir mbDoesLayoutRowsFitIntoWindow &&
902cdf0e10cSrcweir mbDoesLayoutColsFitIntoWindow && // OD 20.02.2003 #107369# - add condition
903cdf0e10cSrcweir nCurrRow > nTotalRows - mnRows )
904cdf0e10cSrcweir {
905cdf0e10cSrcweir // new proposed start page = left-top-corner of last possible
906cdf0e10cSrcweir // preview page.
907cdf0e10cSrcweir nNewStartPage = (nTotalRows - mnRows) * mnCols + 1;
908cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is controlled
909cdf0e10cSrcweir // by <mbBookPreview>.
910cdf0e10cSrcweir if ( mbBookPreview )
911cdf0e10cSrcweir {
912cdf0e10cSrcweir // Note: decrease new proposed start page number by one,
913cdf0e10cSrcweir // because of blank left-top-corner
914cdf0e10cSrcweir --nNewStartPage;
915cdf0e10cSrcweir }
916cdf0e10cSrcweir nNewStartPage = ConvertRelativeToAbsolutePageNum( nNewStartPage );
917cdf0e10cSrcweir }
918cdf0e10cSrcweir else
919cdf0e10cSrcweir {
920cdf0e10cSrcweir // new proposed start page = new selected page.
921cdf0e10cSrcweir nNewStartPage = ConvertRelativeToAbsolutePageNum( nNewRelSelectedPageNum );
922cdf0e10cSrcweir }
923cdf0e10cSrcweir }
924cdf0e10cSrcweir
925cdf0e10cSrcweir _orNewSelectedPage = nNewAbsSelectedPageNum;
926cdf0e10cSrcweir _orNewStartPage = nNewStartPage;
927cdf0e10cSrcweir _orNewStartPos = aNewStartPos;
928cdf0e10cSrcweir
929cdf0e10cSrcweir return true;
930cdf0e10cSrcweir }
931cdf0e10cSrcweir
932cdf0e10cSrcweir /** checks, if given position is inside a shown document page
933cdf0e10cSrcweir
934cdf0e10cSrcweir OD 17.12.2002 #103492#
935cdf0e10cSrcweir
936cdf0e10cSrcweir @author OD
937cdf0e10cSrcweir */
938cdf0e10cSrcweir struct PrevwPosInsidePagePred
939cdf0e10cSrcweir {
940cdf0e10cSrcweir const Point mnPrevwPos;
PrevwPosInsidePagePredPrevwPosInsidePagePred941cdf0e10cSrcweir PrevwPosInsidePagePred( const Point _nPrevwPos ) : mnPrevwPos( _nPrevwPos ) {};
operator ()PrevwPosInsidePagePred942cdf0e10cSrcweir bool operator() ( const PrevwPage* _pPrevwPage )
943cdf0e10cSrcweir {
944cdf0e10cSrcweir if ( _pPrevwPage->bVisible )
945cdf0e10cSrcweir {
946cdf0e10cSrcweir Rectangle aPrevwPageRect( _pPrevwPage->aPrevwWinPos, _pPrevwPage->aPageSize );
947cdf0e10cSrcweir return aPrevwPageRect.IsInside( mnPrevwPos ) ? true : false;
948cdf0e10cSrcweir }
949cdf0e10cSrcweir else
950cdf0e10cSrcweir return false;
951cdf0e10cSrcweir }
952cdf0e10cSrcweir };
953cdf0e10cSrcweir
IsPrevwPosInDocPrevwPage(const Point _aPrevwPos,Point & _orDocPos,bool & _obPosInEmptyPage,sal_uInt16 & _onPageNum) const954cdf0e10cSrcweir bool SwPagePreviewLayout::IsPrevwPosInDocPrevwPage( const Point _aPrevwPos,
955cdf0e10cSrcweir Point& _orDocPos,
956cdf0e10cSrcweir bool& _obPosInEmptyPage,
957cdf0e10cSrcweir sal_uInt16& _onPageNum ) const
958cdf0e10cSrcweir {
959cdf0e10cSrcweir bool bIsPosInsideDoc;
960cdf0e10cSrcweir
961cdf0e10cSrcweir // initialize variable parameter values.
962cdf0e10cSrcweir _orDocPos.X() = 0;
963cdf0e10cSrcweir _orDocPos.Y() = 0;
964cdf0e10cSrcweir _obPosInEmptyPage = false;
965cdf0e10cSrcweir _onPageNum = 0;
966cdf0e10cSrcweir
967cdf0e10cSrcweir std::vector<PrevwPage*>::const_iterator aFoundPrevwPageIter =
968cdf0e10cSrcweir std::find_if( maPrevwPages.begin(), maPrevwPages.end(),
969cdf0e10cSrcweir PrevwPosInsidePagePred( _aPrevwPos ) );
970cdf0e10cSrcweir
971cdf0e10cSrcweir if ( aFoundPrevwPageIter == maPrevwPages.end() )
972cdf0e10cSrcweir // given preview position outside a document page.
973cdf0e10cSrcweir bIsPosInsideDoc = false;
974cdf0e10cSrcweir else
975cdf0e10cSrcweir {
976cdf0e10cSrcweir _onPageNum = (*aFoundPrevwPageIter)->pPage->GetPhyPageNum();
977cdf0e10cSrcweir if ( (*aFoundPrevwPageIter)->pPage->IsEmptyPage() )
978cdf0e10cSrcweir {
979cdf0e10cSrcweir // given preview position inside an empty page
980cdf0e10cSrcweir bIsPosInsideDoc = false;
981cdf0e10cSrcweir _obPosInEmptyPage = true;
982cdf0e10cSrcweir }
983cdf0e10cSrcweir else
984cdf0e10cSrcweir {
985cdf0e10cSrcweir // given preview position inside a normal page
986cdf0e10cSrcweir bIsPosInsideDoc = true;
987cdf0e10cSrcweir _orDocPos = _aPrevwPos -
988cdf0e10cSrcweir (*aFoundPrevwPageIter)->aPrevwWinPos +
989cdf0e10cSrcweir (*aFoundPrevwPageIter)->aLogicPos;
990cdf0e10cSrcweir }
991cdf0e10cSrcweir }
992cdf0e10cSrcweir
993cdf0e10cSrcweir return bIsPosInsideDoc;
994cdf0e10cSrcweir }
995cdf0e10cSrcweir
996cdf0e10cSrcweir /** determine window page scroll amount
997cdf0e10cSrcweir
998cdf0e10cSrcweir OD 17.12.2002 #103492#
999cdf0e10cSrcweir
1000cdf0e10cSrcweir @author OD
1001cdf0e10cSrcweir */
GetWinPagesScrollAmount(const sal_Int16 _nWinPagesToScroll) const1002cdf0e10cSrcweir SwTwips SwPagePreviewLayout::GetWinPagesScrollAmount(
1003cdf0e10cSrcweir const sal_Int16 _nWinPagesToScroll ) const
1004cdf0e10cSrcweir {
1005cdf0e10cSrcweir SwTwips nScrollAmount;
1006cdf0e10cSrcweir if ( mbDoesLayoutRowsFitIntoWindow )
1007cdf0e10cSrcweir {
1008cdf0e10cSrcweir nScrollAmount = (mnPrevwLayoutHeight - mnYFree) * _nWinPagesToScroll;
1009cdf0e10cSrcweir }
1010cdf0e10cSrcweir else
1011cdf0e10cSrcweir nScrollAmount = _nWinPagesToScroll * maPaintedPrevwDocRect.GetHeight();
1012cdf0e10cSrcweir
1013cdf0e10cSrcweir // OD 19.02.2003 #107369# - check, if preview layout size values are valid.
1014cdf0e10cSrcweir // If not, the checks for an adjustment of the scroll amount aren't useful.
1015cdf0e10cSrcweir if ( mbLayoutSizesValid )
1016cdf0e10cSrcweir {
1017cdf0e10cSrcweir if ( (maPaintedPrevwDocRect.Top() + nScrollAmount) <= 0 )
1018cdf0e10cSrcweir nScrollAmount = -maPaintedPrevwDocRect.Top();
1019cdf0e10cSrcweir
1020cdf0e10cSrcweir // OD 14.02.2003 #107369# - correct scroll amount
1021cdf0e10cSrcweir if ( nScrollAmount > 0 &&
1022cdf0e10cSrcweir maPaintedPrevwDocRect.Bottom() == maPreviewDocRect.Bottom()
1023cdf0e10cSrcweir )
1024cdf0e10cSrcweir {
1025cdf0e10cSrcweir nScrollAmount = 0;
1026cdf0e10cSrcweir }
1027cdf0e10cSrcweir else
1028cdf0e10cSrcweir {
1029cdf0e10cSrcweir while ( (maPaintedPrevwDocRect.Top() + nScrollAmount + mnYFree) >= maPreviewDocRect.GetHeight() )
1030cdf0e10cSrcweir {
1031cdf0e10cSrcweir nScrollAmount -= mnRowHeight;
1032cdf0e10cSrcweir }
1033cdf0e10cSrcweir }
1034cdf0e10cSrcweir }
1035cdf0e10cSrcweir
1036cdf0e10cSrcweir return nScrollAmount;
1037cdf0e10cSrcweir }
1038cdf0e10cSrcweir
1039cdf0e10cSrcweir // =============================================================================
1040cdf0e10cSrcweir // methods to paint page preview layout
1041cdf0e10cSrcweir // =============================================================================
1042cdf0e10cSrcweir /** paint prepared preview
1043cdf0e10cSrcweir
1044cdf0e10cSrcweir OD 12.12.2002 #103492#
1045cdf0e10cSrcweir
1046cdf0e10cSrcweir @author OD
1047cdf0e10cSrcweir */
Paint(const Rectangle _aOutRect) const104860d78278Smseidel bool SwPagePreviewLayout::Paint( const Rectangle _aOutRect ) const
1049cdf0e10cSrcweir {
1050cdf0e10cSrcweir // check environment and parameters
1051cdf0e10cSrcweir {
1052cdf0e10cSrcweir if ( !mrParentViewShell.GetWin() &&
1053cdf0e10cSrcweir !mrParentViewShell.GetOut()->GetConnectMetaFile() )
1054cdf0e10cSrcweir return false;
1055cdf0e10cSrcweir
1056cdf0e10cSrcweir ASSERT( mbPaintInfoValid,
1057cdf0e10cSrcweir "invalid preview settings - no paint of preview" );
1058cdf0e10cSrcweir if ( !mbPaintInfoValid )
1059cdf0e10cSrcweir return false;
1060cdf0e10cSrcweir }
1061cdf0e10cSrcweir
1062cdf0e10cSrcweir // OD 17.11.2003 #i22014# - no paint, if <superfluous> flag is set at layout
1063cdf0e10cSrcweir if ( mrLayoutRootFrm.IsSuperfluous() )
1064cdf0e10cSrcweir {
1065cdf0e10cSrcweir return true;
1066cdf0e10cSrcweir }
1067cdf0e10cSrcweir
1068cdf0e10cSrcweir // environment and parameter ok
1069cdf0e10cSrcweir
1070cdf0e10cSrcweir // OD 07.11.2003 #i22014#
1071cdf0e10cSrcweir if ( mbInPaint )
1072cdf0e10cSrcweir {
1073cdf0e10cSrcweir return false;
1074cdf0e10cSrcweir }
1075cdf0e10cSrcweir mbInPaint = true;
1076cdf0e10cSrcweir
1077cdf0e10cSrcweir OutputDevice* pOutputDev = mrParentViewShell.GetOut();
1078cdf0e10cSrcweir
1079cdf0e10cSrcweir // prepare paint
1080cdf0e10cSrcweir if ( maPrevwPages.size() > 0 )
1081cdf0e10cSrcweir {
1082cdf0e10cSrcweir mrParentViewShell.Imp()->bFirstPageInvalid = sal_False;
1083cdf0e10cSrcweir mrParentViewShell.Imp()->pFirstVisPage =
1084cdf0e10cSrcweir const_cast<SwPageFrm*>(maPrevwPages[0]->pPage);
1085cdf0e10cSrcweir }
1086cdf0e10cSrcweir
1087cdf0e10cSrcweir // paint preview background
1088cdf0e10cSrcweir {
1089cdf0e10cSrcweir SwRegionRects aPreviewBackgrdRegion( _aOutRect );
1090cdf0e10cSrcweir // calculate preview background rectangles
1091cdf0e10cSrcweir for ( std::vector<PrevwPage*>::const_iterator aPageIter = maPrevwPages.begin();
1092cdf0e10cSrcweir aPageIter != maPrevwPages.end();
1093cdf0e10cSrcweir ++aPageIter )
1094cdf0e10cSrcweir {
1095cdf0e10cSrcweir if ( (*aPageIter)->bVisible )
1096cdf0e10cSrcweir {
1097cdf0e10cSrcweir aPreviewBackgrdRegion -=
1098cdf0e10cSrcweir SwRect( (*aPageIter)->aPrevwWinPos, (*aPageIter)->aPageSize );
1099cdf0e10cSrcweir }
1100cdf0e10cSrcweir }
1101cdf0e10cSrcweir // paint preview background rectangles
1102cdf0e10cSrcweir mrParentViewShell._PaintDesktop( aPreviewBackgrdRegion );
1103cdf0e10cSrcweir }
1104cdf0e10cSrcweir
1105cdf0e10cSrcweir // prepare data for paint of pages
1106cdf0e10cSrcweir const Rectangle aPxOutRect( pOutputDev->LogicToPixel( _aOutRect ) );
1107cdf0e10cSrcweir
1108cdf0e10cSrcweir MapMode aMapMode( pOutputDev->GetMapMode() );
1109cdf0e10cSrcweir MapMode aSavedMapMode = aMapMode;
1110cdf0e10cSrcweir
1111cdf0e10cSrcweir const Font& rEmptyPgFont = SwPageFrm::GetEmptyPageFont();
1112cdf0e10cSrcweir
1113cdf0e10cSrcweir for ( std::vector<PrevwPage*>::const_iterator aPageIter = maPrevwPages.begin();
1114cdf0e10cSrcweir aPageIter != maPrevwPages.end();
1115cdf0e10cSrcweir ++aPageIter )
1116cdf0e10cSrcweir {
1117cdf0e10cSrcweir if ( !(*aPageIter)->bVisible )
1118cdf0e10cSrcweir continue;
1119cdf0e10cSrcweir
1120cdf0e10cSrcweir Rectangle aPageRect( (*aPageIter)->aLogicPos, (*aPageIter)->aPageSize );
1121cdf0e10cSrcweir aMapMode.SetOrigin( (*aPageIter)->aMapOffset );
1122cdf0e10cSrcweir pOutputDev->SetMapMode( aMapMode );
1123cdf0e10cSrcweir Rectangle aPxPaintRect = pOutputDev->LogicToPixel( aPageRect );
1124cdf0e10cSrcweir if ( aPxOutRect.IsOver( aPxPaintRect) )
1125cdf0e10cSrcweir {
1126cdf0e10cSrcweir if ( (*aPageIter)->pPage->IsEmptyPage() )
1127cdf0e10cSrcweir {
1128cdf0e10cSrcweir const Color aRetouche( mrParentViewShell.Imp()->GetRetoucheColor() );
1129cdf0e10cSrcweir if( pOutputDev->GetFillColor() != aRetouche )
1130cdf0e10cSrcweir pOutputDev->SetFillColor( aRetouche );
1131cdf0e10cSrcweir pOutputDev->SetLineColor(); // OD 20.02.2003 #107369# - no line color
1132cdf0e10cSrcweir // OD 20.02.2003 #107369# - use aligned page rectangle
1133cdf0e10cSrcweir {
1134cdf0e10cSrcweir SwRect aTmpPageRect( aPageRect );
1135cdf0e10cSrcweir ::SwAlignRect( aTmpPageRect, &mrParentViewShell);
1136cdf0e10cSrcweir aPageRect = aTmpPageRect.SVRect();
1137cdf0e10cSrcweir }
1138cdf0e10cSrcweir pOutputDev->DrawRect( aPageRect );
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir // paint empty page text
1141cdf0e10cSrcweir Font aOldFont( pOutputDev->GetFont() );
1142cdf0e10cSrcweir pOutputDev->SetFont( rEmptyPgFont );
1143cdf0e10cSrcweir pOutputDev->DrawText( aPageRect, SW_RESSTR( STR_EMPTYPAGE ),
1144cdf0e10cSrcweir TEXT_DRAW_VCENTER |
1145cdf0e10cSrcweir TEXT_DRAW_CENTER |
1146cdf0e10cSrcweir TEXT_DRAW_CLIP );
1147cdf0e10cSrcweir pOutputDev->SetFont( aOldFont );
1148ad095790Smseidel // paint border for empty page (shadow removed now)
1149ad095790Smseidel // OD 19.02.2003 #107369# - use new method to paint page border
1150a4b2faf0Smseidel SwPageFrm::PaintPageBorder( aPageRect, &mrParentViewShell, true );
1151cdf0e10cSrcweir }
1152cdf0e10cSrcweir else
1153cdf0e10cSrcweir {
1154cdf0e10cSrcweir mrParentViewShell.aVisArea = aPageRect;
1155cdf0e10cSrcweir aPxPaintRect.Intersection( aPxOutRect );
1156cdf0e10cSrcweir Rectangle aPaintRect = pOutputDev->PixelToLogic( aPxPaintRect );
1157cdf0e10cSrcweir mrParentViewShell.Paint( aPaintRect );
1158cdf0e10cSrcweir // --> OD 2007-08-15 #i80691#
1159ad095790Smseidel // paint page border (shadow removed now)
1160cdf0e10cSrcweir {
1161cdf0e10cSrcweir SwRect aPageBorderRect;
1162cdf0e10cSrcweir SwPageFrm::GetBorderAndShadowBoundRect( SwRect( aPageRect ), &mrParentViewShell, aPageBorderRect, true );
1163cdf0e10cSrcweir const Region aDLRegion(aPageBorderRect.SVRect());
1164cdf0e10cSrcweir mrParentViewShell.DLPrePaint2(aDLRegion);
1165a4b2faf0Smseidel SwPageFrm::PaintPageBorder( aPageRect, &mrParentViewShell, true );
1166cdf0e10cSrcweir mrParentViewShell.DLPostPaint2(true);
1167cdf0e10cSrcweir }
1168cdf0e10cSrcweir // <--
1169cdf0e10cSrcweir }
1170cdf0e10cSrcweir // OD 07.11.2003 #i22014# - stop painting, because new print
1171cdf0e10cSrcweir // preview layout is created during paint.
1172cdf0e10cSrcweir if ( mbNewLayoutDuringPaint )
1173cdf0e10cSrcweir {
1174cdf0e10cSrcweir break;
1175cdf0e10cSrcweir }
1176cdf0e10cSrcweir
1177cdf0e10cSrcweir if ( (*aPageIter)->pPage->GetPhyPageNum() == mnSelectedPageNum )
1178cdf0e10cSrcweir {
1179cdf0e10cSrcweir _PaintSelectMarkAtPage( (*aPageIter) );
1180cdf0e10cSrcweir }
1181cdf0e10cSrcweir
1182cdf0e10cSrcweir }
1183cdf0e10cSrcweir }
1184cdf0e10cSrcweir
1185cdf0e10cSrcweir // OD 17.11.2003 #i22014# - no update of accessible preview, if a new
1186cdf0e10cSrcweir // print preview layout is created during paint.
1187cdf0e10cSrcweir if ( !mbNewLayoutDuringPaint )
1188cdf0e10cSrcweir {
1189ad095790Smseidel // update at accessibility interface
1190cdf0e10cSrcweir mrParentViewShell.Imp()->UpdateAccessiblePreview(
1191cdf0e10cSrcweir maPrevwPages,
1192cdf0e10cSrcweir aMapMode.GetScaleX(),
1193cdf0e10cSrcweir mrLayoutRootFrm.GetPageByPageNum( mnSelectedPageNum ),
1194cdf0e10cSrcweir maWinSize );
1195cdf0e10cSrcweir }
1196cdf0e10cSrcweir
1197cdf0e10cSrcweir pOutputDev->SetMapMode( aSavedMapMode );
1198cdf0e10cSrcweir mrParentViewShell.aVisArea.Clear();
1199cdf0e10cSrcweir
1200cdf0e10cSrcweir // OD 07.11.2003 #i22014#
1201cdf0e10cSrcweir mbInPaint = false;
1202cdf0e10cSrcweir mbNewLayoutDuringPaint = false;
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir return true;
1205cdf0e10cSrcweir }
1206cdf0e10cSrcweir
1207cdf0e10cSrcweir /** repaint pages on page preview
1208cdf0e10cSrcweir
1209cdf0e10cSrcweir OD 18.12.2002 #103492#
1210cdf0e10cSrcweir
1211cdf0e10cSrcweir @author OD
1212cdf0e10cSrcweir */
Repaint(const Rectangle _aInvalidCoreRect) const1213cdf0e10cSrcweir void SwPagePreviewLayout::Repaint( const Rectangle _aInvalidCoreRect ) const
1214cdf0e10cSrcweir {
1215cdf0e10cSrcweir // check environment and parameters
1216cdf0e10cSrcweir {
1217cdf0e10cSrcweir if ( !mrParentViewShell.GetWin() &&
1218cdf0e10cSrcweir !mrParentViewShell.GetOut()->GetConnectMetaFile() )
1219cdf0e10cSrcweir return;
1220cdf0e10cSrcweir
1221cdf0e10cSrcweir ASSERT( mbPaintInfoValid,
1222cdf0e10cSrcweir "invalid preview settings - no paint of preview" );
1223cdf0e10cSrcweir if ( !mbPaintInfoValid )
1224cdf0e10cSrcweir return;
1225cdf0e10cSrcweir }
1226cdf0e10cSrcweir
1227307b55caSmseidel // environment and parameter OK
1228cdf0e10cSrcweir
1229cdf0e10cSrcweir // prepare paint
1230cdf0e10cSrcweir if ( maPrevwPages.size() > 0 )
1231cdf0e10cSrcweir {
1232cdf0e10cSrcweir mrParentViewShell.Imp()->bFirstPageInvalid = sal_False;
1233cdf0e10cSrcweir mrParentViewShell.Imp()->pFirstVisPage =
1234cdf0e10cSrcweir const_cast<SwPageFrm*>(maPrevwPages[0]->pPage);
1235cdf0e10cSrcweir }
1236cdf0e10cSrcweir
1237cdf0e10cSrcweir // invalidate visible pages, which overlap the invalid core rectangle
1238cdf0e10cSrcweir for ( std::vector<PrevwPage*>::const_iterator aPageIter = maPrevwPages.begin();
1239cdf0e10cSrcweir aPageIter != maPrevwPages.end();
1240cdf0e10cSrcweir ++aPageIter )
1241cdf0e10cSrcweir {
1242cdf0e10cSrcweir if ( !(*aPageIter)->bVisible )
1243cdf0e10cSrcweir continue;
1244cdf0e10cSrcweir
1245cdf0e10cSrcweir Rectangle aPageRect( (*aPageIter)->aLogicPos, (*aPageIter)->aPageSize );
1246cdf0e10cSrcweir if ( _aInvalidCoreRect.IsOver( aPageRect ) )
1247cdf0e10cSrcweir {
1248cdf0e10cSrcweir aPageRect.Intersection( _aInvalidCoreRect );
1249cdf0e10cSrcweir Rectangle aInvalidPrevwRect = aPageRect;
1250cdf0e10cSrcweir aInvalidPrevwRect.SetPos( aInvalidPrevwRect.TopLeft() -
1251cdf0e10cSrcweir (*aPageIter)->aLogicPos +
1252cdf0e10cSrcweir (*aPageIter)->aPrevwWinPos );
1253cdf0e10cSrcweir mrParentViewShell.GetWin()->Invalidate( aInvalidPrevwRect );
1254cdf0e10cSrcweir }
1255cdf0e10cSrcweir }
1256cdf0e10cSrcweir }
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir /** paint selection mark at page
1259cdf0e10cSrcweir
1260cdf0e10cSrcweir OD 17.12.2002 #103492#
1261cdf0e10cSrcweir
1262cdf0e10cSrcweir @author OD
1263cdf0e10cSrcweir */
_PaintSelectMarkAtPage(const PrevwPage * _aSelectedPrevwPage) const1264cdf0e10cSrcweir void SwPagePreviewLayout::_PaintSelectMarkAtPage(
1265cdf0e10cSrcweir const PrevwPage* _aSelectedPrevwPage ) const
1266cdf0e10cSrcweir {
1267cdf0e10cSrcweir OutputDevice* pOutputDev = mrParentViewShell.GetOut();
1268cdf0e10cSrcweir MapMode aMapMode( pOutputDev->GetMapMode() );
1269cdf0e10cSrcweir // save mapping mode of output device
1270cdf0e10cSrcweir MapMode aSavedMapMode = aMapMode;
1271cdf0e10cSrcweir // save fill and line color of output device
1272cdf0e10cSrcweir Color aFill( pOutputDev->GetFillColor() );
1273cdf0e10cSrcweir Color aLine( pOutputDev->GetLineColor() );
1274cdf0e10cSrcweir
1275*89dcfa4eSmseidel // determine selection mark color
1276*89dcfa4eSmseidel const StyleSettings& rSettings = mrParentViewShell.GetWin()->GetSettings().GetStyleSettings();
1277*89dcfa4eSmseidel Color aSelPgLineColor( rSettings.GetHighlightColor() );
1278*89dcfa4eSmseidel if ( rSettings.GetHighContrastMode() )
1279*89dcfa4eSmseidel aSelPgLineColor = rSettings.GetActiveBorderColor();
1280cdf0e10cSrcweir
1281cdf0e10cSrcweir // set needed mapping mode at output device
1282cdf0e10cSrcweir aMapMode.SetOrigin( _aSelectedPrevwPage->aMapOffset );
1283cdf0e10cSrcweir pOutputDev->SetMapMode( aMapMode );
1284cdf0e10cSrcweir
1285cdf0e10cSrcweir // calculate page rectangle in pixel coordinates
1286cdf0e10cSrcweir SwRect aPageRect( _aSelectedPrevwPage->aLogicPos,
1287cdf0e10cSrcweir _aSelectedPrevwPage->aPageSize );
1288cdf0e10cSrcweir // OD 19.02.2003 #107369# - use aligned page rectangle, as it is used for
1289a4b2faf0Smseidel // page border paint - see <SwPageFrm::PaintPageBorder(..)>
1290cdf0e10cSrcweir ::SwAlignRect( aPageRect, &mrParentViewShell);
1291cdf0e10cSrcweir Rectangle aPxPageRect = pOutputDev->LogicToPixel( aPageRect.SVRect() );
1292cdf0e10cSrcweir
1293ad095790Smseidel // draw two rectangles
1294cdf0e10cSrcweir // OD 19.02.2003 #107369# - adjust position of select mark rectangle
1295cdf0e10cSrcweir Rectangle aRect( aPxPageRect.Left(), aPxPageRect.Top(),
1296cdf0e10cSrcweir aPxPageRect.Right(), aPxPageRect.Bottom() );
1297cdf0e10cSrcweir aRect = pOutputDev->PixelToLogic( aRect );
1298cdf0e10cSrcweir pOutputDev->SetFillColor(); // OD 20.02.2003 #107369# - no fill color
1299cdf0e10cSrcweir pOutputDev->SetLineColor( aSelPgLineColor );
1300cdf0e10cSrcweir pOutputDev->DrawRect( aRect );
1301cdf0e10cSrcweir // OD 19.02.2003 #107369# - adjust position of select mark rectangle
1302cdf0e10cSrcweir aRect = Rectangle( aPxPageRect.Left()+1, aPxPageRect.Top()+1,
1303cdf0e10cSrcweir aPxPageRect.Right()-1, aPxPageRect.Bottom()-1 );
1304cdf0e10cSrcweir aRect = pOutputDev->PixelToLogic( aRect );
1305cdf0e10cSrcweir pOutputDev->DrawRect( aRect );
1306cdf0e10cSrcweir
1307cdf0e10cSrcweir // reset fill and line color of output device
1308cdf0e10cSrcweir pOutputDev->SetFillColor( aFill );
1309cdf0e10cSrcweir pOutputDev->SetLineColor( aLine );
1310cdf0e10cSrcweir
1311cdf0e10cSrcweir // reset mapping mode of output device
1312cdf0e10cSrcweir pOutputDev->SetMapMode( aSavedMapMode );
1313cdf0e10cSrcweir }
1314cdf0e10cSrcweir
1315cdf0e10cSrcweir /** paint to mark new selected page
1316cdf0e10cSrcweir
1317cdf0e10cSrcweir OD 17.12.2002 #103492#
1318cdf0e10cSrcweir Perform paint for current selected page in order to unmark it.
1319cdf0e10cSrcweir Set new selected page and perform paint to mark this page.
1320cdf0e10cSrcweir
132160d78278Smseidel @author OD, _nSelectedPage, mnSelectedPage are absolute
1322cdf0e10cSrcweir */
MarkNewSelectedPage(const sal_uInt16 _nSelectedPage)1323cdf0e10cSrcweir void SwPagePreviewLayout::MarkNewSelectedPage( const sal_uInt16 _nSelectedPage )
1324cdf0e10cSrcweir {
1325cdf0e10cSrcweir sal_uInt16 nOldSelectedPageNum = mnSelectedPageNum;
1326cdf0e10cSrcweir mnSelectedPageNum = _nSelectedPage;
1327cdf0e10cSrcweir
132860d78278Smseidel // re-paint for current selected page in order to unmark it.
1329cdf0e10cSrcweir const PrevwPage* pOldSelectedPrevwPage = _GetPrevwPageByPageNum( nOldSelectedPageNum );
1330cdf0e10cSrcweir if ( pOldSelectedPrevwPage && pOldSelectedPrevwPage->bVisible )
1331cdf0e10cSrcweir {
1332cdf0e10cSrcweir // OD 20.02.2003 #107369# - invalidate only areas of selection mark.
1333cdf0e10cSrcweir SwRect aPageRect( pOldSelectedPrevwPage->aPrevwWinPos,
1334cdf0e10cSrcweir pOldSelectedPrevwPage->aPageSize );
1335cdf0e10cSrcweir ::SwAlignRect( aPageRect, &mrParentViewShell);
1336cdf0e10cSrcweir OutputDevice* pOutputDev = mrParentViewShell.GetOut();
1337cdf0e10cSrcweir Rectangle aPxPageRect = pOutputDev->LogicToPixel( aPageRect.SVRect() );
1338cdf0e10cSrcweir // invalidate top mark line
1339cdf0e10cSrcweir Rectangle aInvalPxRect( aPxPageRect.Left(), aPxPageRect.Top(),
1340cdf0e10cSrcweir aPxPageRect.Right(), aPxPageRect.Top()+1 );
1341cdf0e10cSrcweir mrParentViewShell.GetWin()->Invalidate( pOutputDev->PixelToLogic( aInvalPxRect ) );
1342cdf0e10cSrcweir // invalidate right mark line
1343cdf0e10cSrcweir aInvalPxRect = Rectangle( aPxPageRect.Right()-1, aPxPageRect.Top(),
1344cdf0e10cSrcweir aPxPageRect.Right(), aPxPageRect.Bottom() );
1345cdf0e10cSrcweir mrParentViewShell.GetWin()->Invalidate( pOutputDev->PixelToLogic( aInvalPxRect ) );
1346cdf0e10cSrcweir // invalidate bottom mark line
1347cdf0e10cSrcweir aInvalPxRect = Rectangle( aPxPageRect.Left(), aPxPageRect.Bottom()-1,
1348cdf0e10cSrcweir aPxPageRect.Right(), aPxPageRect.Bottom() );
1349cdf0e10cSrcweir mrParentViewShell.GetWin()->Invalidate( pOutputDev->PixelToLogic( aInvalPxRect ) );
1350cdf0e10cSrcweir // invalidate left mark line
1351cdf0e10cSrcweir aInvalPxRect = Rectangle( aPxPageRect.Left(), aPxPageRect.Top(),
1352cdf0e10cSrcweir aPxPageRect.Left()+1, aPxPageRect.Bottom() );
1353cdf0e10cSrcweir mrParentViewShell.GetWin()->Invalidate( pOutputDev->PixelToLogic( aInvalPxRect ) );
1354cdf0e10cSrcweir }
1355cdf0e10cSrcweir
1356cdf0e10cSrcweir // re-paint for new selected page in order to mark it.
1357cdf0e10cSrcweir const PrevwPage* pNewSelectedPrevwPage = _GetPrevwPageByPageNum( _nSelectedPage );
1358cdf0e10cSrcweir if ( pNewSelectedPrevwPage && pNewSelectedPrevwPage->bVisible )
1359cdf0e10cSrcweir _PaintSelectMarkAtPage( pNewSelectedPrevwPage );
1360cdf0e10cSrcweir }
1361cdf0e10cSrcweir
1362cdf0e10cSrcweir
1363cdf0e10cSrcweir // =============================================================================
1364cdf0e10cSrcweir // helper methods
1365cdf0e10cSrcweir // =============================================================================
1366cdf0e10cSrcweir /** get preview page by physical page number
1367cdf0e10cSrcweir
1368cdf0e10cSrcweir OD 17.12.2002 #103492#
1369cdf0e10cSrcweir
1370cdf0e10cSrcweir @author OD
1371cdf0e10cSrcweir */
1372cdf0e10cSrcweir struct EqualsPageNumPred
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir const sal_uInt16 mnPageNum;
EqualsPageNumPredEqualsPageNumPred1375cdf0e10cSrcweir EqualsPageNumPred( const sal_uInt16 _nPageNum ) : mnPageNum( _nPageNum ) {};
operator ()EqualsPageNumPred1376cdf0e10cSrcweir bool operator() ( const PrevwPage* _pPrevwPage )
1377cdf0e10cSrcweir {
1378cdf0e10cSrcweir return _pPrevwPage->pPage->GetPhyPageNum() == mnPageNum;
1379cdf0e10cSrcweir }
1380cdf0e10cSrcweir };
1381cdf0e10cSrcweir
_GetPrevwPageByPageNum(const sal_uInt16 _nPageNum) const1382cdf0e10cSrcweir const PrevwPage* SwPagePreviewLayout::_GetPrevwPageByPageNum( const sal_uInt16 _nPageNum ) const
1383cdf0e10cSrcweir {
1384cdf0e10cSrcweir std::vector<PrevwPage*>::const_iterator aFoundPrevwPageIter =
1385cdf0e10cSrcweir std::find_if( maPrevwPages.begin(), maPrevwPages.end(),
1386cdf0e10cSrcweir EqualsPageNumPred( _nPageNum ) );
1387cdf0e10cSrcweir
1388cdf0e10cSrcweir if ( aFoundPrevwPageIter == maPrevwPages.end() )
1389cdf0e10cSrcweir return 0;
1390cdf0e10cSrcweir else
1391cdf0e10cSrcweir return (*aFoundPrevwPageIter);
1392cdf0e10cSrcweir }
1393cdf0e10cSrcweir
1394cdf0e10cSrcweir /** determine row the page with the given number is in
1395cdf0e10cSrcweir
1396cdf0e10cSrcweir OD 17.01.2003 #103492#
1397cdf0e10cSrcweir
1398cdf0e10cSrcweir @author OD, _nPageNum is relative
1399cdf0e10cSrcweir */
GetRowOfPage(sal_uInt16 _nPageNum) const1400cdf0e10cSrcweir sal_uInt16 SwPagePreviewLayout::GetRowOfPage( sal_uInt16 _nPageNum ) const
1401cdf0e10cSrcweir {
1402cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is controlled
1403cdf0e10cSrcweir // by <mbBookPreview>.
1404cdf0e10cSrcweir if ( mbBookPreview )
1405cdf0e10cSrcweir {
1406cdf0e10cSrcweir // Note: increase given physical page number by one, because left-top-corner
1407cdf0e10cSrcweir // in the preview layout is left blank.
1408cdf0e10cSrcweir ++_nPageNum;
1409cdf0e10cSrcweir }
1410cdf0e10cSrcweir
1411cdf0e10cSrcweir sal_uInt16 nRow = (_nPageNum) / mnCols;
1412cdf0e10cSrcweir if ( ( (_nPageNum) % mnCols ) > 0 )
1413cdf0e10cSrcweir ++nRow;
1414cdf0e10cSrcweir
1415cdf0e10cSrcweir return nRow;
1416cdf0e10cSrcweir }
1417cdf0e10cSrcweir
1418cdf0e10cSrcweir /** determine column the page with the given number is in
1419cdf0e10cSrcweir
1420cdf0e10cSrcweir OD 17.01.2003 #103492#
1421cdf0e10cSrcweir
1422cdf0e10cSrcweir @author OD, _nPageNum is relative
1423cdf0e10cSrcweir */
GetColOfPage(sal_uInt16 _nPageNum) const1424cdf0e10cSrcweir sal_uInt16 SwPagePreviewLayout::GetColOfPage( sal_uInt16 _nPageNum ) const
1425cdf0e10cSrcweir {
1426cdf0e10cSrcweir // OD 19.02.2003 #107369# - leaving left-top-corner blank is controlled
1427cdf0e10cSrcweir // by <mbBookPreview>.
1428cdf0e10cSrcweir if ( mbBookPreview )
1429cdf0e10cSrcweir {
1430cdf0e10cSrcweir // Note: increase given physical page number by one, because left-top-corner
1431cdf0e10cSrcweir // in the preview layout is left blank.
1432cdf0e10cSrcweir ++_nPageNum;
1433cdf0e10cSrcweir }
1434cdf0e10cSrcweir
1435cdf0e10cSrcweir sal_uInt16 nCol = (_nPageNum) % mnCols;
1436cdf0e10cSrcweir if ( nCol == 0 )
1437cdf0e10cSrcweir nCol = mnCols;
1438cdf0e10cSrcweir
1439cdf0e10cSrcweir return nCol;
1440cdf0e10cSrcweir }
1441cdf0e10cSrcweir
GetPrevwDocSize() const1442cdf0e10cSrcweir Size SwPagePreviewLayout::GetPrevwDocSize() const
1443cdf0e10cSrcweir {
1444cdf0e10cSrcweir ASSERT( PreviewLayoutValid(), "PagePreviewLayout not valid" );
1445cdf0e10cSrcweir return maPreviewDocRect.GetSize();
1446cdf0e10cSrcweir }
1447cdf0e10cSrcweir
1448cdf0e10cSrcweir /** get size of a preview page by its physical page number
1449cdf0e10cSrcweir
1450cdf0e10cSrcweir OD 15.01.2003 #103492#
1451cdf0e10cSrcweir
1452cdf0e10cSrcweir @author OD
1453cdf0e10cSrcweir */
GetPrevwPageSizeByPageNum(sal_uInt16 _nPageNum) const1454cdf0e10cSrcweir Size SwPagePreviewLayout::GetPrevwPageSizeByPageNum( sal_uInt16 _nPageNum ) const
1455cdf0e10cSrcweir {
1456cdf0e10cSrcweir const PrevwPage* pPrevwPage = _GetPrevwPageByPageNum( _nPageNum );
1457cdf0e10cSrcweir if ( pPrevwPage )
1458cdf0e10cSrcweir {
1459cdf0e10cSrcweir return pPrevwPage->aPageSize;
1460cdf0e10cSrcweir }
1461cdf0e10cSrcweir else
1462cdf0e10cSrcweir {
1463cdf0e10cSrcweir return Size( 0, 0 );
1464cdf0e10cSrcweir }
1465cdf0e10cSrcweir }
1466cdf0e10cSrcweir
1467cdf0e10cSrcweir /** get virtual page number by its physical page number
1468cdf0e10cSrcweir
1469cdf0e10cSrcweir OD 21.03.2003 #108282#
1470cdf0e10cSrcweir
1471cdf0e10cSrcweir @author OD
1472cdf0e10cSrcweir */
GetVirtPageNumByPageNum(sal_uInt16 _nPageNum) const1473cdf0e10cSrcweir sal_uInt16 SwPagePreviewLayout::GetVirtPageNumByPageNum( sal_uInt16 _nPageNum ) const
1474cdf0e10cSrcweir {
1475cdf0e10cSrcweir const PrevwPage* pPrevwPage = _GetPrevwPageByPageNum( _nPageNum );
1476cdf0e10cSrcweir if ( pPrevwPage )
1477cdf0e10cSrcweir {
1478cdf0e10cSrcweir return pPrevwPage->pPage->GetVirtPageNum();
1479cdf0e10cSrcweir }
1480cdf0e10cSrcweir else
1481cdf0e10cSrcweir {
1482cdf0e10cSrcweir return 0;
1483cdf0e10cSrcweir }
1484cdf0e10cSrcweir }
1485cdf0e10cSrcweir
1486cdf0e10cSrcweir /** Convert absolute to relative page numbers (see PrintEmptyPages)
1487cdf0e10cSrcweir
1488cdf0e10cSrcweir @author FME
1489cdf0e10cSrcweir */
ConvertAbsoluteToRelativePageNum(sal_uInt16 _nAbsPageNum) const1490cdf0e10cSrcweir sal_uInt16 SwPagePreviewLayout::ConvertAbsoluteToRelativePageNum( sal_uInt16 _nAbsPageNum ) const
1491cdf0e10cSrcweir {
1492cdf0e10cSrcweir if ( mbBookPreview || mbPrintEmptyPages || !_nAbsPageNum )
1493cdf0e10cSrcweir {
1494cdf0e10cSrcweir return _nAbsPageNum;
1495cdf0e10cSrcweir }
1496cdf0e10cSrcweir
1497cdf0e10cSrcweir const SwPageFrm* pTmpPage = static_cast<const SwPageFrm*>(mrLayoutRootFrm.Lower());
1498cdf0e10cSrcweir
1499cdf0e10cSrcweir sal_uInt16 nRet = 1;
1500cdf0e10cSrcweir
1501cdf0e10cSrcweir while ( pTmpPage && pTmpPage->GetPhyPageNum() != _nAbsPageNum )
1502cdf0e10cSrcweir {
1503cdf0e10cSrcweir if ( !pTmpPage->IsEmptyPage() )
1504cdf0e10cSrcweir ++nRet;
1505cdf0e10cSrcweir
1506cdf0e10cSrcweir pTmpPage = static_cast<const SwPageFrm*>( pTmpPage->GetNext() );
1507cdf0e10cSrcweir }
1508cdf0e10cSrcweir
1509cdf0e10cSrcweir return nRet;
1510cdf0e10cSrcweir }
1511cdf0e10cSrcweir
1512cdf0e10cSrcweir /** Convert relative to absolute page numbers (see PrintEmptyPages)
1513cdf0e10cSrcweir
1514cdf0e10cSrcweir @author FME
1515cdf0e10cSrcweir */
ConvertRelativeToAbsolutePageNum(sal_uInt16 _nRelPageNum) const1516cdf0e10cSrcweir sal_uInt16 SwPagePreviewLayout::ConvertRelativeToAbsolutePageNum( sal_uInt16 _nRelPageNum ) const
1517cdf0e10cSrcweir {
1518cdf0e10cSrcweir if ( mbBookPreview || mbPrintEmptyPages || !_nRelPageNum )
1519cdf0e10cSrcweir {
1520cdf0e10cSrcweir return _nRelPageNum;
1521cdf0e10cSrcweir }
1522cdf0e10cSrcweir
1523cdf0e10cSrcweir const SwPageFrm* pTmpPage = static_cast<const SwPageFrm*>(mrLayoutRootFrm.Lower());
1524cdf0e10cSrcweir const SwPageFrm* pRet = 0;
1525cdf0e10cSrcweir
1526cdf0e10cSrcweir sal_uInt16 i = 0;
1527cdf0e10cSrcweir while( pTmpPage && i != _nRelPageNum )
1528cdf0e10cSrcweir {
1529cdf0e10cSrcweir if ( !pTmpPage->IsEmptyPage() )
1530cdf0e10cSrcweir ++i;
1531cdf0e10cSrcweir
1532cdf0e10cSrcweir pRet = pTmpPage;
1533cdf0e10cSrcweir pTmpPage = static_cast<const SwPageFrm*>( pTmpPage->GetNext() );
1534cdf0e10cSrcweir }
1535cdf0e10cSrcweir
1536cdf0e10cSrcweir return pRet->GetPhyPageNum();
1537cdf0e10cSrcweir }
153857124fcbSmseidel
153957124fcbSmseidel /* vim: set noet sw=4 ts=4: */
1540