sw/inc/pagepreviewlayout.hxx

   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 #ifndef INCLUDED_SW_INC_PAGEPREVIEWLAYOUT_HXX
  21 #define INCLUDED_SW_INC_PAGEPREVIEWLAYOUT_HXX
  22
  23 // template class <std::vector>
  24 #include <vector>
  25 // datatypes sal_xyz
  26 #include <sal/types.h>
  27 // classes <Point>, <Size> and <Rectangle>
  28 #include <tools/gen.hxx>
  29 // RenderContext type
  30 #include <vcl/outdev.hxx>
  31 // datatype <SwTwips>
  32 #include "swtypes.hxx"
  33
  34 class SwViewShell;
  35 class SwRootFrame;
  36 class SwPageFrame;
  37 class Fraction;
  38 struct PreviewPage;
  39
  40 /** page preview functionality in the writer */
  41 class SwPagePreviewLayout
  42 {
  43 private:
  44     friend class SwViewShell;
  45
  46     /// number of horizontal and vertical twips for spacing between the pages.
  47     static constexpr SwTwips gnXFree = 4 * 142;
  48     static constexpr SwTwips gnYFree = 4 * 142;
  49
  50     /// view shell the print preview is generated for.
  51     SwViewShell& mrParentViewShell;
  52     /// top layout frame of the layout for accessing the pages
  53     const SwRootFrame& mrLayoutRootFrame;
  54
  55     /** boolean indicating, if the layout information (number of columns and rows)
  56        are valid. */
  57     bool        mbLayoutInfoValid;
  58     /** boolean indicating, if the calculated print preview layout sizes
  59        ( windows size in twips, maximal page size, column width, row height,
  60          width and height of a print preview page, size of the print preview
  61          document ) are valid */
  62     bool        mbLayoutSizesValid;
  63     /** boolean indicating, if the paint information ( physical number of
  64          start page, start column and row, paint offsets, rectangle visible of
  65          the print preview document. */
  66     bool        mbPaintInfoValid;
  67
  68     Size        maWinSize;
  69     sal_uInt16  mnCols;
  70     sal_uInt16  mnRows;
  71     sal_uInt16  mnPages;
  72     // #i18143# - the book preview is controlled by this flag
  73     bool        mbBookPreview;
  74     bool        mbBookPreviewModeToggled;
  75
  76     Size        maMaxPageSize;
  77     tools::Rectangle   maPreviewDocRect;
  78     SwTwips     mnColWidth;
  79     SwTwips     mnRowHeight;
  80     SwTwips     mnPreviewLayoutWidth;
  81     SwTwips     mnPreviewLayoutHeight;
  82     bool        mbDoesLayoutColsFitIntoWindow;
  83     bool        mbDoesLayoutRowsFitIntoWindow;
  84
  85     sal_uInt16  mnPaintPhyStartPageNum;
  86     sal_uInt16  mnPaintStartCol;
  87     sal_uInt16  mnPaintStartRow;
  88     bool        mbNoPageVisible;
  89     Point       maPaintStartPageOffset;
  90     Point       maPaintPreviewDocOffset;
  91     Point       maAdditionalPaintOffset;
  92     tools::Rectangle   maPaintedPreviewDocRect;
  93     sal_uInt16  mnSelectedPageNum;
  94
  95     std::vector<std::unique_ptr<PreviewPage>> maPreviewPages;
  96
  97     /** #i22014# - internal booleans to indicate, that a new print
  98        preview layout has been created during a paint. */
  99     mutable bool mbInPaint;
 100     mutable bool mbNewLayoutDuringPaint;
 101
 102     bool mbPrintEmptyPages;
 103
 104     /** clear internal data about current page preview */
 105     void Clear_();
 106
 107     /** helper method to clear preview page layout sizes */
 108     void ClearPreviewLayoutSizes();
 109
 110     /** helper method to clear data in preview page vectors */
 111     void ClearPreviewPageData();
 112
 113     /** calculate page preview layout sizes */
 114     void CalcPreviewLayoutSizes();
 115
 116     /** apply new zoom at given view shell
 117
 118         @param _aNewZoom
 119         input parameter - new zoom percentage
 120     */
 121     void ApplyNewZoomAtViewShell( sal_uInt8 _aNewZoom );
 122
 123     /** calculate additional paint offset
 124
 125         helper method called by <Prepare> in order to calculate an additional
 126         paint offset to center output in given window size.
 127         The booleans <mbDoesLayoutRowsFitIntoWindow> and <mbDoesLayoutColsFitIntoWindow>
 128         are also determined.
 129         preconditions:
 130         (1) preview layout is given (number of rows and columns).
 131         (2) window size is given.
 132         (3) height of row and width of column are calculated.
 133         (4) paint offset of start page is calculated.
 134     */
 135     void CalcAdditionalPaintOffset();
 136
 137     /** calculate painted preview document rectangle
 138
 139         helper method called by <Prepare> in order to calculate the rectangle,
 140         which will be painted for the document arranged by the given preview
 141         layout.
 142         preconditions:
 143         (1) paint offset of document preview is calculated.
 144         (2) size of document preview is calculated.
 145         (3) additional paint offset is calculated - see <CalcAdditionalPaintOffset>.
 146     */
 147     void CalcDocPreviewPaintRect();
 148
 149     /** determines preview data for a given page and a given preview offset
 150
 151         @param _rPage
 152         input parameter - constant reference to page frame, for which the
 153         preview data will be calculated.
 154
 155         @param _rPreviewOffset
 156         input parameter - constant reference to the offset the given page has
 157         in the current preview window.
 158         Note: Offset can be negative.
 159
 160         @param _opPreviewPage
 161         output parameter - calculated preview data.
 162     */
 163     void CalcPreviewDataForPage( const SwPageFrame& _rPage,
 164                                   const Point& _rPreviewOffset,
 165                                   PreviewPage* _opPreviewPage );
 166
 167     /** calculate preview pages
 168
 169         helper method called by <Prepare> in order to determine which pages
 170         will be visible in the current preview and calculate the data needed
 171         to paint these pages. Also the accessible pages with its needed data
 172         are determined.
 173     */
 174     void CalcPreviewPages();
 175
 176     /** get preview page by physical page number
 177
 178         @param _nPageNum
 179         input parameter - physical page number of page, for which the preview
 180         page will be returned.
 181
 182         @return pointer to preview page of current preview pages. If page doesn't
 183         belongs to current preview pages, <0> is returned.
 184     */
 185     const PreviewPage* GetPreviewPageByPageNum( const sal_uInt16 _nPageNum ) const;
 186
 187     /** paint selection mark at page */
 188     void PaintSelectMarkAtPage(vcl::RenderContext& rRenderContext, const PreviewPage* _aSelectedPreviewPage) const;
 189
 190 public:
 191     /** constructor of <SwPagePreviewLayout>
 192
 193         @param _rParentViewShell
 194         input parameter - reference to the view shell the page preview
 195         layout belongs to. Reference will be hold as member <mrParentViewShell>.
 196         Adjustments/Changes at this view shell:
 197         (1) Adjustment of the mapping mode at the output device.
 198         (2) Change of the zoom at the view options.
 199         (3) Preparations for paint of the page preview.
 200
 201         @param _rLayoutRootFrame
 202         input parameter - constant reference to the root frame of the layout.
 203         Reference will be hold as member <mrLayoutRootFrame> in order to get
 204         access to the page frames.
 205     */
 206     SwPagePreviewLayout( SwViewShell& _rParentViewShell,
 207                          const SwRootFrame&    _rLayoutRootFrame );
 208
 209     /** destructor of <SwPagePreviewLayout> */
 210     ~SwPagePreviewLayout()
 211     {
 212         ClearPreviewPageData();
 213     }
 214
 215     /** init page preview layout
 216
 217         initialize the page preview settings for a given layout.
 218         side effects:
 219         (1) If parameter <_bCalcScale> is true, mapping mode with calculated
 220         scaling is set at the output device and the zoom at the view options of
 221         the given view shell is set with the calculated scaling.
 222
 223         @param _nCols
 224         input parameter - initial number of page columns in the preview.
 225
 226         @param _nRows
 227         input parameter - initial number of page rows in the preview.
 228
 229         @param _rPxWinSize
 230         input parameter - window size in which the preview will be displayed and
 231         for which the scaling will be calculated.
 232     */
 233     void Init( const sal_uInt16 _nCols,
 234                const sal_uInt16 _nRows,
 235                const Size&      _rPxWinSize
 236               );
 237
 238     /** method to adjust page preview layout to document changes */
 239     void ReInit();
 240
 241     /** prepare paint of page preview
 242
 243         With the valid preview layout settings - calculated and set by method
 244         <Init(..)> - the paint of a specific part of the virtual preview
 245         document is prepared. The corresponding part is given by either
 246         a start page (parameter <_nProposedStartPageNum>) or a absolute position
 247         (parameter <_aProposedStartPoint>).
 248         The accessibility preview will also be updated via a corresponding
 249         method call.
 250
 251         @param _nProposedStartPageNum [0..<number of document pages>]
 252         input parameter - proposed number of page, which should be painted in
 253         the left-top-corner in the current output device. input parameter
 254         <_bStartWithPageAtFirstCol> influences, if proposed page is actual
 255         painted in the left-top-corner.
 256
 257         @param _nProposedStartPos [(0,0)..<PreviewDocumentSize>]
 258         input parameter - proposed absolute position in the virtual preview
 259         document, which should be painted in the left-top-corner in the current
 260         output device.
 261
 262         @param _rPxWinSize
 263         input parameter - pixel size of window the preview will be painted in.
 264
 265         @param _onStartPageNum
 266         output parameter - physical number of page, which will be painted in the
 267         left-top-corner in the current output device.
 268
 269         @param _orDocPreviewPaintRect
 270         output parameter - rectangle of preview document, which will be painted.
 271
 272         @param _bStartWithPageAtFirstCol
 273         input parameter with default value "true" - controls, if start page
 274         is set to page in first column the proposed start page is located.
 275
 276         @return boolean, indicating, if prepare of preview paint was successful.
 277     */
 278     bool Prepare( const sal_uInt16 _nProposedStartPageNum,
 279                   const Point&      rProposedStartPos,
 280                   const Size&      _rPxWinSize,
 281                   sal_uInt16&      _onStartPageNum,
 282                   tools::Rectangle&       _orDocPreviewPaintRect,
 283                   const bool       _bStartWithPageAtFirstCol = true
 284                 );
 285
 286     /** get selected page number */
 287     sal_uInt16 SelectedPage()
 288     {
 289         return mnSelectedPageNum;
 290     }
 291
 292     /** set selected page number */
 293     void SetSelectedPage( sal_uInt16 _nSelectedPageNum )
 294     {
 295         mnSelectedPageNum = _nSelectedPageNum;
 296     }
 297
 298     /** paint prepared preview
 299
 300         @param _aOutRect
 301         input parameter - Twip rectangle of window, which should be painted.
 302
 303         @return boolean, indicating, if paint of preview was performed
 304     */
 305     bool Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rOutRect) const;
 306
 307     /** repaint pages on page preview
 308
 309         method to invalidate visible pages due to changes in a different
 310         view shell.
 311     */
 312     void Repaint(const tools::Rectangle& rInvalidCoreRect) const;
 313
 314     /** paint to mark new selected page
 315
 316         Perform paint for current selected page in order to unmark it.
 317         Set new selected page and perform paint to mark this page.
 318
 319         @param _nNewSelectedPage
 320         input parameter - physical number of page, which will be marked as selected.
 321     */
 322     void MarkNewSelectedPage( const sal_uInt16 _nSelectedPage );
 323
 324     /** calculate start position for new scale
 325
 326         calculate new start position for a new scale. Calculation bases on the
 327         current visible part of the document arranged in the given preview layout.
 328         preconditions:
 329         (1) new scaling is already set at the given output device.
 330
 331         @return Point, start position for new scale
 332     */
 333     Point GetPreviewStartPosForNewScale( const Fraction& _aNewScale,
 334                                          const Fraction& _aOldScale,
 335                                          const Size&     _aNewWinSize ) const;
 336
 337     /** determines, if page with given page number is visible in preview
 338
 339         @param _nPageNum
 340         input parameter - physical number of page, for which it will be
 341         determined, if it is visible.
 342
 343         @return boolean, indicating, if page with given page number is visible
 344         in preview.
 345     */
 346     bool IsPageVisible( const sal_uInt16 _nPageNum ) const;
 347
 348     /** calculate data to bring new selected page into view.
 349
 350         @param _nHoriMove
 351         input parameter - positive/negative number of columns the current
 352         selected page have to be moved.
 353
 354         @param _nVertMove
 355         input parameter - positive/negative number of rows the current
 356         selected page have to be moved.
 357
 358         @param _orNewSelectedPage
 359         output parameter - number of new selected page
 360
 361         @param _orNewStartPage
 362         output parameter - number of new start page
 363
 364         @param _orNewStartPos
 365         output parameter - new start position in document preview
 366     */
 367     void CalcStartValuesForSelectedPageMove( const sal_Int16  _nHoriMove,
 368                                              const sal_Int16  _nVertMove,
 369                                              sal_uInt16&      _orNewSelectedPage,
 370                                              sal_uInt16&      _orNewStartPage,
 371                                              Point&           _orNewStartPos ) const;
 372
 373     /** checks, if given position is inside a shown document page
 374
 375         @param _aPreviewPos
 376         input parameter - position inside the visible preview window.
 377
 378         @param _orDocPos
 379         output parameter - corresponding position in the document, if given
 380         preview position is inside a shown document page, not an empty page.
 381         If not, its value is <Point( 0, 0 )>.
 382
 383         @param _obPosInEmptyPage
 384         output parameter - indicates, that given preview position lays inside
 385         an shown empty page.
 386
 387         @param _onPageNum
 388         output parameter - corresponding physical number of page, if given
 389         preview position is inside a shown document page, considers also empty
 390         pages. If not, its value is <0>.
 391
 392         @return boolean - indicating, that given preview position lays inside
 393         a shown document preview page, not an empty page.
 394     */
 395     bool IsPreviewPosInDocPreviewPage( const Point& rPreviewPos,
 396                                    Point&       _orDocPos,
 397                                    bool&        _obPosInEmptyPage,
 398                                    sal_uInt16&  _onPageNum ) const;
 399
 400     bool DoesPreviewLayoutRowsFitIntoWindow() const
 401     {
 402         return mbDoesLayoutRowsFitIntoWindow;
 403     }
 404
 405     bool DoesPreviewLayoutColsFitIntoWindow() const
 406     {
 407         return mbDoesLayoutColsFitIntoWindow;
 408     }
 409
 410     bool PreviewLayoutValid() const
 411     {
 412         return mbLayoutInfoValid && mbLayoutSizesValid && mbPaintInfoValid;
 413     }
 414
 415     /** determine preview window page scroll amount
 416
 417         @param _nWinPagesToScroll
 418         input parameter - number of preview window pages the scroll amount has
 419         to be calculated for. Negative values for preview window page up
 420         scrolling, positive values for preview window page down scrolling.
 421
 422         @return scroll amount in SwTwips
 423     */
 424     SwTwips GetWinPagesScrollAmount( const sal_Int16 _nWinPagesToScroll ) const;
 425
 426     /** determine row the page with the given number is in
 427
 428         @param _nPageNum
 429         input parameter - physical page number of page, for which the row in
 430         preview layout has to be calculated.
 431
 432         @return number of row the page with the given physical page number is in
 433     */
 434     sal_uInt16 GetRowOfPage( sal_uInt16 _nPageNum ) const;
 435
 436     /** determine column the page with the given number is in
 437
 438         @param _nPageNum
 439         input parameter - physical page number of page, for which the column in
 440         preview layout has to be calculated.
 441
 442         @return number of column the page with the given physical page number is in
 443     */
 444     sal_uInt16 GetColOfPage( sal_uInt16 _nPageNum ) const;
 445
 446     Size GetPreviewDocSize() const;
 447
 448     /** get size of a preview page by its physical page number
 449
 450         @param _nPageNum
 451         input parameter - physical page number of preview page, for which the
 452         page size has to be returned.
 453
 454         @return an object of class <Size>
 455     */
 456     Size GetPreviewPageSizeByPageNum( sal_uInt16 _nPageNum ) const;
 457
 458     /** get virtual page number by its physical page number
 459
 460         @param _nPageNum
 461         input parameter - physical page number of preview page, for which the
 462         virtual page number has to be determined.
 463
 464         @return virtual page number of page given by its physical page number,
 465         if the page is in the current preview pages vector, otherwise 0.
 466     */
 467     sal_uInt16 GetVirtPageNumByPageNum( sal_uInt16 _nPageNum ) const;
 468
 469     /** enable/disable book preview */
 470     bool SetBookPreviewMode( const bool  _bEnableBookPreview,
 471                              sal_uInt16& _onStartPageNum,
 472                              tools::Rectangle&  _orDocPreviewPaintRect );
 473
 474     /** Convert relative to absolute page numbers (see PrintEmptyPages) */
 475     sal_uInt16 ConvertRelativeToAbsolutePageNum( sal_uInt16 _nRelPageNum ) const;
 476
 477     /** Convert absolute to relative page numbers (see PrintEmptyPages) */
 478     sal_uInt16 ConvertAbsoluteToRelativePageNum( sal_uInt16 _nAbsPageNum ) const;
 479
 480     SwViewShell& GetParentViewShell()
 481     {
 482         return mrParentViewShell;
 483     }
 484 };
 485
 486 #endif // INCLUDED_SW_INC_PAGEPREVIEWLAYOUT_HXX
 487
 488 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */