| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef SD_SLIDESORTER_VIEW_LAYOUTER_HXX |
| #define SD_SLIDESORTER_VIEW_LAYOUTER_HXX |
| |
| #include "SlideSorter.hxx" |
| #include "view/SlsPageObjectLayouter.hxx" |
| #include "view/SlsTheme.hxx" |
| #include <sal/types.h> |
| #include <tools/fract.hxx> |
| #include <vcl/mapmod.hxx> |
| #include <vector> |
| #include <utility> |
| |
| |
| class MapMode; |
| class OutputDevice; |
| class Size; |
| |
| namespace sd { namespace slidesorter { namespace view { |
| |
| class InsertPosition; |
| |
| |
| |
| /** Calculate the size and position of page objects displayed by a slide |
| sorter. The layouter takes into account various input values: |
| 1.) Size of the window in which the slide sorter is displayed. |
| 2.) Desired and minimal and maximal widths of page objects. |
| 3.) Minimal and maximal number of columns. |
| 4.) Vertical and horizontal gaps between objects in adjacent columns. |
| 5.) Borders arround every page object. |
| 6.) Vertical and horizontal borders between enclosing page and outer |
| page objects. |
| From these it calculates various output values: |
| 1.) The width of page objects. |
| 2.) The number of columns. |
| 3.) The size of the enclosing page. |
| |
| <p>Sizes and lengths are all in pixel except where explicitly stated |
| otherwise.</p> |
| |
| <p>The GetIndex... methods may return indices that are larger than or |
| equal to (zero based) the number of pages. This is so because the |
| number of pages is not known to the class instances. Indices are |
| calculated with reference to the general grid layout of page |
| objects.</p> |
| */ |
| class Layouter |
| { |
| public: |
| enum Orientation { HORIZONTAL, VERTICAL, GRID }; |
| |
| Layouter ( |
| const SharedSdWindow& rpWindow, |
| const ::boost::shared_ptr<Theme>& rpTheme); |
| ~Layouter (void); |
| |
| ::boost::shared_ptr<PageObjectLayouter> GetPageObjectLayouter (void) const; |
| /** Set the horizontal and vertical borders in pixel coordinates between |
| the enclosing window and page objects. The borders may be painted |
| larger then the given values when the space for the insertion marker |
| is not sufficient. |
| @param nLeftBorder |
| Use a negative value to indicate that the left border size |
| shall not be modified. A value of 10 is the default. |
| @param nRightBorder |
| Use a negative value to indicate that the right border size |
| shall not be modified. A value of 10 is the default. |
| @param nTopBorder |
| Use a negative value to indicate that the top border size |
| shall not be modified. A value of 10 is the default. |
| @param nBottomBorder |
| Use a negative value to indicate that the bottom border size |
| shall not be modified. A value of 10 is the default. |
| */ |
| void SetBorders (sal_Int32 nLeftBorder, sal_Int32 nRightBorder, |
| sal_Int32 nTopBorder, sal_Int32 nBottomBorder); |
| |
| /** Set the interval of valid column counts. When nMinimalColumnCount |
| <= nMaximalColumnCount is not fullfilled then the call is ignored. |
| @param nMinimalColumnCount |
| The default value is 1. The question whether higher values make |
| any sense is left to the caller. |
| @param nMaximalColumnCount |
| The default value is 5. |
| */ |
| void SetColumnCount (sal_Int32 nMinimalColumnCount, |
| sal_Int32 nMaximalColumnCount); |
| |
| /** Central method of this class. It takes the input values and |
| calculates the output values. Both given sizes must not be 0 in any |
| dimension or the call is ignored. |
| @param eOrientation |
| This defines the generaly layout and specifies whether there may |
| be more than one row or more than one column. |
| @param rWindowSize |
| The size of the window in pixels that the slide sorter is |
| displayed in. This can differ from the size of mpWindow during |
| detection of whether or not the scroll bars should be visible. |
| @param rPreviewModelSize |
| Size of each page in model coordinates. |
| @param rpWindow |
| The map mode of this window is adapted to the new layout of the |
| page objects. |
| @return |
| The return value indicates whether the Get... methods can be |
| used to obtain valid values (<TRUE/>). |
| */ |
| bool Rearrange ( |
| const Orientation eOrientation, |
| const Size& rWindowSize, |
| const Size& rPreviewModelSize, |
| const sal_uInt32 nPageCount); |
| |
| /** Change the zoom factor. This does not change the general layout |
| (number of columns). |
| */ |
| void _SetZoom (double nZoomFactor); |
| void _SetZoom (Fraction nZoomFactor); |
| |
| /** Return the number of columns. |
| */ |
| sal_Int32 GetColumnCount (void) const; |
| |
| sal_Int32 GetRowCount (void) const; |
| |
| sal_Int32 GetRow (const sal_Int32 nIndex) const; |
| |
| sal_Int32 GetColumn (const sal_Int32 nIndex) const; |
| |
| sal_Int32 GetIndex (const sal_Int32 nRow, const sal_Int32 nColumn) const; |
| |
| /** Return the scale factor that can be set at the map mode of the |
| output window. |
| */ |
| Fraction GetScaleFactor (void) const; |
| |
| Size GetPageObjectSize (void) const; |
| |
| /** Return the bounding box in window coordinates of the nIndex-th page |
| object. |
| */ |
| Rectangle GetPageObjectBox ( |
| const sal_Int32 nIndex, |
| const bool bIncludeBorderAndGap = false) const; |
| |
| /** Return the bounding box in model coordinates of the page that |
| contains the given amount of page objects. |
| */ |
| Rectangle GetTotalBoundingBox (void) const; |
| |
| /** Return the index of the first fully or partially visible page |
| object. This takes into account only the vertical dimension. |
| @return |
| The second index may be larger than the number of existing |
| page objects. |
| */ |
| Range GetRangeOfVisiblePageObjects (const Rectangle& rVisibleArea) const; |
| |
| /** Return the index of the page object that is rendered at the given |
| point. |
| @param rPosition |
| The position is expected to be in model coordinates relative to |
| the page origin. |
| @param bIncludePageBorders |
| When <TRUE/> then include the page borders into the calculation, |
| i.e. when a point lies in the border of a page object but not on |
| the actual page area the index of that page is returned; |
| otherwise -1 would be returned to indicate that no page object |
| has been hit. |
| @param bClampToValidRange |
| When <TRUE/> then values outside the valid range [0,mnPageCount) |
| are mapped to 0 (when smaller than 0) or mnPageCount-1 when |
| equal to or larger than mnPageCount. |
| When <FALSE/> then -1 is returned for values outside the valid range. |
| @return |
| The returned index may be larger than the number of existing |
| page objects. |
| */ |
| sal_Int32 GetIndexAtPoint ( |
| const Point& rModelPosition, |
| const bool bIncludePageBorders = false, |
| const bool bClampToValidRange = true) const; |
| |
| /** Return an object that describes the logical and visual properties of |
| where to do an insert operation when the user would release the the |
| mouse button at the given position after a drag operation and of |
| where and how to display an insertion indicator. |
| @param rModelPosition |
| The position in the model coordinate system for which to |
| determine the insertion page index. The position does not have |
| to be over a page object to return a valid value. |
| @param rIndicatorSize |
| The size of the insertion indicator. This size is used to adapt |
| the location when at the left or right of a row or at the top or |
| bottom of a column. |
| @param rModel |
| The model is used to get access to the selection states of the |
| pages. This in turn is used to determine the visual bounding |
| boxes. |
| */ |
| InsertPosition GetInsertPosition ( |
| const Point& rModelPosition, |
| const Size& rIndicatorSize, |
| model::SlideSorterModel& rModel) const; |
| |
| Range GetValidHorizontalSizeRange (void) const; |
| Range GetValidVerticalSizeRange (void) const; |
| |
| class Implementation; |
| |
| private: |
| ::boost::scoped_ptr<Implementation> mpImplementation; |
| SharedSdWindow mpWindow; |
| }; |
| |
| |
| |
| |
| |
| /** Collect all values concerning the logical and visual properties of the |
| insertion position that is used for drag-and-drop and copy-and-past. |
| */ |
| class InsertPosition |
| { |
| public: |
| InsertPosition (void); |
| InsertPosition& operator= (const InsertPosition& rInsertPosition); |
| bool operator== (const InsertPosition& rInsertPosition) const; |
| bool operator!= (const InsertPosition& rInsertPosition) const; |
| |
| void SetLogicalPosition ( |
| const sal_Int32 nRow, |
| const sal_Int32 nColumn, |
| const sal_Int32 nIndex, |
| const bool bIsAtRunStart, |
| const bool bIsAtRunEnd, |
| const bool bIsExtraSpaceNeeded); |
| void SetGeometricalPosition( |
| const Point aLocation, |
| const Point aLeadingOffset, |
| const Point aTrailingOffset); |
| |
| sal_Int32 GetRow (void) const { return mnRow; } |
| sal_Int32 GetColumn (void) const { return mnColumn; } |
| sal_Int32 GetIndex (void) const { return mnIndex; } |
| Point GetLocation (void) const { return maLocation; } |
| Point GetLeadingOffset (void) const { return maLeadingOffset; } |
| Point GetTrailingOffset (void) const { return maTrailingOffset; } |
| bool IsAtRunStart (void) const { return mbIsAtRunStart; } |
| bool IsAtRunEnd (void) const { return mbIsAtRunEnd; } |
| bool IsExtraSpaceNeeded (void) const { return mbIsExtraSpaceNeeded; } |
| |
| private: |
| sal_Int32 mnRow; |
| sal_Int32 mnColumn; |
| sal_Int32 mnIndex; |
| bool mbIsAtRunStart : 1; |
| bool mbIsAtRunEnd : 1; |
| bool mbIsExtraSpaceNeeded : 1; |
| Point maLocation; |
| Point maLeadingOffset; |
| Point maTrailingOffset; |
| }; |
| |
| |
| |
| } } } // end of namespace ::sd::slidesorter::view |
| |
| #endif |
