tablecontrol_impl.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
#pragma once
 
#include <controls/table/tablemodel.hxx>
#include <controls/table/tablecontrolinterface.hxx>
 
#include <vcl/svtaccessiblefactory.hxx>
#include <vcl/accessibletable.hxx>
 
#include <vcl/seleng.hxx>
 
#include <vector>
 
class ScrollBar;
class ScrollBarBox;
 
namespace svt::table
{
    struct MutableColumnMetrics : public ColumnMetrics
    {
        MutableColumnMetrics()
            :ColumnMetrics()
        {
        }
 
        MutableColumnMetrics( tools::Long const i_startPixel, tools::Long const i_endPixel )
            :ColumnMetrics( i_startPixel, i_endPixel )
        {
        }
 
        tools::Long getStart() const { return nStartPixel; }
        tools::Long getEnd() const { return nEndPixel; }
 
        void move( tools::Long const i_offset ) { nStartPixel += i_offset; nEndPixel += i_offset; }
 
        tools::Long getWidth() const { return nEndPixel - nStartPixel; }
    };
 
    struct ColumnInfoPositionLess
    {
        bool operator()( MutableColumnMetrics const& i_lhs, MutableColumnMetrics const& i_rhs )
        {
            return i_lhs.getEnd() < i_rhs.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:
        TableControl&           m_rAntiImpl;
        PTableModel             m_pModel;
        PTableInputHandler      m_pInputHandler;
        ColumnPositions         m_aColumnWidths;
 
        tools::Long                    m_nRowHeightPixel;
        tools::Long                    m_nColHeaderHeightPixel;
        tools::Long                    m_nRowHeaderWidthPixel;
 
        TableSize               m_nColumnCount;
 
        TableSize               m_nRowCount;
 
        ColPos                  m_nCurColumn;
        RowPos                  m_nCurRow;
        ColPos                  m_nLeftColumn;
        RowPos                  m_nTopRow;
 
        sal_Int32               m_nCursorHidden;
 
        VclPtr<TableDataWindow> m_pDataWindow;
        VclPtr<ScrollBar>       m_pVScroll;
        VclPtr<ScrollBar>       m_pHScroll;
        VclPtr<ScrollBarBox>    m_pScrollCorner;
        //selection engine - for determining selection range, e.g. single, multiple
        std::unique_ptr<SelectionEngine> m_pSelEngine;
        //vector which contains the selected rows
        std::vector<RowPos>     m_aSelectedRows;
        //part of selection engine
        std::unique_ptr<TableFunctionSet> m_pTableFunctionSet;
        //part of selection engine
        RowPos                  m_nAnchor;
        bool                    m_bUpdatingColWidths;
 
        vcl::AccessibleFactoryAccess     m_aFactoryAccess;
        vcl::table::IAccessibleTableControl*    m_pAccessibleTable;
 
    public:
        void        setModel( const PTableModel& _pModel );
 
        const PTableInputHandler&   getInputHandler() const { return m_pInputHandler; }
 
        RowPos  getCurRow() const           { return m_nCurRow; }
 
        RowPos  getAnchor() const { return m_nAnchor; }
        void    setAnchor( RowPos const i_anchor ) { m_nAnchor = i_anchor; }
 
        RowPos  getTopRow() const       { return m_nTopRow; }
        ColPos  getLeftColumn() const { return m_nLeftColumn; }
 
        const TableControl&   getAntiImpl() const { return m_rAntiImpl; }
        TableControl&   getAntiImpl()       { return m_rAntiImpl; }
 
    public:
        explicit TableControl_Impl( TableControl& _rAntiImpl );
        virtual ~TableControl_Impl() override;
 
        void    onResize();
 
        void    doPaintContent(vcl::RenderContext& rRenderContext, const tools::Rectangle& _rUpdateRect);
 
        bool    goTo( ColPos _nColumn, RowPos _nRow );
 
        void    ensureVisible( ColPos _nColumn, RowPos _nRow );
 
        OUString getCellContentAsString( RowPos const i_row, ColPos const i_col );
 
        static int getRowSelectedNumber(const ::std::vector<RowPos>& selectedRows, RowPos current);
 
        void invalidateRect(const tools::Rectangle &rInvalidateRect);
 
        void    invalidateSelectedRegion( RowPos _nPrevRow, RowPos _nCurRow );
 
        void    invalidateRowRange( RowPos const i_firstRow, RowPos const i_lastRow );
 
        void    invalidateRow( RowPos const i_row ) { invalidateRowRange( i_row, i_row ); }
 
        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;
 
        bool        markRowAsDeselected( RowPos const i_rowIndex );
 
        bool        markRowAsSelected( RowPos const i_rowIndex );
 
        bool        markAllRowsAsDeselected();
 
        bool        markAllRowsAsSelected();
 
        void commitAccessibleEvent( sal_Int16 const i_eventID );
        void commitCellEvent( sal_Int16 const i_eventID, const css::uno::Any& i_newValue, const css::uno::Any& i_oldValue );
        void commitTableEvent( sal_Int16 const i_eventID, const css::uno::Any& i_newValue, const css::uno::Any& i_oldValue );
 
        // ITableControl
        virtual void                hideCursor() override;
        virtual void                showCursor() override;
        virtual bool                dispatchAction( TableControlAction _eAction ) override;
        virtual SelectionEngine*    getSelEngine() override;
        virtual PTableModel         getModel() const override;
        virtual ColPos              getCurrentColumn() const override;
        virtual RowPos              getCurrentRow() const override;
        virtual void                activateCell( ColPos const i_col, RowPos const i_row ) override;
        virtual ::Size              getTableSizePixel() const override;
        virtual void                setPointer( PointerStyle i_pointer ) override;
        virtual void                captureMouse() override;
        virtual void                releaseMouse() override;
        virtual void                invalidate( TableArea const i_what ) override;
        virtual tools::Long                pixelWidthToAppFont( tools::Long const i_pixels ) const override;
        virtual void                hideTracking() override;
        virtual void                showTracking( tools::Rectangle const & i_location, ShowTrackFlags const i_flags ) override;
        RowPos                      getRowAtPoint( const Point& rPoint ) const;
        ColPos                      getColAtPoint( const Point& rPoint ) const;
        virtual TableCell           hitTest( const Point& rPoint ) const override;
        virtual ColumnMetrics       getColumnMetrics( ColPos const i_column ) const override;
        virtual bool                isRowSelected( RowPos i_row ) const override;
 
 
        tools::Long                        appFontWidthToPixel( tools::Long const i_appFontUnits ) const;
 
        TableDataWindow&        getDataWindow()       { return *m_pDataWindow; }
        const TableDataWindow&  getDataWindow() const { return *m_pDataWindow; }
        ScrollBar* getHorzScrollbar() { return m_pHScroll; }
        ScrollBar* getVertScrollbar() { return m_pVScroll; }
 
        tools::Rectangle calcHeaderRect( bool bColHeader );
        tools::Rectangle calcHeaderCellRect( bool bColHeader, sal_Int32 nPos );
        tools::Rectangle calcTableRect() const;
        tools::Rectangle calcCellRect( sal_Int32 nRow, sal_Int32 nCol ) const;
 
        // A11Y
        css::uno::Reference< css::accessibility::XAccessible >
                        getAccessible( vcl::Window& i_parentWindow );
        void            disposeAccessible();
 
        bool     isAccessibleAlive() const { return impl_isAccessibleAlive(); }
 
        // ITableModelListener
        virtual void    rowsInserted( RowPos first, RowPos last ) override;
        virtual void    rowsRemoved( RowPos first, RowPos last ) override;
        virtual void    columnInserted() override;
        virtual void    columnRemoved() override;
        virtual void    allColumnsRemoved() override;
        virtual void    cellsUpdated( RowPos const i_firstRow, RowPos const i_lastRow ) override;
        virtual void    columnChanged( ColPos const i_column, ColumnAttributeGroup const i_attributeGroup ) override;
        virtual void    tableMetricsChanged() override;
 
    private:
        bool            impl_isAccessibleAlive() const;
        void            impl_commitAccessibleEvent(
                            sal_Int16 const i_eventID,
                            css::uno::Any const & i_newValue
                        );
 
        void        impl_ni_doSwitchCursor( bool _bOn );
 
        TableSize   impl_getVisibleRows( bool _bAcceptPartialRow ) const;
 
        TableSize   impl_getVisibleColumns( bool _bAcceptPartialCol ) const;
 
        void        impl_getCellRect( ColPos _nColumn, RowPos _nRow, tools::Rectangle& _rCellRect ) const;
 
        void        impl_ni_updateCachedModelValues();
 
        void        impl_ni_updateCachedTableMetrics();
 
        void        impl_ni_relayout( ColPos const i_assumeInflexibleColumnsUpToIncluding = COL_INVALID );
 
        tools::Long        impl_ni_calculateColumnWidths(
                        ColPos const i_assumeInflexibleColumnsUpToIncluding,
                        bool const i_assumeVerticalScrollbar,
                        ::std::vector< tools::Long >& o_newColWidthsPixel
                    ) const;
 
        void        impl_ni_positionChildWindows(
                        tools::Rectangle const & i_dataCellPlayground,
                        bool const i_verticalScrollbar,
                        bool const i_horizontalScrollbar
                    );
 
        TableSize   impl_ni_ScrollRows( TableSize _nRowDelta );
 
        TableSize   impl_scrollRows( TableSize const i_rowDelta );
 
        TableSize   impl_ni_ScrollColumns( TableSize _nColumnDelta );
 
        TableSize   impl_scrollColumns( TableSize const i_columnDelta );
 
        tools::Rectangle   impl_getAllVisibleCellsArea() const;
 
        tools::Rectangle   impl_getAllVisibleDataCellArea() const;
 
        ColPos      impl_getColumnForOrdinate( tools::Long const i_ordinate ) const;
 
        RowPos      impl_getRowForAbscissa( tools::Long const i_abscissa ) const;
 
        void        impl_invalidateColumn( ColPos const i_column );
 
        DECL_LINK( OnScroll, ScrollBar*, void );
        DECL_LINK( OnUpdateScrollbars, void*, 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:
        explicit TableFunctionSet(TableControl_Impl* _pTableControl);
        virtual ~TableFunctionSet() override;
 
        virtual void BeginDrag() override;
        virtual void CreateAnchor() override;
        virtual void DestroyAnchor() override;
        virtual void SetCursorAtPoint(const Point& rPoint, bool bDontSelectAtCursor = false) override;
        virtual bool IsSelectionAtPoint( const Point& rPoint ) override;
        virtual void DeselectAtPoint( const Point& rPoint ) override;
        virtual void DeselectAll() override;
    };
 
 
} // namespace svt::table
 
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */