| /************************************************************** |
| * |
| * 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 _VCL_ARRANGE_HXX |
| #define _VCL_ARRANGE_HXX |
| |
| #include "vcl/window.hxx" |
| |
| #include <vector> |
| #include <map> |
| #include <boost/shared_ptr.hpp> |
| |
| namespace vcl |
| { |
| /* some helper classes for simple window layouting |
| guidelines: |
| - a WindowArranger is not a Window |
| - a WindowArranger hierarchy manages exactly one level of child windows inside a common parent |
| this is to keep the vcl Window hierarchy flat, as some code like accelerators depend on such behavior |
| - a WindowArranger never becomes owner of a Window, windows need to be destroyed separately |
| - a WindowArranger however always is owner of its child WindowArrangers, that is the |
| WindowArranger hierarchy will keep track of its objects and delete them |
| - a managed element of a WindowArranger can either be a Window (a leaf in the hierarchy) |
| or a child WindowArranger (a node in the hierarchy), but never both |
| */ |
| |
| class VCL_DLLPUBLIC WindowArranger |
| { |
| protected: |
| struct Element |
| { |
| Window* m_pElement; |
| boost::shared_ptr<WindowArranger> m_pChild; |
| sal_Int32 m_nExpandPriority; |
| Size m_aMinSize; |
| bool m_bHidden; |
| long m_nLeftBorder; |
| long m_nTopBorder; |
| long m_nRightBorder; |
| long m_nBottomBorder; |
| |
| Element() |
| : m_pElement( NULL ) |
| , m_pChild() |
| , m_nExpandPriority( 0 ) |
| , m_bHidden( false ) |
| , m_nLeftBorder( 0 ) |
| , m_nTopBorder( 0 ) |
| , m_nRightBorder( 0 ) |
| , m_nBottomBorder( 0 ) |
| {} |
| |
| Element( Window* i_pWin, |
| boost::shared_ptr<WindowArranger> const & i_pChild = boost::shared_ptr<WindowArranger>(), |
| sal_Int32 i_nExpandPriority = 0, |
| const Size& i_rMinSize = Size() |
| ) |
| : m_pElement( i_pWin ) |
| , m_pChild( i_pChild ) |
| , m_nExpandPriority( i_nExpandPriority ) |
| , m_aMinSize( i_rMinSize ) |
| , m_bHidden( false ) |
| , m_nLeftBorder( 0 ) |
| , m_nTopBorder( 0 ) |
| , m_nRightBorder( 0 ) |
| , m_nBottomBorder( 0 ) |
| {} |
| |
| void deleteChild() { m_pChild.reset(); } |
| |
| sal_Int32 getExpandPriority() const; |
| Size getOptimalSize( WindowSizeType ) const; |
| bool isVisible() const; |
| void setPosSize( const Point&, const Size& ); |
| }; |
| |
| Window* m_pParentWindow; |
| WindowArranger* m_pParentArranger; |
| Rectangle m_aManagedArea; |
| long m_nOuterBorder; |
| |
| rtl::OUString m_aIdentifier; |
| |
| virtual Element* getElement( size_t i_nIndex ) = 0; |
| const Element* getConstElement( size_t i_nIndex ) const |
| { return const_cast<WindowArranger*>(this)->getElement( i_nIndex ); } |
| |
| |
| public: |
| static long getDefaultBorder(); |
| |
| static long getBorderValue( long nBorder ) |
| { return nBorder >= 0 ? nBorder : -nBorder * getDefaultBorder(); } |
| |
| WindowArranger( WindowArranger* i_pParent = NULL ) |
| : m_pParentWindow( i_pParent ? i_pParent->m_pParentWindow : NULL ) |
| , m_pParentArranger( i_pParent ) |
| , m_nOuterBorder( 0 ) |
| {} |
| virtual ~WindowArranger(); |
| |
| // ask what would be the optimal size |
| virtual Size getOptimalSize( WindowSizeType ) const = 0; |
| // call Resize to trigger layouting inside the managed area |
| // without function while parent window is unset |
| virtual void resize() = 0; |
| // avoid this if possible, using the constructor instead |
| // there can be only one parent window and all managed windows MUST |
| // be direct children of that window |
| // violating that condition will result in undefined behavior |
| virtual void setParentWindow( Window* ); |
| |
| virtual void setParent( WindowArranger* ); |
| |
| virtual size_t countElements() const = 0; |
| boost::shared_ptr<WindowArranger> getChild( size_t i_nIndex ) const |
| { |
| const Element* pEle = getConstElement( i_nIndex ); |
| return pEle ? pEle->m_pChild : boost::shared_ptr<WindowArranger>(); |
| } |
| Window* getWindow( size_t i_nIndex ) const |
| { |
| const Element* pEle = getConstElement( i_nIndex ); |
| return pEle ? pEle->m_pElement : NULL; |
| } |
| |
| virtual bool isVisible() const; // true if any element is visible |
| |
| virtual com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue > getProperties() const; |
| virtual void setProperties( const com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >& ); |
| |
| sal_Int32 getExpandPriority( size_t i_nIndex ) const |
| { |
| const Element* pEle = getConstElement( i_nIndex ); |
| return pEle ? pEle->getExpandPriority() : 0; |
| } |
| |
| Size getMinimumSize( size_t i_nIndex ) const |
| { |
| const Element* pEle = getConstElement( i_nIndex ); |
| return pEle ? pEle->m_aMinSize : Size(); |
| } |
| |
| bool setMinimumSize( size_t i_nIndex, const Size& i_rMinSize ) |
| { |
| Element* pEle = getElement( i_nIndex ); |
| if( pEle ) |
| pEle->m_aMinSize = i_rMinSize; |
| return pEle != NULL; |
| } |
| |
| void setBorders( size_t i_nIndex, long i_nLeft, long i_nTop, long i_nRight, long i_nBottom ) |
| { |
| Element* pEle = getElement( i_nIndex ); |
| if( pEle ) |
| { |
| pEle->m_nLeftBorder = i_nLeft; |
| pEle->m_nRightBorder = i_nRight; |
| pEle->m_nTopBorder = i_nTop; |
| pEle->m_nBottomBorder = i_nBottom; |
| } |
| } |
| |
| void getBorders( size_t i_nIndex, long* i_pLeft = NULL, long* i_pTop = NULL, long* i_pRight = NULL, long* i_pBottom = NULL ) const |
| { |
| const Element* pEle = getConstElement( i_nIndex ); |
| if( pEle ) |
| { |
| if( i_pLeft ) *i_pLeft = pEle->m_nLeftBorder; |
| if( i_pTop ) *i_pTop = pEle->m_nTopBorder; |
| if( i_pRight ) *i_pRight = pEle->m_nRightBorder; |
| if( i_pBottom ) *i_pBottom = pEle->m_nBottomBorder; |
| } |
| } |
| |
| |
| void show( bool i_bShow = true, bool i_bImmediateUpdate = true ); |
| |
| void setManagedArea( const Rectangle& i_rArea ) |
| { |
| m_aManagedArea = i_rArea; |
| resize(); |
| } |
| const Rectangle& getManagedArea() const { return m_aManagedArea; } |
| |
| void setOuterBorder( long i_nBorder ) |
| { |
| m_nOuterBorder = i_nBorder; |
| resize(); |
| } |
| |
| const rtl::OUString getIdentifier() const |
| { return m_aIdentifier; } |
| |
| void setIdentifier( const rtl::OUString& i_rId ) |
| { m_aIdentifier = i_rId; } |
| }; |
| |
| class VCL_DLLPUBLIC RowOrColumn : public WindowArranger |
| { |
| long m_nBorderWidth; |
| bool m_bColumn; |
| |
| std::vector< WindowArranger::Element > m_aElements; |
| |
| void distributeRowWidth( std::vector< Size >& io_rSizes, long i_nUsedWidth, long i_nExtraWidth ); |
| void distributeColumnHeight( std::vector< Size >& io_rSizes, long i_nUsedHeight, long i_nExtraHeight ); |
| protected: |
| virtual Element* getElement( size_t i_nIndex ) |
| { return i_nIndex < m_aElements.size() ? &m_aElements[ i_nIndex ] : 0; } |
| |
| public: |
| RowOrColumn( WindowArranger* i_pParent = NULL, |
| bool bColumn = true, long i_nBorderWidth = -1 ) |
| : WindowArranger( i_pParent ) |
| , m_nBorderWidth( i_nBorderWidth ) |
| , m_bColumn( bColumn ) |
| {} |
| |
| virtual ~RowOrColumn(); |
| |
| virtual Size getOptimalSize( WindowSizeType ) const; |
| virtual void resize(); |
| virtual size_t countElements() const { return m_aElements.size(); } |
| |
| // add a managed window at the given index |
| // an index smaller than zero means add the window at the end |
| size_t addWindow( Window*, sal_Int32 i_nExpandPrio = 0, const Size& i_rMinSize = Size(), size_t i_nIndex = ~0 ); |
| void remove( Window* ); |
| |
| size_t addChild( boost::shared_ptr<WindowArranger> const &, sal_Int32 i_nExpandPrio = 0, size_t i_nIndex = ~0 ); |
| // convenience: use for addChild( new WindowArranger( ... ) ) constructs |
| size_t addChild( WindowArranger* i_pNewChild, sal_Int32 i_nExpandPrio = 0, size_t i_nIndex = ~0 ) |
| { return addChild( boost::shared_ptr<WindowArranger>( i_pNewChild ), i_nExpandPrio, i_nIndex ); } |
| void remove( boost::shared_ptr<WindowArranger> const & ); |
| |
| long getBorderWidth() const { return m_nBorderWidth; } |
| }; |
| |
| class VCL_DLLPUBLIC LabeledElement : public WindowArranger |
| { |
| WindowArranger::Element m_aLabel; |
| WindowArranger::Element m_aElement; |
| long m_nDistance; |
| long m_nLabelColumnWidth; |
| int m_nLabelStyle; |
| protected: |
| virtual Element* getElement( size_t i_nIndex ) |
| { |
| if( i_nIndex == 0 ) |
| return &m_aLabel; |
| else if( i_nIndex == 1 ) |
| return &m_aElement; |
| return 0; |
| } |
| |
| public: |
| LabeledElement( WindowArranger* i_pParent = NULL, int i_nLabelStyle = 0, long i_nDistance = -1 ) |
| : WindowArranger( i_pParent ) |
| , m_nDistance( i_nDistance ) |
| , m_nLabelColumnWidth( 0 ) |
| , m_nLabelStyle( i_nLabelStyle ) |
| {} |
| |
| virtual ~LabeledElement(); |
| |
| virtual Size getOptimalSize( WindowSizeType ) const; |
| virtual void resize(); |
| virtual size_t countElements() const { return 2; } |
| |
| void setLabel( Window* ); |
| void setLabel( boost::shared_ptr<WindowArranger> const & ); |
| void setElement( Window* ); |
| void setElement( boost::shared_ptr<WindowArranger> const & ); |
| void setLabelColumnWidth( long i_nWidth ) |
| { m_nLabelColumnWidth = i_nWidth; } |
| |
| Size getLabelSize( WindowSizeType i_eType ) const |
| { return m_aLabel.getOptimalSize( i_eType ); } |
| Size getElementSize( WindowSizeType i_eType ) const |
| { return m_aElement.getOptimalSize( i_eType ); } |
| }; |
| |
| class VCL_DLLPUBLIC LabelColumn : public RowOrColumn |
| { |
| long getLabelWidth() const; |
| public: |
| LabelColumn( WindowArranger* i_pParent = NULL, long i_nBorderWidth = -1 ) |
| : RowOrColumn( i_pParent, true, i_nBorderWidth ) |
| {} |
| virtual ~LabelColumn(); |
| |
| virtual Size getOptimalSize( WindowSizeType ) const; |
| virtual void resize(); |
| |
| // returns the index of the added label |
| size_t addRow( Window* i_pLabel, boost::shared_ptr<WindowArranger> const& i_rElement, long i_nIndent = 0 ); |
| size_t addRow( Window* i_pLabel, Window* i_pElement, long i_nIndent = 0, const Size& i_rElementMinSize = Size() ); |
| }; |
| |
| class VCL_DLLPUBLIC Indenter : public WindowArranger |
| { |
| long m_nIndent; |
| WindowArranger::Element m_aElement; |
| |
| protected: |
| virtual Element* getElement( size_t i_nIndex ) |
| { return i_nIndex == 0 ? &m_aElement : NULL; } |
| |
| public: |
| Indenter( WindowArranger* i_pParent = NULL, long i_nIndent = 3*getDefaultBorder() ) |
| : WindowArranger( i_pParent ) |
| , m_nIndent( i_nIndent ) |
| {} |
| |
| virtual ~Indenter(); |
| |
| virtual Size getOptimalSize( WindowSizeType ) const; |
| virtual void resize(); |
| virtual size_t countElements() const { return (m_aElement.m_pElement != 0 || m_aElement.m_pChild != 0) ? 1 : 0; } |
| |
| void setIndent( long i_nIndent ) |
| { |
| m_nIndent = i_nIndent; |
| resize(); |
| } |
| |
| void setWindow( Window*, sal_Int32 i_nExpandPrio = 0 ); |
| void setChild( boost::shared_ptr<WindowArranger> const &, sal_Int32 i_nExpandPrio = 0 ); |
| // convenience: use for setChild( new WindowArranger( ... ) ) constructs |
| void setChild( WindowArranger* i_pChild, sal_Int32 i_nExpandPrio = 0 ) |
| { setChild( boost::shared_ptr<WindowArranger>( i_pChild ), i_nExpandPrio ); } |
| }; |
| |
| class VCL_DLLPUBLIC Spacer : public WindowArranger |
| { |
| WindowArranger::Element m_aElement; |
| Size m_aSize; |
| |
| protected: |
| virtual Element* getElement( size_t i_nIndex ) |
| { return i_nIndex == 0 ? &m_aElement : NULL; } |
| |
| public: |
| Spacer( WindowArranger* i_pParent = NULL, sal_Int32 i_nPrio = 20, const Size& i_rSize = Size( 0, 0 ) ) |
| : WindowArranger( i_pParent ) |
| , m_aElement( NULL, boost::shared_ptr<WindowArranger>(), i_nPrio ) |
| , m_aSize( i_rSize ) |
| {} |
| |
| virtual ~Spacer() {} |
| |
| virtual Size getOptimalSize( WindowSizeType ) const |
| { return m_aSize; } |
| virtual void resize() {} |
| virtual void setParentWindow( Window* ) {} |
| virtual size_t countElements() const { return 1; } |
| virtual bool isVisible() const { return true; } |
| }; |
| |
| class VCL_DLLPUBLIC MatrixArranger : public WindowArranger |
| { |
| long m_nBorderX; |
| long m_nBorderY; |
| |
| struct MatrixElement : public WindowArranger::Element |
| { |
| sal_uInt32 m_nX; |
| sal_uInt32 m_nY; |
| |
| MatrixElement() |
| : WindowArranger::Element() |
| , m_nX( 0 ) |
| , m_nY( 0 ) |
| {} |
| |
| MatrixElement( Window* i_pWin, |
| sal_uInt32 i_nX, sal_uInt32 i_nY, |
| boost::shared_ptr<WindowArranger> const & i_pChild = boost::shared_ptr<WindowArranger>(), |
| sal_Int32 i_nExpandPriority = 0, |
| const Size& i_rMinSize = Size() |
| ) |
| : WindowArranger::Element( i_pWin, i_pChild, i_nExpandPriority, i_rMinSize ) |
| , m_nX( i_nX ) |
| , m_nY( i_nY ) |
| { |
| } |
| }; |
| |
| std::vector< MatrixElement > m_aElements; |
| std::map< sal_uInt64, size_t > m_aMatrixMap; // maps (x | (y << 32)) to index in m_aElements |
| |
| sal_uInt64 getMap( sal_uInt32 i_nX, sal_uInt32 i_nY ) |
| { return static_cast< sal_uInt64 >(i_nX) | (static_cast< sal_uInt64>(i_nY) << 32 ); } |
| |
| static void distributeExtraSize( std::vector<long>& io_rSizes, const std::vector<sal_Int32>& i_rPrios, long i_nExtraWidth ); |
| |
| Size getOptimalSize( WindowSizeType, |
| std::vector<long>& o_rColumnWidths, std::vector<long>& o_rRowHeights, |
| std::vector<sal_Int32>& o_rColumnPrio, std::vector<sal_Int32>& o_rRowPrio |
| ) const; |
| protected: |
| virtual Element* getElement( size_t i_nIndex ) |
| { return i_nIndex < m_aElements.size() ? &m_aElements[ i_nIndex ] : 0; } |
| |
| public: |
| MatrixArranger( WindowArranger* i_pParent = NULL, |
| long i_nBorderX = -1, |
| long i_nBorderY = -1 ) |
| : WindowArranger( i_pParent ) |
| , m_nBorderX( i_nBorderX ) |
| , m_nBorderY( i_nBorderY ) |
| {} |
| |
| virtual ~MatrixArranger(); |
| |
| virtual Size getOptimalSize( WindowSizeType ) const; |
| virtual void resize(); |
| virtual size_t countElements() const { return m_aElements.size(); } |
| |
| // add a managed window at the given matrix position |
| size_t addWindow( Window*, sal_uInt32 i_nX, sal_uInt32 i_nY, sal_Int32 i_nExpandPrio = 0, const Size& i_rMinSize = Size() ); |
| void remove( Window* ); |
| |
| size_t addChild( boost::shared_ptr<WindowArranger> const &, sal_uInt32 i_nX, sal_uInt32 i_nY, sal_Int32 i_nExpandPrio = 0 ); |
| // convenience: use for addChild( new WindowArranger( ... ) ) constructs |
| size_t addChild( WindowArranger* i_pNewChild, sal_uInt32 i_nX, sal_uInt32 i_nY, sal_Int32 i_nExpandPrio = 0 ) |
| { return addChild( boost::shared_ptr<WindowArranger>( i_pNewChild ), i_nX, i_nY, i_nExpandPrio ); } |
| void remove( boost::shared_ptr<WindowArranger> const & ); |
| }; |
| |
| } |
| |
| #endif |
| |
