xref: /aoo42x/main/svtools/source/table/tablecontrol_impl.hxx (revision fb0b81f5)

/**************************************************************
 *
 * 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 SVTOOLS_TABLECONTROL_IMPL_HXX
#define SVTOOLS_TABLECONTROL_IMPL_HXX

#include "svtools/table/tablemodel.hxx"
#include "svtools/table/tablecontrolinterface.hxx"

#include "svtaccessiblefactory.hxx"

#include <vcl/seleng.hxx>

#include <vector>

#include <boost/scoped_ptr.hpp>

class ScrollBar;
class ScrollBarBox;

//........................................................................
namespace svt { namespace table
{
//........................................................................

    struct MutableColumnMetrics : protected ColumnMetrics
    {
        MutableColumnMetrics()
            :ColumnMetrics()
        {
        }

        MutableColumnMetrics( long const i_startPixel, long const i_endPixel )
            :ColumnMetrics( i_startPixel, i_endPixel )
        {
        }

        long getStart() const { return nStartPixel; }
        long getEnd() const { return nEndPixel; }

        void setEnd( long const i_end ) { nEndPixel = i_end; }
        void move( long const i_offset ) { nStartPixel += i_offset; nEndPixel += i_offset; }

        long getWidth() const { return nEndPixel - nStartPixel; }

        ColumnMetrics const & operator()() { return *this; }
    };

    struct ColumnInfoPositionLess
    {
        bool operator()( MutableColumnMetrics const& i_colInfo, long const i_position )
        {
            return i_colInfo.getEnd() < i_position;
        }
        bool operator()( long const i_position, MutableColumnMetrics const& i_colInfo )
        {
            return i_position < i_colInfo.getStart();
        }
    };

    typedef ::std::vector< MutableColumnMetrics >    ColumnPositions;

    class TableControl;
    class TableDataWindow;
    class TableFunctionSet;

    //====================================================================
	//= TableControl_Impl
	//====================================================================
    class TableControl_Impl :public ITableControl
                            ,public ITableModelListener
    {
        friend class TableGeometry;
        friend class TableRowGeometry;
        friend class TableColumnGeometry;
        friend class SuspendInvariants;

    private:
        /// the control whose impl-instance we implemnt
        TableControl&       	m_rAntiImpl;
        /// the model of the table control
        PTableModel         	m_pModel;
        /// the input handler to use, usually the input handler as provided by ->m_pModel
        PTableInputHandler  	m_pInputHandler;
        /// info about the widths of our columns
        ColumnPositions         m_aColumnWidths;

        /// the height of a single row in the table, measured in pixels
        long                	m_nRowHeightPixel;
        /// the height of the column header row in the table, measured in pixels
        long                	m_nColHeaderHeightPixel;
        /// the width of the row header column in the table, measured in pixels
        long                	m_nRowHeaderWidthPixel;

        /// the number of columns in the table control. Cached model value.
        TableSize           	m_nColumnCount;

        /// the number of rows in the table control. Cached model value.
        TableSize           	m_nRowCount;

        /// denotes whether or not the columns fitted into the available width, last time we checked
        long                    m_bColumnsFit;

        ColPos              	m_nCurColumn;
        RowPos              	m_nCurRow;
        ColPos              	m_nLeftColumn;
        RowPos              	m_nTopRow;

        sal_Int32           	m_nCursorHidden;

        /** the window to contain all data content, including header bars

            The window's upper left corner is at position (0,0), relative to the
            table control, which is the direct parent of the data window.
        */
        ::boost::scoped_ptr< TableDataWindow >
                                m_pDataWindow;
        /// the vertical scrollbar, if any
        ScrollBar*          	m_pVScroll;
        /// the horizontal scrollbar, if any
        ScrollBar*              m_pHScroll;
        ScrollBarBox*       	m_pScrollCorner;
	    //selection engine - for determining selection range, e.g. single, multiple
	    SelectionEngine*    	m_pSelEngine;
	    //vector which contains the selected rows
	    std::vector<RowPos> 	m_aSelectedRows;
	    //part of selection engine
	    TableFunctionSet*   	m_pTableFunctionSet;
	    //part of selection engine
	    RowPos		    	    m_nAnchor;
        bool                    m_bUpdatingColWidths;

    	Link                    m_aSelectHdl;

	    AccessibleFactoryAccess     m_aFactoryAccess;
	    IAccessibleTableControl*    m_pAccessibleTable;

