From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- include/svtools/brwbox.hxx | 849 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 849 insertions(+) create mode 100644 include/svtools/brwbox.hxx (limited to 'include/svtools/brwbox.hxx') diff --git a/include/svtools/brwbox.hxx b/include/svtools/brwbox.hxx new file mode 100644 index 000000000..6f65c6b30 --- /dev/null +++ b/include/svtools/brwbox.hxx @@ -0,0 +1,849 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +class BrowserColumn; +class BrowserHeader; +class ScrollBar; +class MeasureStatusBar; + +namespace svt { + class BrowseBoxImpl; +} + +namespace utl { + class AccessibleStateSetHelper; +} + +namespace vcl { + class IAccessibleFactory; +} + +#define BROWSER_INVALIDID SAL_MAX_UINT16 +constexpr sal_Int32 BROWSER_ENDOFSELECTION = SFX_ENDOFSELECTION; + +enum class BrowserMode +{ + NONE = 0x000000, + COLUMNSELECTION = 0x000001, + MULTISELECTION = 0x000002, + KEEPHIGHLIGHT = 0x000008, + HLINES = 0x000010, + VLINES = 0x000020, + + HIDESELECT = 0x000100, + HIDECURSOR = 0x000200, + + NO_HSCROLL = 0x000400, + + AUTO_VSCROLL = 0x001000, + AUTO_HSCROLL = 0x002000, + + TRACKING_TIPS = 0x004000, + + NO_VSCROLL = 0x008000, + + HEADERBAR_NEW = 0x040000, + AUTOSIZE_LASTCOL = 0x080000, + + CURSOR_WO_FOCUS = 0x200000, + // Allows a cursor which is shown even if the control does not have the focus. This does not affect other + // situations which require to temporarily hide the cursor (such as scrolling). + +}; +namespace o3tl +{ + template<> struct typed_flags : is_typed_flags {}; +} + +#define BROWSER_NONE 0 +#define BROWSER_SELECT 720 +#define BROWSER_ENHANCESELECTION 722 +#define BROWSER_SELECTDOWN 724 +#define BROWSER_SELECTUP 725 +#define BROWSER_CURSORDOWN 731 +#define BROWSER_CURSORUP 732 +#define BROWSER_CURSORLEFT 733 +#define BROWSER_CURSORRIGHT 734 +#define BROWSER_CURSORPAGEDOWN 735 +#define BROWSER_CURSORPAGEUP 736 +#define BROWSER_CURSORENDOFFILE 741 +#define BROWSER_CURSORTOPOFFILE 742 +#define BROWSER_CURSORENDOFSCREEN 743 +#define BROWSER_CURSORTOPOFSCREEN 744 +#define BROWSER_CURSORHOME 745 +#define BROWSER_CURSOREND 746 +#define BROWSER_SCROLLDOWN 751 +#define BROWSER_SCROLLUP 752 +#define BROWSER_SELECTHOME 753 +#define BROWSER_SELECTEND 754 +#define BROWSER_SELECTCOLUMN 755 +#define BROWSER_MOVECOLUMNLEFT 756 +#define BROWSER_MOVECOLUMNRIGHT 757 + + +class BrowseEvent +{ + VclPtr pWin; + tools::Rectangle aRect; + sal_Int32 nRow; + sal_uInt16 nCol; + sal_uInt16 nColId; + +public: + BrowseEvent( vcl::Window* pWindow, + sal_Int32 nAbsRow, + sal_uInt16 nColumn, sal_uInt16 nColumnId, + const tools::Rectangle& rRect ); + + vcl::Window* GetWindow() const { return pWin; } + sal_Int32 GetRow() const { return nRow; } + sal_uInt16 GetColumn() const { return nCol; } + sal_uInt16 GetColumnId() const { return nColId; } + const tools::Rectangle& GetRect() const { return aRect; } +}; + +class BrowseBox; +class ScrollBarBox; +class BrowserMouseEvent; + +class BrowserDataWin final + :public Control + ,public DragSourceHelper + ,public DropTargetHelper +{ +public: + VclPtr pHeaderBar; // only for BrowserMode::HEADERBAR_NEW + VclPtr pCornerWin; // Window in the corner btw the ScrollBars + bool bInDtor; + AutoTimer aMouseTimer; // recalls MouseMove on dragging out + MouseEvent aRepeatEvt; // a MouseEvent to repeat + Point aLastMousePos; // prevents pseudo-MouseMoves + + OUString aRealRowCount; // to show in VScrollBar + + std::vector aInvalidRegion; // invalidated Rectangles during !UpdateMode + bool bInPaint; // TRUE while in Paint + bool bInCommand; // TRUE while in Command + bool bNoHScroll; // no horizontal scrollbar + bool bNoVScroll; // no vertical scrollbar + bool bAutoHScroll; // autohide horizontaler Scrollbar + bool bAutoVScroll; // autohide horizontaler Scrollbar + bool bUpdateMode; // not SV-UpdateMode because of Invalidate() + bool bAutoSizeLastCol; // last column always fills up window + bool bResizeOnPaint; // outstanding resize-event + bool bUpdateOnUnlock; // Update() while locked + bool bInUpdateScrollbars; // prevents recursions + bool bHadRecursion; // a recursion occurred + bool bCallingDropCallback; // we're in a callback to AcceptDrop or ExecuteDrop currently + sal_uInt16 nUpdateLock; // lock count, don't call Control::Update()! + short nCursorHidden; // new counter for DoHide/ShowCursor + + tools::Long m_nDragRowDividerLimit; + tools::Long m_nDragRowDividerOffset; + +public: + explicit BrowserDataWin( BrowseBox* pParent ); + virtual ~BrowserDataWin() override; + virtual void dispose() override; + + virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + virtual void RequestHelp( const HelpEvent& rHEvt ) override; + virtual void Command( const CommandEvent& rEvt ) override; + virtual void MouseButtonDown( const MouseEvent& rEvt ) override; + virtual void MouseMove( const MouseEvent& rEvt ) override; + DECL_LINK( RepeatedMouseMove, Timer *, void ); + + virtual void MouseButtonUp( const MouseEvent& rEvt ) override; + virtual void KeyInput( const KeyEvent& rEvt ) override; + virtual void Tracking( const TrackingEvent& rTEvt ) override; + + // DropTargetHelper overridables + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override; + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override; + + // DragSourceHelper overridables + virtual void StartDrag( sal_Int8 _nAction, const Point& _rPosPixel ) override; + + + BrowseEvent CreateBrowseEvent( const Point& rPosPixel ); + BrowseBox* GetParent() const; + const OUString& GetRealRowCount() const { return aRealRowCount; } + + void SetUpdateMode( bool bMode ); + bool GetUpdateMode() const { return bUpdateMode; } + void EnterUpdateLock() { ++nUpdateLock; } + void LeaveUpdateLock(); + void Update(); + void DoOutstandingInvalidations(); + void Invalidate( InvalidateFlags nFlags = InvalidateFlags::NONE ) override; + void Invalidate( const tools::Rectangle& rRect, InvalidateFlags nFlags = InvalidateFlags::NONE ) override; + using Control::Invalidate; + +private: + void StartRowDividerDrag( const Point& _rStartPos ); + bool ImplRowDividerHitTest( const BrowserMouseEvent& _rEvent ) const; +}; + +class BrowserMouseEvent: public MouseEvent, public BrowseEvent +{ +public: + BrowserMouseEvent( BrowserDataWin* pWin, const MouseEvent& rEvt ); + BrowserMouseEvent( vcl::Window* pWin, const MouseEvent& rEvt, + sal_Int32 nAbsRow, sal_uInt16 nColumn, sal_uInt16 nColumnId, + const tools::Rectangle& rRect ); +}; + + +class BrowserAcceptDropEvent : public AcceptDropEvent, public BrowseEvent +{ +public: + BrowserAcceptDropEvent( BrowserDataWin* pWin, const AcceptDropEvent& rEvt ); +}; + + +class BrowserExecuteDropEvent : public ExecuteDropEvent, public BrowseEvent +{ +public: + BrowserExecuteDropEvent( BrowserDataWin* pWin, const ExecuteDropEvent& rEvt ); +}; + +// TODO +// The whole selection thingie in this class is somewhat... suspicious to me. +// some oddities: +// * method parameters named like members (and used in both semantics within the method!) +// * the multi selection flag is sometimes used as if it is for row selection, sometimes as if +// it's for column selection, too (and sometimes in an even stranger way :) +// * it is not really defined like all these hundreds selection related flags/methods work together +// and influence each other. I do not understand it very well, but this may be my fault :) +// * There is a GetColumnSelection, but it can't be used to determine the selected columns (at least +// not without a const_cast) +// +// We should clearly define this somewhere in the future. Or, even better, we should re-implement this +// whole class, which is planned for a long time :) +// +// sorry for the ranting. could not resist + +class SVT_DLLPUBLIC BrowseBox + :public Control + ,public DragSourceHelper + ,public DropTargetHelper + ,public vcl::IAccessibleTableProvider +{ + friend class BrowserDataWin; + friend class ::svt::BrowseBoxImpl; + +public: + static const sal_uInt16 HandleColumnId = 0; + +private: + VclPtr pDataWin; // window to display data rows + VclPtr pVScroll; // vertical scrollbar + VclPtr aHScroll; // horizontal scrollbar + VclPtr aStatusBarHeight; // statusbar, just to measure its height + + tools::Long m_nDataRowHeight; // height of a single data-row + sal_uInt16 nTitleLines; // number of lines in title row + sal_uLong nControlAreaWidth; // width of fixed area beneath hscroll + bool bColumnCursor; // single columns and fields selectable + bool bMultiSelection;// allow multiple selected rows + bool bKeepHighlight; // don't hide selection on LoseFocus + + bool bHLines; // draw lines between rows + bool bVLines; // draw lines between columns + bool bBootstrapped; // child windows resized etc. + sal_Int32 nTopRow; // no. of first visible row (0...) + sal_Int32 nCurRow; // no. of row with cursor + sal_Int32 nRowCount; // total number of rows in model + sal_uInt16 nFirstCol; // no. of first visible scrollable column + sal_uInt16 nCurColId; // column id of cursor + + bool bSelecting; + bool bRowDividerDrag; + bool bHit; + bool mbInteractiveRowHeight; + + tools::Long nResizeX; // mouse position at start of resizing + tools::Long nMinResizeX; // never drag more left + tools::Long nDragX; // last dragged column (MouseMove) + sal_uInt16 nResizeCol; // resize this column in MouseMove + bool bResizing; // mouse captured for column resizing + + bool bSelect; /// select or deselect + bool bSelectionIsVisible; // depending on focus + bool bScrolling; // hidden cursor while scrolling + bool bNotToggleSel; // set while in ToggleSelection() etc. + bool bHasFocus; // set/unset in Get/LoseFocus + bool bHideSelect; // hide selection (highlight) + TriState bHideCursor; // hide cursor (frame) + Range aSelRange; // for selection expansion + + ::std::vector< std::unique_ptr > mvCols; // array of column-descriptions + union + { + MultiSelection* pSel; // selected rows for multi-selection + sal_Int32 nSel; // selected row for single-selection + } uRow; + std::unique_ptr pColSel; // selected column-ids + + // fdo#83943, detect if making the cursor position visible is impossible to achieve + struct CursorMoveAttempt + { + sal_Int32 m_nCol; + sal_Int32 m_nRow; + bool m_bScrolledToReachCell; + CursorMoveAttempt(sal_Int32 nCol, sal_Int32 nRow, bool bScrolledToReachCell) + : m_nCol(nCol) + , m_nRow(nRow) + , m_bScrolledToReachCell(bScrolledToReachCell) + { + } + bool operator==(const CursorMoveAttempt& r) const + { + return m_nCol == r.m_nCol && + m_nRow == r.m_nRow && + m_bScrolledToReachCell == r.m_bScrolledToReachCell; + } + bool operator!=(const CursorMoveAttempt& r) const { return !(*this == r); } + }; + std::stack + m_aGotoStack; + + ::std::unique_ptr< ::svt::BrowseBoxImpl > m_pImpl; // impl structure of the BrowseBox object + + bool m_bFocusOnlyCursor; // hide cursor if we don't have the focus + Color m_aCursorColor; // special color for cursor, COL_TRANSPARENT for usual (VCL-painted) "inverted" cursor + BrowserMode m_nCurrentMode; // last argument of SetMode (redundant, as our other members represent the current settings, too) + +private: + SVT_DLLPRIVATE void ConstructImpl(BrowserMode nMode); + SVT_DLLPRIVATE void ExpandRowSelection( const BrowserMouseEvent& rEvt ); + SVT_DLLPRIVATE void ToggleSelection(); + + SVT_DLLPRIVATE void UpdateScrollbars(); + SVT_DLLPRIVATE void AutoSizeLastColumn(); + + SVT_DLLPRIVATE tools::Long ImpGetDataRowHeight() const; + SVT_DLLPRIVATE tools::Rectangle ImplFieldRectPixel( sal_Int32 nRow, sal_uInt16 nColId ) const; + SVT_DLLPRIVATE sal_uInt16 FrozenColCount() const; + + SVT_DLLPRIVATE void ColumnInserted( sal_uInt16 nPos ); + + DECL_DLLPRIVATE_LINK( ScrollHdl, ScrollBar*, void ); + DECL_DLLPRIVATE_LINK( StartDragHdl, HeaderBar*, void ); + + SVT_DLLPRIVATE tools::Long GetFrozenWidth() const; + + SVT_DLLPRIVATE tools::Long GetBarHeight() const; + + bool GoToRow(sal_Int32 nRow, bool bRowColMove, bool bDoNotModifySelection = false ); + + bool GoToColumnId( sal_uInt16 nColId, bool bMakeVisible, bool bRowColMove = false); + void SelectColumnPos( sal_uInt16 nCol, bool _bSelect, bool bMakeVisible); + + void ImplPaintData(OutputDevice& _rOut, const tools::Rectangle& _rRect, bool _bForeignDevice); + + bool PaintCursorIfHiddenOnce() const { return !m_bFocusOnlyCursor && !HasFocus(); } + + sal_uInt16 ToggleSelectedColumn(); + void SetToggledSelectedColumn(sal_uInt16 _nSelectedColumnId); + +protected: + /// retrieves the XAccessible implementation associated with the BrowseBox instance + ::vcl::IAccessibleFactory& getAccessibleFactory(); + +protected: + sal_uInt16 ColCount() const; + + // software plug for database access + // RowCount is counted automatically + // (with the help of RowInserted and RowRemoved), so overriding of + // the method is needless +public: + virtual sal_Int32 GetRowCount() const override; + +protected: + // for display in VScrollBar set it e.g. on "?" + void SetRealRowCount( const OUString &rRealRowCount ); + + // Return Value has to be sal_True always - SeekRow *has* to work! + // (else ASSERT) MI: who integrated that? It must not be like that! + + /** seeks for the given row position + @param nRow + nRow starts at 0 + */ + virtual bool SeekRow( sal_Int32 nRow ) = 0; + void DrawCursor(); + void PaintData(vcl::Window const & rWin, vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect); + virtual void PaintField(vcl::RenderContext& rDev, const tools::Rectangle& rRect, sal_uInt16 nColumnId) const = 0; + // Advice for the subclass: the visible scope of rows has changed. + // The subclass is able to announce changes of the model with the + // help of the methods RowInserted and RowRemoved. Because of the + // new status a paint is induced (SeekRow is called etc). + // + // parameters: nNewTopRow: number of the new TopRow (can get changed from + // VisibleRowsChanged by request of RowInserted and RowDeleted). + // nNumRows: number of visible rows (a partial visible row is counted too) + // + // Possible reason for changing the visible scope: + // - in front of the visible scope rows were inserted or removed, so the + // numbering of the visible scope has changed + // - Scrolling (and thereof resulting in another first visible row) + // - Resize the window + virtual void VisibleRowsChanged( sal_Int32 nNewTopRow, sal_uInt16 nNumRows); + + // number of visible rows in the window (incl. "truncated" rows) + sal_uInt16 GetVisibleRows() const; + sal_Int32 GetTopRow() const { return nTopRow; } + sal_uInt16 GetFirstVisibleColNumber() const { return nFirstCol; } + + // Focus-Rect enable / disable + void DoShowCursor(); + void DoHideCursor(); + short GetCursorHideCount() const; + + virtual VclPtr CreateHeaderBar( BrowseBox* pParent ); + + // HACK(virtual create is not called in Ctor) + void SetHeaderBar( BrowserHeader* ); + + tools::Long CalcReverseZoom(tools::Long nVal) const; + + const DataFlavorExVector& + GetDataFlavors() const; + + bool IsDropFormatSupported( SotClipboardFormatId nFormat ) const; // need this because the base class' IsDropFormatSupported is not const ... + + void DisposeAccessible(); + +protected: + // callbacks for the data window + virtual void ImplStartTracking(); + virtual void ImplEndTracking(); + +public: + BrowseBox( vcl::Window* pParent, WinBits nBits, + BrowserMode nMode = BrowserMode::NONE ); + virtual ~BrowseBox() override; + virtual void dispose() override; + + // override inherited handler + virtual void StateChanged( StateChangedType nStateChange ) override; + virtual void MouseButtonDown( const MouseEvent& rEvt ) override; + virtual void MouseMove( const MouseEvent& rEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rEvt ) override; + virtual void KeyInput( const KeyEvent& rEvt ) override; + virtual void LoseFocus() override; + virtual void GetFocus() override; + virtual void Resize() override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void Draw( OutputDevice* pDev, const Point& rPos, SystemTextColorFlags nFlags ) override; + virtual void Command( const CommandEvent& rEvt ) override; + virtual void StartDrag( sal_Int8 _nAction, const Point& _rPosPixel ) override; + + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override; // will forward everything got to the second AcceptDrop method + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override; // will forward everything got to the second ExecuteDrop method + + virtual sal_Int8 AcceptDrop( const BrowserAcceptDropEvent& rEvt ); + virtual sal_Int8 ExecuteDrop( const BrowserExecuteDropEvent& rEvt ); + + // new handlers + virtual void MouseButtonDown( const BrowserMouseEvent& rEvt ); + virtual void MouseButtonUp( const BrowserMouseEvent& rEvt ); + void StartScroll(); + virtual void EndScroll(); + virtual void Select(); + virtual void DoubleClick( const BrowserMouseEvent& rEvt ); + virtual bool IsCursorMoveAllowed( sal_Int32 nNewRow, sal_uInt16 nNewColId ) const; + virtual void CursorMoved(); + virtual void ColumnMoved( sal_uInt16 nColId ); + virtual void ColumnResized( sal_uInt16 nColId ); + /// called when the row height has been changed interactively + virtual void RowHeightChanged(); + virtual tools::Long QueryMinimumRowHeight(); + + // Window-Control (pass to DataWindow) + void SetUpdateMode( bool bUpdate ); + bool GetUpdateMode() const; + + // map-mode and font control + void SetFont( const vcl::Font& rNewFont ); + const vcl::Font& GetFont() const; + void SetTitleFont( const vcl::Font& rNewFont ) + { Control::SetFont( rNewFont ); } + + // inserting, changing, removing and freezing of columns + void InsertHandleColumn( sal_uLong nWidth ); + void InsertDataColumn( sal_uInt16 nItemId, const OUString& rText, + tools::Long nSize, HeaderBarItemBits nBits = HeaderBarItemBits::STDSTYLE, + sal_uInt16 nPos = HEADERBAR_APPEND ); + void SetColumnTitle( sal_uInt16 nColumnId, const OUString &rTitle ); + void SetColumnWidth( sal_uInt16 nColumnId, sal_uLong nWidth ); + void SetColumnPos( sal_uInt16 nColumnId, sal_uInt16 nPos ); + void FreezeColumn( sal_uInt16 nColumnId ); + void RemoveColumn( sal_uInt16 nColumnId ); + void RemoveColumns(); + + // control of title and data row height + void SetDataRowHeight( tools::Long nPixel ); + tools::Long GetDataRowHeight() const; + void SetTitleLines( sal_uInt16 nLines ); + tools::Long GetTitleHeight() const; + + // access to dynamic values of cursor row + OUString GetColumnTitle( sal_uInt16 nColumnId ) const; + tools::Rectangle GetFieldRect( sal_uInt16 nColumnId ) const; + sal_uLong GetColumnWidth( sal_uInt16 nColumnId ) const; + sal_uInt16 GetColumnId( sal_uInt16 nPos ) const; + sal_uInt16 GetColumnPos( sal_uInt16 nColumnId ) const; + bool IsFrozen( sal_uInt16 nColumnId ) const; + + // movement of visible area + sal_Int32 ScrollColumns( sal_Int32 nColumns ); + sal_Int32 ScrollRows( sal_Int32 nRows ); + void MakeFieldVisible( sal_Int32 nRow, sal_uInt16 nColId ); + + // access and movement of cursor + sal_Int32 GetCurRow() const { return nCurRow; } + sal_uInt16 GetCurColumnId() const { return nCurColId; } + bool GoToRow( sal_Int32 nRow ); + bool GoToColumnId( sal_uInt16 nColId ); + bool GoToRowColumnId( sal_Int32 nRow, sal_uInt16 nColId ); + + // selections + virtual void SetNoSelection() override; + virtual void SelectAll() override; + virtual void SelectRow( sal_Int32 nRow, bool _bSelect = true, bool bExpand = true ) override; + void SelectColumnPos( sal_uInt16 nCol, bool _bSelect = true ) + { SelectColumnPos( nCol, _bSelect, true); } + void SelectColumnId( sal_uInt16 nColId ) + { SelectColumnPos( GetColumnPos(nColId), true, true); } + sal_Int32 GetSelectRowCount() const; + sal_uInt16 GetSelectColumnCount() const; + virtual bool IsRowSelected( sal_Int32 nRow ) const override; + bool IsColumnSelected( sal_uInt16 nColumnId ) const; + sal_Int32 FirstSelectedRow(); + sal_Int32 LastSelectedRow(); + sal_Int32 NextSelectedRow(); + const MultiSelection* GetColumnSelection() const { return pColSel.get(); } + const MultiSelection* GetSelection() const + { return bMultiSelection ? uRow.pSel : nullptr; } + + sal_Int32 FirstSelectedColumn( ) const; + + bool IsResizing() const { return bResizing; } + + // access to positions of fields, column and rows + BrowserDataWin& GetDataWindow() const; + tools::Rectangle GetRowRectPixel( sal_Int32 nRow ) const; + tools::Rectangle GetFieldRectPixel( sal_Int32 nRow, sal_uInt16 nColId, + bool bRelToBrowser = true) const; + bool IsFieldVisible( sal_Int32 nRow, sal_uInt16 nColId, + bool bComplete = false ) const; + sal_Int32 GetRowAtYPosPixel( tools::Long nY, + bool bRelToBrowser = true ) const; + sal_uInt16 GetColumnAtXPosPixel( tools::Long nX ) const; + + // invalidations + void Clear(); + void RowRemoved( sal_Int32 nRow, sal_Int32 nNumRows = 1, bool bDoPaint = true ); + void RowModified( sal_Int32 nRow, sal_uInt16 nColId = BROWSER_INVALIDID ); + void RowInserted( sal_Int32 nRow, sal_Int32 nNumRows = 1, bool bDoPaint = true, bool bKeepSelection = false ); + + // miscellaneous + bool ReserveControlArea(sal_uInt16 nWidth = USHRT_MAX); + tools::Rectangle GetControlArea() const; + virtual bool ProcessKey(const KeyEvent& rEvt); + virtual void ChildFocusIn(); + virtual void ChildFocusOut(); + void Dispatch( sal_uInt16 nId ); + void SetMode( BrowserMode nMode ); + BrowserMode GetMode( ) const { return m_nCurrentMode; } + + void SetCursorColor(const Color& _rCol); + + /** specifies that the user is allowed to interactively change the height of a row, + by simply dragging an arbitrary row separator. + + Note that this works only if there's a handle column, since only in this case, + there *is* something for the user to click onto + */ + void EnableInteractiveRowHeight() { mbInteractiveRowHeight = true; } + bool IsInteractiveRowHeightEnabled( ) const { return mbInteractiveRowHeight; } + + /// access to selected methods, to be granted to the BrowserColumn + struct BrowserColumnAccess { friend class BrowserColumn; private: BrowserColumnAccess() { } }; + /** public version of PaintField, with selected access rights for the BrowserColumn + */ + void DoPaintField( OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColumnId, BrowserColumnAccess ) const + { PaintField( rDev, rRect, nColumnId ); } + + /** suggests a default width for a column containing a given text + + The width is calculated so that the text fits completely, plus some margin. + */ + sal_uLong GetDefaultColumnWidth( const OUString& _rText ) const; + + /** GetCellText returns the text at the given position + @param _nRow + the number of the row + @param _nColId + the ID of the column + @return + the text out of the cell + */ + virtual OUString GetCellText(sal_Int32 _nRow, sal_uInt16 _nColId) const; + + /** @return + the current column count + */ + sal_uInt16 GetColumnCount() const override { return ColCount(); } + + /** commitBrowseBoxEvent commit the event at all listeners of the browsebox + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + void commitBrowseBoxEvent(sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue); + + /** commitTableEvent commit the event at all listeners of the table + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + void commitTableEvent(sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue); + + /** fires an AccessibleEvent relative to a header bar AccessibleContext + + @param nEventId + the event id + @param rNewValue + the new value + @param rOldValue + the old value + */ + void commitHeaderBarEvent(sal_Int16 nEventId, + const css::uno::Any& rNewValue, + const css::uno::Any& rOldValue, + bool _bColumnHeaderBar + ); + + /** returns the Rectangle for either the column header bar or the row header bar + @param _bIsColumnBar + when column header bar is used + @param _bOnScreen + when the rectangle should be calculated OnScreen + @return + the Rectangle + */ + virtual tools::Rectangle calcHeaderRect(bool _bIsColumnBar, bool _bOnScreen = true) override; + + /** calculates the Rectangle of the table + @param _bOnScreen + when the rectangle should be calculated OnScreen + @return + the Rectangle + */ + virtual tools::Rectangle calcTableRect(bool _bOnScreen = true) override; + + /** + @param _nRowId + the current row + @param _nColId + the column id + @param _bOnScreen + when the rectangle should be calculated OnScreen + @return + the Rectangle + */ + virtual tools::Rectangle GetFieldRectPixelAbs(sal_Int32 _nRowId, sal_uInt16 _nColId, bool _bIsHeader, bool _bOnScreen = true) override; + + /// return if and only if the accessible object for this instance has been created and is alive + bool isAccessibleAlive( ) const; + +public: + /** Creates and returns the accessible object of the whole BrowseBox. */ + virtual css::uno::Reference< + css::accessibility::XAccessible > CreateAccessible() override; + + // Children --------------------------------------------------------------- + + /** Creates the accessible object of a data table cell. + @param nRow The row index of the cell. + @param nColumnId The column pos of the cell. + @return The XAccessible interface of the specified cell. */ + virtual css::uno::Reference< + css::accessibility::XAccessible > + CreateAccessibleCell( sal_Int32 nRow, sal_uInt16 nColumnPos ) override; + + /** Creates the accessible object of a row header. + @param nRow The row index of the header. + @return The XAccessible interface of the specified row header. */ + virtual css::uno::Reference< + css::accessibility::XAccessible > + CreateAccessibleRowHeader( sal_Int32 nRow ) override; + + /** Creates the accessible object of a column header. + @param nColumnId The column ID of the header. + @return The XAccessible interface of the specified column header. */ + virtual css::uno::Reference< + css::accessibility::XAccessible > + CreateAccessibleColumnHeader( sal_uInt16 nColumnPos ) override; + + /** @return The count of additional controls of the control area. */ + virtual sal_Int32 GetAccessibleControlCount() const override; + + /** Creates the accessible object of an additional control. + @param nIndex The 0-based index of the control. + @return The XAccessible interface of the specified control. */ + virtual css::uno::Reference< + css::accessibility::XAccessible > + CreateAccessibleControl( sal_Int32 nIndex ) override; + + /** Converts a point relative to the data window origin to a cell address. + @param rnRow Out-parameter that takes the row index. + @param rnColumnId Out-parameter that takes the column ID. + @param rPoint The position in pixels relative to the data window. + @return , if the point could be converted to a valid address. */ + virtual bool ConvertPointToCellAddress( + sal_Int32& rnRow, sal_uInt16& rnColumnId, const Point& rPoint ) override; + + /** Converts a point relative to the row header bar origin to a row header + index. + @param rnRow Out-parameter that takes the row index. + @param rPoint The position in pixels relative to the header bar. + @return , if the point could be converted to a valid index. */ + virtual bool ConvertPointToRowHeader( sal_Int32& rnRow, const Point& rPoint ) override; + + /** Converts a point relative to the column header bar origin to a column + header index. + @param rnColumnId Out-parameter that takes the column ID. + @param rPoint The position in pixels relative to the header bar. + @return , if the point could be converted to a valid index. */ + virtual bool ConvertPointToColumnHeader( sal_uInt16& rnColumnPos, const Point& rPoint ) override; + + /** Converts a point relative to the BrowseBox origin to the index of an + existing control. + @param rnRow Out-parameter that takes the 0-based control index. + @param rPoint The position in pixels relative to the BrowseBox. + @return , if the point could be converted to a valid index. */ + virtual bool ConvertPointToControlIndex( sal_Int32& rnIndex, const Point& rPoint ) override; + + /** return the name of the specified object. + @param eObjType + The type to ask for + @param _nPosition + The position of a tablecell (index position), header bar column/row cell + @return + The name of the specified object. + */ + virtual OUString GetAccessibleObjectName( AccessibleBrowseBoxObjType eObjType,sal_Int32 _nPosition = -1) const override; + + /** return the description of the specified object. + @param eObjType + The type to ask for + @param _nPosition + The position of a tablecell (index position), header bar column/row cell + @return + The description of the specified object. + */ + virtual OUString GetAccessibleObjectDescription( AccessibleBrowseBoxObjType eObjType,sal_Int32 _nPosition = -1) const override; + + /** @return The header text of the specified row. */ + virtual OUString GetRowDescription( sal_Int32 nRow ) const override; + + /** @return The header text of the specified column. */ + virtual OUString GetColumnDescription( sal_uInt16 _nColumn ) const override; + + /** Fills the StateSet with all states (except DEFUNC and SHOWING, done by + the accessible object), depending on the specified object type. */ + virtual void FillAccessibleStateSet( + ::utl::AccessibleStateSetHelper& rStateSet, + AccessibleBrowseBoxObjType eObjType ) const override; + + /** Fills the StateSet with all states for one cell (except DEFUNC and SHOWING, done by + the accessible object). */ + virtual void FillAccessibleStateSetForCell( + ::utl::AccessibleStateSetHelper& _rStateSet, + sal_Int32 _nRow, sal_uInt16 _nColumn ) const override; + + /** Sets focus to current cell of the data table. */ + virtual void GrabTableFocus() override; + + // IAccessibleTableProvider + virtual sal_Int32 GetCurrRow() const override; + virtual sal_uInt16 GetCurrColumn() const override; + virtual bool HasRowHeader() const override; + virtual bool GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn ) override; + virtual void SelectColumn( sal_uInt16 _nColumn, bool _bSelect = true ) override; + virtual bool IsColumnSelected( sal_Int32 _nColumn ) const override; + virtual sal_Int32 GetSelectedRowCount() const override; + virtual sal_Int32 GetSelectedColumnCount() const override; + virtual void GetAllSelectedRows( css::uno::Sequence< sal_Int32 >& _rRows ) const override; + virtual void GetAllSelectedColumns( css::uno::Sequence< sal_Int32 >& _rColumns ) const override; + virtual bool IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumn ) const override; + virtual OUString GetAccessibleCellText(sal_Int32 _nRow, sal_uInt16 _nColPos) const override; + virtual bool GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, int nLen, std::vector< tools::Rectangle >& rVector ) override; + virtual tools::Rectangle GetWindowExtentsRelative(const vcl::Window *pRelativeWindow) const override; + virtual void GrabFocus() override; + virtual css::uno::Reference< css::accessibility::XAccessible > GetAccessible() override; + virtual vcl::Window* GetAccessibleParentWindow() const override; + virtual vcl::Window* GetWindowInstance() override; + +private: + // the following declares some Window/OutputDevice methods private. This happened in the course + // of CWS warnings01, which pointed out nameclashs in those methods. If the build breaks in some + // upper module, you should investigate whether you really wanted to call base class methods, + // or the versions at this class. In the latter case, use the renamed versions above. + + // ToTop/ToBottom were never property implemented. If you currently call it, this is most probably wrong + // and not doing as intended + using Window::ToTop; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3