#if DBG_UTIL
    #define INV_SCROLL_POSITION     1
        /** represents a bitmask of invariants to check

            Actually, impl_checkInvariants checks more invariants than denoted in this
            bit mask, but only those present here can be disabled temporarily.
        */
        sal_Int32           m_nRequiredInvariants;
#endif

    public:
        void        setModel( PTableModel _pModel );

        inline  const PTableInputHandler&   getInputHandler() const { return m_pInputHandler; }

		inline	RowPos  getCurRow() const           { return m_nCurRow; }
		inline	void	setCurRow( RowPos i_curRow ){ m_nCurRow = i_curRow; }

        RowPos  getAnchor() const { return m_nAnchor; }
        void    setAnchor( RowPos const i_anchor ) { m_nAnchor = i_anchor; }

        inline  RowPos  getTopRow() const       { return m_nTopRow; }
        inline  ColPos  getLeftColumn() const { return m_nLeftColumn; }

        inline  const TableControl&   getAntiImpl() const { return m_rAntiImpl; }
        inline        TableControl&   getAntiImpl()       { return m_rAntiImpl; }

    public:
        TableControl_Impl( TableControl& _rAntiImpl );
        ~TableControl_Impl();

#if DBG_UTIL
        const sal_Char* impl_checkInvariants() const;
#endif
        /** to be called when the anti-impl instance has been resized
        */
        void    onResize();

        /** paints the table control content which intersects with the given rectangle
        */
        void    doPaintContent( const Rectangle& _rUpdateRect );

        /** moves the cursor to the cell with the given coordinates

            To ease the caller's code, the coordinates must not necessarily denote a
            valid position. If they don't, <FALSE/> will be returned.
        */
        bool    goTo( ColPos _nColumn, RowPos _nRow );

        /** ensures that the given coordinate is visible
            @param _nColumn
                the column position which should be visible. Must be non-negative, and smaller
                than the column count.
            @param _nRow
                the row position which should be visibleMust be non-negative, and smaller
                than the row count.
            @param _bAcceptPartialVisibility
                <TRUE/> if it's okay that the given cooordinate is only partially visible
        */
        void    ensureVisible( ColPos _nColumn, RowPos _nRow, bool _bAcceptPartialVisibility );

        /** retrieves the content of the given cell, converted to a string
        */
        ::rtl::OUString getCellContentAsString( RowPos const i_row, ColPos const i_col );

        /** returns the position of the current row in the selection vector */
	    int	getRowSelectedNumber(const ::std::vector<RowPos>& selectedRows, RowPos current);

        /** ??? */
	    void    invalidateSelectedRegion( RowPos _nPrevRow, RowPos _nCurRow );

        /** invalidates the part of the data window which is covered by the given rows
            @param i_firstRow
                the index of the first row to include in the invalidation
            @param i_lastRow
                the index of the last row to include in the invalidation, or ROW_INVALID if the invalidation
                should happen down to the bottom of the data window.
        */
        void    invalidateRowRange( RowPos const i_firstRow, RowPos const i_lastRow );

        /** invalidates the part of the data window which is covered by the given row
        */
        void    invalidateRow( RowPos const i_row ) { invalidateRowRange( i_row, i_row ); }

        /** invalidates all selected rows
        */
        void    invalidateSelectedRows();

	    void    checkCursorPosition();

        bool    hasRowSelection() const { return !m_aSelectedRows.empty(); }
        size_t  getSelectedRowCount() const { return m_aSelectedRows.size(); }
        RowPos  getSelectedRowIndex( size_t const i_selectionIndex ) const;

        /** removes the given row index from m_aSelectedRows

            @return
                <TRUE/> if and only if the row was previously marked as selected
        */
        bool        markRowAsDeselected( RowPos const i_rowIndex );

        /** marks the given row as selectged, by putting it into m_aSelectedRows
            @return
                <TRUE/> if and only if the row was previously <em>not</em> marked as selected
        */
        bool        markRowAsSelected( RowPos const i_rowIndex );

        /** marks all rows as deselected
            @return
                <TRUE/> if and only if the selection actually changed by this operation
        */
        bool        markAllRowsAsDeselected();

        /** marks all rows as selected
            @return
                <FALSE/> if and only if all rows were selected already.
        */
        bool        markAllRowsAsSelected();

        void        setSelectHandler( Link const & i_selectHandler ) { m_aSelectHdl = i_selectHandler; }
        Link const& getSelectHandler() const { return m_aSelectHdl; }

        void commitAccessibleEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );
        void commitCellEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );
        void commitTableEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );

        // ITableControl
        virtual void                hideCursor();
        virtual void                showCursor();
        virtual bool                dispatchAction( TableControlAction _eAction );
	    virtual SelectionEngine*    getSelEngine();
        virtual PTableModel         getModel() const;
        virtual ColPos              getCurrentColumn() const;
        virtual RowPos              getCurrentRow() const;
        virtual bool                activateCell( ColPos const i_col, RowPos const i_row );
        virtual ::Size              getTableSizePixel() const;
        virtual void                setPointer( Pointer const & i_pointer );
        virtual void                captureMouse();
        virtual void                releaseMouse();
        virtual void                invalidate( TableArea const i_what );
        virtual long                pixelWidthToAppFont( long const i_pixels ) const;
        virtual void                hideTracking();
        virtual void                showTracking( Rectangle const & i_location, sal_uInt16 const i_flags );
	    virtual RowPos	            getRowAtPoint( const Point& rPoint ) const;
        virtual ColPos              getColAtPoint( const Point& rPoint ) const;
        virtual TableCell           hitTest( const Point& rPoint ) const;
        virtual ColumnMetrics       getColumnMetrics( ColPos const i_column ) const;
	    virtual bool                isRowSelected( RowPos i_row ) const;


        long                        appFontWidthToPixel( long const i_appFontUnits ) const;

        TableDataWindow&        getDataWindow()       { return *m_pDataWindow; }
        const TableDataWindow&  getDataWindow() const { return *m_pDataWindow; }
	    ScrollBar* getHorzScrollbar();
	    ScrollBar* getVertScrollbar();

	    Rectangle calcHeaderRect( bool bColHeader );
        Rectangle calcHeaderCellRect( bool bColHeader, sal_Int32 nPos );
	    Rectangle calcTableRect();
        Rectangle calcCellRect( sal_Int32 nRow, sal_Int32 nCol );

        // A11Y
        ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >
                        getAccessible( Window& i_parentWindow );
        void            disposeAccessible();

        inline bool     isAccessibleAlive() const { return impl_isAccessibleAlive(); }

        // ITableModelListener
        virtual void    rowsInserted( RowPos first, RowPos last );
        virtual void    rowsRemoved( RowPos first, RowPos last );
        virtual void    columnInserted( ColPos const i_colIndex );
        virtual void    columnRemoved( ColPos const i_colIndex );
        virtual void    allColumnsRemoved();
        virtual void    cellsUpdated( ColPos const i_firstCol, ColPos i_lastCol, RowPos const i_firstRow, RowPos const i_lastRow );
        virtual void    columnChanged( ColPos const i_column, ColumnAttributeGroup const i_attributeGroup );
        virtual void    tableMetricsChanged();

    private:
        bool            impl_isAccessibleAlive() const;
        void            impl_commitAccessibleEvent(
                            sal_Int16 const i_eventID,
                            ::com::sun::star::uno::Any const & i_newValue,
                            ::com::sun::star::uno::Any const & i_oldValue
                        );

        /** toggles the cursor visibility

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.
        */
        void        impl_ni_doSwitchCursor( bool _bOn );

        /** returns the number of visible rows.

            @param _bAcceptPartialRow
                specifies whether a possible only partially visible last row is
                counted, too.
        */
        TableSize   impl_getVisibleRows( bool _bAcceptPartialRow ) const;

        /** returns the number of visible columns

            The value may change with different horizontal scroll positions, as
            different columns have different widths. For instance, if your control is
            100 pixels wide, and has three columns of width 50, 50, 100, respectively,
            then this method will return either "2" or "1", depending on which column
            is the first visible one.

            @param _bAcceptPartialRow
                specifies whether a possible only partially visible last row is
                counted, too.
        */
        TableSize   impl_getVisibleColumns( bool _bAcceptPartialCol ) const;

        /** determines the rectangle occupied by the given cell
        */
        void        impl_getCellRect( ColPos _nColumn, RowPos _nRow, Rectangle& _rCellRect ) const;

        /** updates all cached model values

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.
        */
        void        impl_ni_updateCachedModelValues();

        /** updates the cached table metrics (row height etc.)
        */
        void        impl_ni_updateCachedTableMetrics();

        /** does a relayout of the table control

            Column widths, and consequently the availability of the vertical and horizontal scrollbar, are updated
            with a call to this method.

            @param i_assumeInflexibleColumnsUpToIncluding
                the index of a column up to which all columns should be considered as inflexible, or
                <code>COL_INVALID</code>.
        */
        void        impl_ni_relayout( ColPos const i_assumeInflexibleColumnsUpToIncluding = COL_INVALID );

        /** calculates the new width of our columns, taking into account their min and max widths, and their relative
            flexibility.

            @param i_assumeInflexibleColumnsUpToIncluding
                the index of a column up to which all columns should be considered as inflexible, or
                <code>COL_INVALID</code>.

            @param i_assumeVerticalScrollbar
                controls whether or not we should assume the presence of a vertical scrollbar. If <true/>, and
                if the model has a VerticalScrollbarVisibility != ScrollbarShowNever, the method will leave
                space for a vertical scrollbar.

            @return
                the overall width of the grid, which is available for columns
        */
        long        impl_ni_calculateColumnWidths(
                        ColPos const i_assumeInflexibleColumnsUpToIncluding,
                        bool const i_assumeVerticalScrollbar,
                        ::std::vector< long >& o_newColWidthsPixel
                    ) const;

        /** positions all child windows, e.g. the both scrollbars, the corner window, and the data window
        */
        void        impl_ni_positionChildWindows(
                        Rectangle const & i_dataCellPlayground,
                        bool const i_verticalScrollbar,
                        bool const i_horizontalScrollbar
                    );

        /** scrolls the view by the given number of rows

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.

            @return
                the number of rows by which the viewport was scrolled. This may differ
                from the given numbers to scroll in case the begin or the end of the
                row range were reached.
        */
        TableSize   impl_ni_ScrollRows( TableSize _nRowDelta );

        /** equivalent to impl_ni_ScrollRows, but checks the instances invariants beforehand (in a non-product build only)
        */
        TableSize   impl_scrollRows( TableSize const i_rowDelta );

        /** scrolls the view by the given number of columns

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.

            @return
                the number of columns by which the viewport was scrolled. This may differ
                from the given numbers to scroll in case the begin or the end of the
                column range were reached.
        */
        TableSize   impl_ni_ScrollColumns( TableSize _nColumnDelta );

        /** equivalent to impl_ni_ScrollColumns, but checks the instances invariants beforehand (in a non-product build only)
        */
        TableSize   impl_scrollColumns( TableSize const i_columnDelta );

        /** retrieves the area occupied by the totality of (at least partially) visible cells

            The returned area includes row and column headers. Also, it takes into
            account the fact that there might be less columns than would normally
            find room in the control.

            As a result of respecting the partial visibility of rows and columns,
            the returned area might be larger than the data window's output size.
        */
        Rectangle   impl_getAllVisibleCellsArea() const;

        /** retrieves the area occupied by all (at least partially) visible data cells.

            Effectively, the returned area is the same as returned by ->impl_getAllVisibleCellsArea,
            minus the row and column header areas.
        */
        Rectangle   impl_getAllVisibleDataCellArea() const;

        /** retrieves the column which covers the given ordinate
        */
        ColPos      impl_getColumnForOrdinate( long const i_ordinate ) const;

        /** retrieves the row which covers the given abscissa
        */
        RowPos      impl_getRowForAbscissa( long const i_abscissa ) const;

        /// invalidates the window area occupied by the given column
        void        impl_invalidateColumn( ColPos const i_column );

        DECL_LINK( OnScroll, ScrollBar* );
        DECL_LINK( OnUpdateScrollbars, void* );
    };

	//see seleng.hxx, seleng.cxx, FunctionSet overridables, part of selection engine
	class TableFunctionSet : public FunctionSet
	{
	private:
		TableControl_Impl*  m_pTableControl;
		RowPos              m_nCurrentRow;

	public:
		TableFunctionSet(TableControl_Impl* _pTableControl);
		virtual ~TableFunctionSet();

	   virtual void BeginDrag();
	   virtual void CreateAnchor();
	   virtual void DestroyAnchor();
	   virtual sal_Bool SetCursorAtPoint(const Point& rPoint, sal_Bool bDontSelectAtCursor);
	   virtual sal_Bool IsSelectionAtPoint( const Point& rPoint );
	   virtual void DeselectAtPoint( const Point& rPoint );
	   virtual void DeselectAll();
	};


//........................................................................
} } // namespace svt::table
//........................................................................

#endif // SVTOOLS_TABLECONTROL_IMPL_HXX