summaryrefslogtreecommitdiffstats
path: root/svtools/source/brwbox
diff options
context:
space:
mode:
Diffstat (limited to 'svtools/source/brwbox')
-rw-r--r--svtools/source/brwbox/brwbox1.cxx2347
-rw-r--r--svtools/source/brwbox/brwbox2.cxx1972
-rw-r--r--svtools/source/brwbox/brwbox3.cxx559
-rw-r--r--svtools/source/brwbox/brwhead.cxx107
-rw-r--r--svtools/source/brwbox/brwimpl.hxx80
-rw-r--r--svtools/source/brwbox/datwin.cxx691
-rw-r--r--svtools/source/brwbox/datwin.hxx189
-rw-r--r--svtools/source/brwbox/ebbcontrols.cxx566
-rw-r--r--svtools/source/brwbox/editbrowsebox.cxx1326
-rw-r--r--svtools/source/brwbox/editbrowsebox2.cxx200
-rw-r--r--svtools/source/brwbox/editbrowseboximpl.hxx35
11 files changed, 8072 insertions, 0 deletions
diff --git a/svtools/source/brwbox/brwbox1.cxx b/svtools/source/brwbox/brwbox1.cxx
new file mode 100644
index 000000000..ee3922582
--- /dev/null
+++ b/svtools/source/brwbox/brwbox1.cxx
@@ -0,0 +1,2347 @@
+/* -*- 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 .
+ */
+
+#include <svtools/brwbox.hxx>
+#include <svtools/brwhead.hxx>
+#include <o3tl/numeric.hxx>
+#include <o3tl/safeint.hxx>
+#include "datwin.hxx"
+#include <tools/debug.hxx>
+#include <tools/fract.hxx>
+#include <sal/log.hxx>
+#include <vcl/scrbar.hxx>
+#include <vcl/status.hxx>
+
+#include <algorithm>
+#include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
+#include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#include <tools/multisel.hxx>
+#include "brwimpl.hxx"
+
+
+#define SCROLL_FLAGS (ScrollFlags::Clip | ScrollFlags::NoChildren)
+
+using namespace com::sun::star::accessibility::AccessibleEventId;
+using namespace com::sun::star::accessibility::AccessibleTableModelChangeType;
+using com::sun::star::accessibility::AccessibleTableModelChange;
+using namespace ::com::sun::star::uno;
+using namespace svt;
+
+namespace
+{
+ void disposeAndClearHeaderCell(::svt::BrowseBoxImpl::THeaderCellMap& _rHeaderCell)
+ {
+ ::std::for_each(
+ _rHeaderCell.begin(),
+ _rHeaderCell.end(),
+ ::svt::BrowseBoxImpl::THeaderCellMapFunctorDispose()
+ );
+ _rHeaderCell.clear();
+ }
+}
+
+void BrowseBox::ConstructImpl( BrowserMode nMode )
+{
+ SAL_INFO("svtools", "BrowseBox:ConstructImpl " << this );
+ bMultiSelection = false;
+ pColSel = nullptr;
+ pVScroll = nullptr;
+ pDataWin = VclPtr<BrowserDataWin>::Create( this ).get();
+ m_pImpl.reset( new ::svt::BrowseBoxImpl() );
+
+ InitSettings_Impl( this );
+ InitSettings_Impl( pDataWin );
+
+ bBootstrapped = false;
+ nDataRowHeight = 0;
+ nTitleLines = 1;
+ nFirstCol = 0;
+ nTopRow = 0;
+ nCurRow = BROWSER_ENDOFSELECTION;
+ nCurColId = 0;
+ bResizing = false;
+ bSelect = false;
+ bSelecting = false;
+ bScrolling = false;
+ bSelectionIsVisible = false;
+ bNotToggleSel = false;
+ bRowDividerDrag = false;
+ bHit = false;
+ mbInteractiveRowHeight = false;
+ bHideSelect = false;
+ bHideCursor = TRISTATE_FALSE;
+ nRowCount = 0;
+ m_bFocusOnlyCursor = true;
+ m_aCursorColor = COL_TRANSPARENT;
+ m_nCurrentMode = BrowserMode::NONE;
+ nControlAreaWidth = USHRT_MAX;
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+
+ aHScroll->SetLineSize(1);
+ aHScroll->SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
+ pDataWin->Show();
+
+ SetMode( nMode );
+ bSelectionIsVisible = bKeepHighlight;
+ bHasFocus = HasChildPathFocus();
+ pDataWin->nCursorHidden =
+ ( bHasFocus ? 0 : 1 ) + ( GetUpdateMode() ? 0 : 1 );
+}
+
+BrowseBox::BrowseBox( vcl::Window* pParent, WinBits nBits, BrowserMode nMode )
+ :Control( pParent, nBits | WB_3DLOOK )
+ ,DragSourceHelper( this )
+ ,DropTargetHelper( this )
+ ,aHScroll( VclPtr<ScrollBar>::Create(this, WB_HSCROLL) )
+ ,aStatusBar( VclPtr<StatusBar>::Create(this) )
+{
+ ConstructImpl( nMode );
+}
+
+BrowseBox::~BrowseBox()
+{
+ disposeOnce();
+}
+
+void BrowseBox::dispose()
+{
+ SAL_INFO("svtools", "BrowseBox:dispose " << this );
+
+ if ( m_pImpl->m_pAccessible )
+ {
+ disposeAndClearHeaderCell(m_pImpl->m_aColHeaderCellMap);
+ disposeAndClearHeaderCell(m_pImpl->m_aRowHeaderCellMap);
+ m_pImpl->m_pAccessible->dispose();
+ }
+
+ Hide();
+ pDataWin->pHeaderBar.disposeAndClear();
+ pDataWin->pCornerWin.disposeAndClear();
+ pDataWin.disposeAndClear();
+ pVScroll.disposeAndClear();
+ aHScroll.disposeAndClear();
+ aStatusBar.disposeAndClear();
+
+ // free columns-space
+ mvCols.clear();
+ pColSel.reset();
+ if ( bMultiSelection )
+ delete uRow.pSel;
+ DragSourceHelper::dispose();
+ DropTargetHelper::dispose();
+ Control::dispose();
+}
+
+
+short BrowseBox::GetCursorHideCount() const
+{
+ return pDataWin->nCursorHidden;
+}
+
+
+void BrowseBox::DoShowCursor( const char * )
+{
+ if (!pDataWin)
+ return;
+ short nHiddenCount = --pDataWin->nCursorHidden;
+ if (PaintCursorIfHiddenOnce())
+ {
+ if (1 == nHiddenCount)
+ DrawCursor();
+ }
+ else
+ {
+ if (0 == nHiddenCount)
+ DrawCursor();
+ }
+}
+
+
+void BrowseBox::DoHideCursor( const char * )
+{
+ short nHiddenCount = ++pDataWin->nCursorHidden;
+ if (PaintCursorIfHiddenOnce())
+ {
+ if (2 == nHiddenCount)
+ DrawCursor();
+ }
+ else
+ {
+ if (1 == nHiddenCount)
+ DrawCursor();
+ }
+}
+
+
+void BrowseBox::SetRealRowCount( const OUString &rRealRowCount )
+{
+ pDataWin->aRealRowCount = rRealRowCount;
+}
+
+
+void BrowseBox::SetFont( const vcl::Font& rNewFont )
+{
+ pDataWin->SetFont( rNewFont );
+ ImpGetDataRowHeight();
+}
+
+const vcl::Font& BrowseBox::GetFont() const
+{
+ return pDataWin->GetFont();
+}
+
+sal_uLong BrowseBox::GetDefaultColumnWidth( const OUString& _rText ) const
+{
+ return pDataWin->GetTextWidth( _rText ) + pDataWin->GetTextWidth(OUString('0')) * 4;
+}
+
+
+void BrowseBox::InsertHandleColumn( sal_uLong nWidth )
+{
+
+#if OSL_DEBUG_LEVEL > 0
+ OSL_ENSURE( ColCount() == 0 || mvCols[0]->GetId() != HandleColumnId , "BrowseBox::InsertHandleColumn: there is already a handle column" );
+ {
+ for (auto const & col : mvCols)
+ OSL_ENSURE( col->GetId() != HandleColumnId, "BrowseBox::InsertHandleColumn: there is a non-Handle column with handle ID" );
+ }
+#endif
+
+ mvCols.insert( mvCols.begin(), std::unique_ptr<BrowserColumn>(new BrowserColumn( 0, OUString(), nWidth, GetZoom() )) );
+ FreezeColumn( 0 );
+
+ // adjust headerbar
+ if ( pDataWin->pHeaderBar )
+ {
+ pDataWin->pHeaderBar->SetPosSizePixel(
+ Point(nWidth, 0),
+ Size( GetOutputSizePixel().Width() - nWidth, GetTitleHeight() )
+ );
+ }
+
+ ColumnInserted( 0 );
+}
+
+
+void BrowseBox::InsertDataColumn( sal_uInt16 nItemId, const OUString& rText,
+ long nWidth, HeaderBarItemBits nBits, sal_uInt16 nPos )
+{
+
+ OSL_ENSURE( nItemId != HandleColumnId, "BrowseBox::InsertDataColumn: nItemId is HandleColumnId" );
+ OSL_ENSURE( nItemId != BROWSER_INVALIDID, "BrowseBox::InsertDataColumn: nItemId is reserved value BROWSER_INVALIDID" );
+
+#if OSL_DEBUG_LEVEL > 0
+ {
+ for (auto const& col : mvCols)
+ OSL_ENSURE( col->GetId() != nItemId, "BrowseBox::InsertDataColumn: duplicate column Id" );
+ }
+#endif
+
+ if ( nPos < mvCols.size() )
+ {
+ mvCols.emplace( mvCols.begin() + nPos, new BrowserColumn( nItemId, rText, nWidth, GetZoom() ) );
+ }
+ else
+ {
+ mvCols.emplace_back( new BrowserColumn( nItemId, rText, nWidth, GetZoom() ) );
+ }
+ if ( nCurColId == 0 )
+ nCurColId = nItemId;
+
+ if ( pDataWin->pHeaderBar )
+ {
+ // Handle column not in the header bar
+ sal_uInt16 nHeaderPos = nPos;
+ if (nHeaderPos != HEADERBAR_APPEND && GetColumnId(0) == HandleColumnId )
+ nHeaderPos--;
+ pDataWin->pHeaderBar->InsertItem(
+ nItemId, rText, nWidth, nBits, nHeaderPos );
+ }
+ ColumnInserted( nPos );
+}
+
+sal_uInt16 BrowseBox::ToggleSelectedColumn()
+{
+ sal_uInt16 nSelectedColId = BROWSER_INVALIDID;
+ if ( pColSel && pColSel->GetSelectCount() )
+ {
+ DoHideCursor( "ToggleSelectedColumn" );
+ ToggleSelection();
+ long nSelected = pColSel->FirstSelected();
+ if (nSelected != static_cast<long>(SFX_ENDOFSELECTION))
+ nSelectedColId = mvCols[nSelected]->GetId();
+ pColSel->SelectAll(false);
+ }
+ return nSelectedColId;
+}
+
+void BrowseBox::SetToggledSelectedColumn(sal_uInt16 _nSelectedColumnId)
+{
+ if ( pColSel && _nSelectedColumnId != BROWSER_INVALIDID )
+ {
+ pColSel->Select( GetColumnPos( _nSelectedColumnId ) );
+ ToggleSelection();
+ SAL_INFO("svtools", "BrowseBox::SetToggledSelectedColumn " << this );
+ DoShowCursor( "SetToggledSelectedColumn" );
+ }
+}
+
+void BrowseBox::FreezeColumn( sal_uInt16 nItemId )
+{
+ // get the position in the current array
+ size_t nItemPos = GetColumnPos( nItemId );
+ if ( nItemPos >= mvCols.size() )
+ // not available!
+ return;
+
+ // doesn't the state change?
+ if ( mvCols[ nItemPos ]->IsFrozen() )
+ return;
+
+ // remark the column selection
+ sal_uInt16 nSelectedColId = ToggleSelectedColumn();
+
+ // to be moved?
+ if ( nItemPos != 0 && !mvCols[ nItemPos-1 ]->IsFrozen() )
+ {
+ // move to the right of the last frozen column
+ sal_uInt16 nFirstScrollable = FrozenColCount();
+ std::unique_ptr<BrowserColumn> pColumn = std::move(mvCols[ nItemPos ]);
+ mvCols.erase( mvCols.begin() + nItemPos );
+ nItemPos = nFirstScrollable;
+ mvCols.insert( mvCols.begin() + nItemPos, std::move(pColumn) );
+ }
+
+ // adjust the number of the first scrollable and visible column
+ if ( nFirstCol <= nItemPos )
+ nFirstCol = nItemPos + 1;
+
+ // toggle the freeze-state of the column
+ mvCols[ nItemPos ]->Freeze();
+
+ // align the scrollbar-range
+ UpdateScrollbars();
+
+ // repaint
+ Control::Invalidate();
+ pDataWin->Invalidate();
+
+ // remember the column selection
+ SetToggledSelectedColumn(nSelectedColId);
+}
+
+
+void BrowseBox::SetColumnPos( sal_uInt16 nColumnId, sal_uInt16 nPos )
+{
+ // never set pos of the handle column
+ if ( nColumnId == HandleColumnId )
+ return;
+
+ // get the position in the current array
+ sal_uInt16 nOldPos = GetColumnPos( nColumnId );
+ if ( nOldPos >= mvCols.size() )
+ // not available!
+ return;
+
+ // does the state change?
+ if (nOldPos == nPos)
+ return;
+
+ // remark the column selection
+ sal_uInt16 nSelectedColId = ToggleSelectedColumn();
+
+ // determine old column area
+ Size aDataWinSize( pDataWin->GetSizePixel() );
+ if ( pDataWin->pHeaderBar )
+ aDataWinSize.AdjustHeight(pDataWin->pHeaderBar->GetSizePixel().Height() );
+
+ tools::Rectangle aFromRect( GetFieldRect( nColumnId) );
+ aFromRect.AdjustRight(2*MIN_COLUMNWIDTH );
+
+ sal_uInt16 nNextPos = nOldPos + 1;
+ if ( nOldPos > nPos )
+ nNextPos = nOldPos - 1;
+
+ BrowserColumn *pNextCol = mvCols[ nNextPos ].get();
+ tools::Rectangle aNextRect(GetFieldRect( pNextCol->GetId() ));
+
+ // move column internally
+ {
+ std::unique_ptr<BrowserColumn> pTemp = std::move(mvCols[nOldPos]);
+ mvCols.erase( mvCols.begin() + nOldPos );
+ mvCols.insert( mvCols.begin() + nPos, std::move(pTemp) );
+ }
+
+ // determine new column area
+ tools::Rectangle aToRect( GetFieldRect( nColumnId ) );
+ aToRect.AdjustRight(2*MIN_COLUMNWIDTH );
+
+ // do scroll, let redraw
+ if( pDataWin->GetBackground().IsScrollable() )
+ {
+ long nScroll = -aFromRect.GetWidth();
+ tools::Rectangle aScrollArea;
+ if ( nOldPos > nPos )
+ {
+ long nFrozenWidth = GetFrozenWidth();
+ if ( aToRect.Left() < nFrozenWidth )
+ aToRect.SetLeft( nFrozenWidth );
+ aScrollArea = tools::Rectangle(Point(aToRect.Left(),0),
+ Point(aNextRect.Right(),aDataWinSize.Height()));
+ nScroll *= -1; // reverse direction
+ }
+ else
+ aScrollArea = tools::Rectangle(Point(aNextRect.Left(),0),
+ Point(aToRect.Right(),aDataWinSize.Height()));
+
+ pDataWin->Scroll( nScroll, 0, aScrollArea );
+ aToRect.SetTop( 0 );
+ aToRect.SetBottom( aScrollArea.Bottom() );
+ Invalidate( aToRect );
+ }
+ else
+ pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
+
+ // adjust header bar positions
+ if ( pDataWin->pHeaderBar )
+ {
+ sal_uInt16 nNewPos = nPos;
+ if ( GetColumnId(0) == HandleColumnId )
+ --nNewPos;
+ pDataWin->pHeaderBar->MoveItem(nColumnId,nNewPos);
+ }
+ // remember the column selection
+ SetToggledSelectedColumn(nSelectedColId);
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange(
+ DELETE,
+ 0,
+ GetRowCount(),
+ nOldPos,
+ nOldPos
+ )
+ ),
+ Any()
+ );
+
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange(
+ INSERT,
+ 0,
+ GetRowCount(),
+ nPos,
+ nPos
+ )
+ ),
+ Any()
+ );
+
+}
+
+
+void BrowseBox::SetColumnTitle( sal_uInt16 nItemId, const OUString& rTitle )
+{
+
+ // never set title of the handle-column
+ if ( nItemId == HandleColumnId )
+ return;
+
+ // get the position in the current array
+ sal_uInt16 nItemPos = GetColumnPos( nItemId );
+ if ( nItemPos >= mvCols.size() )
+ // not available!
+ return;
+
+ // does the state change?
+ BrowserColumn *pCol = mvCols[ nItemPos ].get();
+ if ( pCol->Title() == rTitle )
+ return;
+
+ OUString sOld(pCol->Title());
+
+ pCol->Title() = rTitle;
+
+ // adjust headerbar column
+ if ( pDataWin->pHeaderBar )
+ pDataWin->pHeaderBar->SetItemText( nItemId, rTitle );
+ else
+ {
+ // redraw visible columns
+ if ( GetUpdateMode() && ( pCol->IsFrozen() || nItemPos > nFirstCol ) )
+ Invalidate( tools::Rectangle( Point(0,0),
+ Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
+ }
+
+ if ( isAccessibleAlive() )
+ {
+ commitTableEvent( TABLE_COLUMN_DESCRIPTION_CHANGED,
+ makeAny( rTitle ),
+ makeAny( sOld )
+ );
+ }
+}
+
+
+void BrowseBox::SetColumnWidth( sal_uInt16 nItemId, sal_uLong nWidth )
+{
+
+ // get the position in the current array
+ size_t nItemPos = GetColumnPos( nItemId );
+ if ( nItemPos >= mvCols.size() )
+ return;
+
+ // does the state change?
+ if ( !(nWidth >= LONG_MAX || mvCols[ nItemPos ]->Width() != nWidth) )
+ return;
+
+ long nOldWidth = mvCols[ nItemPos ]->Width();
+
+ // adjust last column, if necessary
+ if ( IsVisible() && nItemPos == mvCols.size() - 1 )
+ {
+ long nMaxWidth = pDataWin->GetSizePixel().Width();
+ nMaxWidth -= pDataWin->bAutoSizeLastCol
+ ? GetFieldRect(nItemId).Left()
+ : GetFrozenWidth();
+ if ( pDataWin->bAutoSizeLastCol || nWidth > o3tl::make_unsigned(nMaxWidth) )
+ {
+ nWidth = nMaxWidth > 16 ? nMaxWidth : nOldWidth;
+ }
+ }
+
+ // OV
+ // In AutoSizeLastColumn(), we call SetColumnWidth with nWidth==0xffff.
+ // Thus, check here, if the width has actually changed.
+ if( static_cast<sal_uLong>(nOldWidth) == nWidth )
+ return;
+
+ // do we want to display the change immediately?
+ bool bUpdate = GetUpdateMode() &&
+ ( mvCols[ nItemPos ]->IsFrozen() || nItemPos >= nFirstCol );
+
+ if ( bUpdate )
+ {
+ // Selection hidden
+ DoHideCursor( "SetColumnWidth" );
+ ToggleSelection();
+ //!pDataWin->Update();
+ //!Control::Update();
+ }
+
+ // set width
+ mvCols[ nItemPos ]->SetWidth(nWidth, GetZoom());
+
+ // scroll and invalidate
+ if ( bUpdate )
+ {
+ // get X-Pos of the column changed
+ long nX = 0;
+ for ( size_t nCol = 0; nCol < nItemPos; ++nCol )
+ {
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+ if ( pCol->IsFrozen() || nCol >= nFirstCol )
+ nX += pCol->Width();
+ }
+
+ // actually scroll+invalidate
+ pDataWin->SetClipRegion();
+ bool bSelVis = bSelectionIsVisible;
+ bSelectionIsVisible = false;
+ if( GetBackground().IsScrollable() )
+ {
+
+ tools::Rectangle aScrRect( nX + std::min( static_cast<sal_uLong>(nOldWidth), nWidth ), 0,
+ GetSizePixel().Width() , // the header is longer than the datawin
+ pDataWin->GetPosPixel().Y() - 1 );
+ Control::Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
+ aScrRect.SetBottom( pDataWin->GetSizePixel().Height() );
+ pDataWin->Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
+ tools::Rectangle aInvRect( nX, 0, nX + std::max( nWidth, static_cast<sal_uLong>(nOldWidth) ), USHRT_MAX );
+ Control::Invalidate( aInvRect, InvalidateFlags::NoChildren );
+ pDataWin->Invalidate( aInvRect );
+ }
+ else
+ {
+ Control::Invalidate( InvalidateFlags::NoChildren );
+ pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
+ }
+
+
+ //!pDataWin->Update();
+ //!Control::Update();
+ bSelectionIsVisible = bSelVis;
+ ToggleSelection();
+ DoShowCursor( "SetColumnWidth" );
+ }
+ UpdateScrollbars();
+
+ // adjust headerbar column
+ if ( pDataWin->pHeaderBar )
+ pDataWin->pHeaderBar->SetItemSize(
+ nItemId ? nItemId : USHRT_MAX - 1, nWidth );
+
+ // adjust last column
+ if ( nItemPos != mvCols.size() - 1 )
+ AutoSizeLastColumn();
+}
+
+
+void BrowseBox::AutoSizeLastColumn()
+{
+ if ( pDataWin->bAutoSizeLastCol &&
+ pDataWin->GetUpdateMode() )
+ {
+ sal_uInt16 nId = GetColumnId( static_cast<sal_uInt16>(mvCols.size()) - 1 );
+ SetColumnWidth( nId, LONG_MAX );
+ ColumnResized( nId );
+ }
+}
+
+
+void BrowseBox::RemoveColumn( sal_uInt16 nItemId )
+{
+
+ // get column position
+ sal_uInt16 nPos = GetColumnPos(nItemId);
+ if ( nPos >= ColCount() )
+ // not available
+ return;
+
+ // correct column selection
+ if ( pColSel )
+ pColSel->Remove( nPos );
+
+ // correct column cursor
+ if ( nCurColId == nItemId )
+ nCurColId = 0;
+
+ // delete column
+ mvCols.erase( mvCols.begin() + nPos );
+ if ( nFirstCol >= nPos && nFirstCol > FrozenColCount() )
+ {
+ OSL_ENSURE(nFirstCol > 0,"FirstCol must be greater zero!");
+ --nFirstCol;
+ }
+
+ // handlecolumn not in headerbar
+ if (nItemId)
+ {
+ if ( pDataWin->pHeaderBar )
+ pDataWin->pHeaderBar->RemoveItem( nItemId );
+ }
+ else
+ {
+ // adjust headerbar
+ if ( pDataWin->pHeaderBar )
+ {
+ pDataWin->pHeaderBar->SetPosSizePixel(
+ Point(0, 0),
+ Size( GetOutputSizePixel().Width(), GetTitleHeight() )
+ );
+ }
+ }
+
+ // correct vertical scrollbar
+ UpdateScrollbars();
+
+ // trigger repaint, if necessary
+ if ( GetUpdateMode() )
+ {
+ pDataWin->Invalidate();
+ Control::Invalidate();
+ if ( pDataWin->bAutoSizeLastCol && nPos ==ColCount() )
+ SetColumnWidth( GetColumnId( nPos - 1 ), LONG_MAX );
+ }
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange( DELETE,
+ 0,
+ GetRowCount(),
+ nPos,
+ nPos
+ )
+ ),
+ Any()
+ );
+
+ commitHeaderBarEvent(
+ CHILD,
+ Any(),
+ makeAny( CreateAccessibleColumnHeader( nPos ) ),
+ true
+ );
+}
+
+
+void BrowseBox::RemoveColumns()
+{
+ size_t nOldCount = mvCols.size();
+
+ // remove all columns
+ mvCols.clear();
+
+ // correct column selection
+ if ( pColSel )
+ {
+ pColSel->SelectAll(false);
+ pColSel->SetTotalRange( Range( 0, 0 ) );
+ }
+
+ // correct column cursor
+ nCurColId = 0;
+ nFirstCol = 0;
+
+ if ( pDataWin->pHeaderBar )
+ pDataWin->pHeaderBar->Clear( );
+
+ // correct vertical scrollbar
+ UpdateScrollbars();
+
+ // trigger repaint if necessary
+ if ( GetUpdateMode() )
+ {
+ pDataWin->Invalidate();
+ Control::Invalidate();
+ }
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ if ( mvCols.size() == nOldCount )
+ return;
+
+ // all columns should be removed, so we remove the column header bar and append it again
+ // to avoid to notify every column remove
+ commitBrowseBoxEvent(
+ CHILD,
+ Any(),
+ makeAny(m_pImpl->getAccessibleHeaderBar(vcl::BBTYPE_COLUMNHEADERBAR))
+ );
+
+ // and now append it again
+ commitBrowseBoxEvent(
+ CHILD,
+ makeAny(m_pImpl->getAccessibleHeaderBar(vcl::BBTYPE_COLUMNHEADERBAR)),
+ Any()
+ );
+
+ // notify a table model change
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny ( AccessibleTableModelChange( DELETE,
+ 0,
+ GetRowCount(),
+ 0,
+ nOldCount
+ )
+ ),
+ Any()
+ );
+}
+
+
+OUString BrowseBox::GetColumnTitle( sal_uInt16 nId ) const
+{
+
+ sal_uInt16 nItemPos = GetColumnPos( nId );
+ if ( nItemPos >= mvCols.size() )
+ return OUString();
+ return mvCols[ nItemPos ]->Title();
+}
+
+
+long BrowseBox::GetRowCount() const
+{
+ return nRowCount;
+}
+
+
+sal_uInt16 BrowseBox::ColCount() const
+{
+
+ return static_cast<sal_uInt16>(mvCols.size());
+}
+
+
+long BrowseBox::ImpGetDataRowHeight() const
+{
+
+ BrowseBox *pThis = const_cast<BrowseBox*>(this);
+ pThis->nDataRowHeight = pThis->CalcReverseZoom(pDataWin->GetTextHeight() + 2);
+ pThis->Resize();
+ pDataWin->Invalidate();
+ return nDataRowHeight;
+}
+
+
+void BrowseBox::SetDataRowHeight( long nPixel )
+{
+
+ nDataRowHeight = CalcReverseZoom(nPixel);
+ Resize();
+ pDataWin->Invalidate();
+}
+
+
+void BrowseBox::SetTitleLines( sal_uInt16 nLines )
+{
+
+ nTitleLines = nLines;
+}
+
+
+long BrowseBox::ScrollColumns( long nCols )
+{
+
+ if ( nFirstCol + nCols < 0 ||
+ nFirstCol + nCols >= static_cast<long>(mvCols.size()) )
+ return 0;
+
+ // implicitly hides cursor while scrolling
+ StartScroll();
+ bScrolling = true;
+ bool bScrollable = pDataWin->GetBackground().IsScrollable();
+ bool bInvalidateView = false;
+
+ // scrolling one column to the right?
+ if ( nCols == 1 )
+ {
+ // update internal value and scrollbar
+ ++nFirstCol;
+ aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
+
+ if ( !bScrollable )
+ {
+ bInvalidateView = true;
+ }
+ else
+ {
+ long nDelta = mvCols[ nFirstCol-1 ]->Width();
+ long nFrozenWidth = GetFrozenWidth();
+
+ tools::Rectangle aScrollRect( Point( nFrozenWidth + nDelta, 0 ),
+ Size ( GetOutputSizePixel().Width() - nFrozenWidth - nDelta,
+ GetTitleHeight() - 1
+ ) );
+
+ // scroll the header bar area (if there is no dedicated HeaderBar control)
+ if ( !pDataWin->pHeaderBar && nTitleLines )
+ {
+ // actually scroll
+ Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );
+
+ // invalidate the area of the column which was scrolled out to the left hand side
+ tools::Rectangle aInvalidateRect( aScrollRect );
+ aInvalidateRect.SetLeft( nFrozenWidth );
+ aInvalidateRect.SetRight( nFrozenWidth + nDelta - 1 );
+ Invalidate( aInvalidateRect );
+ }
+
+ // scroll the data-area
+ aScrollRect.SetBottom( pDataWin->GetOutputSizePixel().Height() );
+
+ // actually scroll
+ pDataWin->Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );
+
+ // invalidate the area of the column which was scrolled out to the left hand side
+ aScrollRect.SetLeft( nFrozenWidth );
+ aScrollRect.SetRight( nFrozenWidth + nDelta - 1 );
+ pDataWin->Invalidate( aScrollRect );
+ }
+ }
+
+ // scrolling one column to the left?
+ else if ( nCols == -1 )
+ {
+ --nFirstCol;
+ aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
+
+ if ( !bScrollable )
+ {
+ bInvalidateView = true;
+ }
+ else
+ {
+ long nDelta = mvCols[ nFirstCol ]->Width();
+ long nFrozenWidth = GetFrozenWidth();
+
+ tools::Rectangle aScrollRect( Point( nFrozenWidth, 0 ),
+ Size ( GetOutputSizePixel().Width() - nFrozenWidth,
+ GetTitleHeight() - 1
+ ) );
+
+ // scroll the header bar area (if there is no dedicated HeaderBar control)
+ if ( !pDataWin->pHeaderBar && nTitleLines )
+ {
+ Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
+ }
+
+ // scroll the data-area
+ aScrollRect.SetBottom( pDataWin->GetOutputSizePixel().Height() );
+ pDataWin->Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
+ }
+ }
+ else
+ {
+ if ( GetUpdateMode() )
+ {
+ Invalidate( tools::Rectangle(
+ Point( GetFrozenWidth(), 0 ),
+ Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
+ pDataWin->Invalidate( tools::Rectangle(
+ Point( GetFrozenWidth(), 0 ),
+ pDataWin->GetSizePixel() ) );
+ }
+
+ nFirstCol = nFirstCol + static_cast<sal_uInt16>(nCols);
+ aHScroll->SetThumbPos( nFirstCol - FrozenColCount() );
+ }
+
+ // adjust external headerbar, if necessary
+ if ( pDataWin->pHeaderBar )
+ {
+ long nWidth = 0;
+ for ( size_t nCol = 0;
+ nCol < mvCols.size() && nCol < nFirstCol;
+ ++nCol )
+ {
+ // not the handle column
+ if ( mvCols[ nCol ]->GetId() )
+ nWidth += mvCols[ nCol ]->Width();
+ }
+
+ pDataWin->pHeaderBar->SetOffset( nWidth );
+ }
+
+ if( bInvalidateView )
+ {
+ Control::Invalidate( InvalidateFlags::NoChildren );
+ pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
+ }
+
+ // implicitly show cursor after scrolling
+ if ( nCols )
+ {
+ pDataWin->Update();
+ PaintImmediately();
+ }
+ bScrolling = false;
+ EndScroll();
+
+ return nCols;
+}
+
+
+long BrowseBox::ScrollRows( long nRows )
+{
+ // compute new top row
+ long nTmpMin = std::min( static_cast<long>(nTopRow + nRows), static_cast<long>(nRowCount - 1) );
+
+ long nNewTopRow = std::max<long>( nTmpMin, 0 );
+
+ if ( nNewTopRow == nTopRow )
+ return 0;
+
+ sal_uInt16 nVisibleRows =
+ static_cast<sal_uInt16>(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
+
+ VisibleRowsChanged(nNewTopRow, nVisibleRows);
+
+ // compute new top row again (nTopRow might have changed!)
+ nTmpMin = std::min( static_cast<long>(nTopRow + nRows), static_cast<long>(nRowCount - 1) );
+
+ nNewTopRow = std::max<long>( nTmpMin, 0 );
+
+ StartScroll();
+
+ // scroll area on screen and/or repaint
+ long nDeltaY = GetDataRowHeight() * ( nNewTopRow - nTopRow );
+ long nOldTopRow = nTopRow;
+ nTopRow = nNewTopRow;
+
+ if ( GetUpdateMode() )
+ {
+ pVScroll->SetRange( Range( 0L, nRowCount ) );
+ pVScroll->SetThumbPos( nTopRow );
+
+ if( pDataWin->GetBackground().IsScrollable() &&
+ std::abs( nDeltaY ) > 0 &&
+ std::abs( nDeltaY ) < pDataWin->GetSizePixel().Height() )
+ {
+ pDataWin->Scroll( 0, static_cast<short>(-nDeltaY), SCROLL_FLAGS );
+ }
+ else
+ pDataWin->Invalidate();
+
+ if ( nTopRow - nOldTopRow )
+ pDataWin->Update();
+ }
+
+ EndScroll();
+
+ return nTopRow - nOldTopRow;
+}
+
+
+void BrowseBox::RowModified( long nRow, sal_uInt16 nColId )
+{
+
+ if ( !GetUpdateMode() )
+ return;
+
+ tools::Rectangle aRect;
+ if ( nColId == BROWSER_INVALIDID )
+ // invalidate the whole row
+ aRect = tools::Rectangle( Point( 0, (nRow-nTopRow) * GetDataRowHeight() ),
+ Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
+ else
+ {
+ // invalidate the specific field
+ aRect = GetFieldRectPixel( nRow, nColId, false );
+ }
+ pDataWin->Invalidate( aRect );
+}
+
+
+void BrowseBox::Clear()
+{
+
+ // adjust the total number of rows
+ DoHideCursor( "Clear" );
+ long nOldRowCount = nRowCount;
+ nRowCount = 0;
+ if(bMultiSelection)
+ {
+ assert(uRow.pSel);
+ uRow.pSel->Reset();
+ }
+ else
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+ nCurRow = BROWSER_ENDOFSELECTION;
+ nTopRow = 0;
+ nCurColId = 0;
+
+ // nFirstCol may not be reset, else the scrolling code will become confused.
+ // nFirstCol may only be changed when adding or deleting columns
+ // nFirstCol = 0; -> wrong!
+ aHScroll->SetThumbPos( 0 );
+ pVScroll->SetThumbPos( 0 );
+
+ Invalidate();
+ UpdateScrollbars();
+ SetNoSelection();
+ DoShowCursor( "Clear" );
+ CursorMoved();
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ // all rows should be removed, so we remove the row header bar and append it again
+ // to avoid to notify every row remove
+ if ( nOldRowCount == nRowCount )
+ return;
+
+ commitBrowseBoxEvent(
+ CHILD,
+ Any(),
+ makeAny( m_pImpl->getAccessibleHeaderBar( vcl::BBTYPE_ROWHEADERBAR ) )
+ );
+
+ // and now append it again
+ commitBrowseBoxEvent(
+ CHILD,
+ makeAny( m_pImpl->getAccessibleHeaderBar( vcl::BBTYPE_ROWHEADERBAR ) ),
+ Any()
+ );
+
+ // notify a table model change
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange( DELETE,
+ 0,
+ nOldRowCount,
+ 0,
+ GetColumnCount())
+ ),
+ Any()
+ );
+}
+
+void BrowseBox::RowInserted( long nRow, long nNumRows, bool bDoPaint, bool bKeepSelection )
+{
+
+ if (nRow < 0)
+ nRow = 0;
+ else if (nRow > nRowCount) // maximal = nRowCount
+ nRow = nRowCount;
+
+ if ( nNumRows <= 0 )
+ return;
+
+ // adjust total row count
+ bool bLastRow = nRow >= nRowCount;
+ nRowCount += nNumRows;
+
+ DoHideCursor( "RowInserted" );
+
+ // must we paint the new rows?
+ long nOldCurRow = nCurRow;
+ Size aSz = pDataWin->GetOutputSizePixel();
+ if ( bDoPaint && nRow >= nTopRow &&
+ nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
+ {
+ long nY = (nRow-nTopRow) * GetDataRowHeight();
+ if ( !bLastRow )
+ {
+ // scroll down the rows behind the new row
+ pDataWin->SetClipRegion();
+ if( pDataWin->GetBackground().IsScrollable() )
+ {
+ pDataWin->Scroll( 0, GetDataRowHeight() * nNumRows,
+ tools::Rectangle( Point( 0, nY ),
+ Size( aSz.Width(), aSz.Height() - nY ) ),
+ SCROLL_FLAGS );
+ }
+ else
+ pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
+ }
+ else
+ // scroll would cause a repaint, so we must explicitly invalidate
+ pDataWin->Invalidate( tools::Rectangle( Point( 0, nY ),
+ Size( aSz.Width(), nNumRows * GetDataRowHeight() ) ) );
+ }
+
+ // correct top row if necessary
+ if ( nRow < nTopRow )
+ nTopRow += nNumRows;
+
+ // adjust the selection
+ if ( bMultiSelection )
+ uRow.pSel->Insert( nRow, nNumRows );
+ else if ( uRow.nSel != BROWSER_ENDOFSELECTION && nRow <= uRow.nSel )
+ uRow.nSel += nNumRows;
+
+ // adjust the cursor
+ if ( nCurRow == BROWSER_ENDOFSELECTION )
+ GoToRow( 0, false, bKeepSelection );
+ else if ( nRow <= nCurRow )
+ {
+ nCurRow += nNumRows;
+ GoToRow( nCurRow, false, bKeepSelection );
+ }
+
+ // adjust the vertical scrollbar
+ if ( bDoPaint )
+ {
+ UpdateScrollbars();
+ AutoSizeLastColumn();
+ }
+
+ DoShowCursor( "RowInserted" );
+ // notify accessible that rows were inserted
+ if ( isAccessibleAlive() )
+ {
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange(
+ INSERT,
+ nRow,
+ nRow + nNumRows,
+ 0,
+ GetColumnCount()
+ )
+ ),
+ Any()
+ );
+
+ for (long i = nRow+1 ; i <= nRowCount ; ++i)
+ {
+ commitHeaderBarEvent(
+ CHILD,
+ makeAny( CreateAccessibleRowHeader( i ) ),
+ Any(),
+ false
+ );
+ }
+ }
+
+ if ( nCurRow != nOldCurRow )
+ CursorMoved();
+
+ DBG_ASSERT(nRowCount > 0,"BrowseBox: nRowCount <= 0");
+ DBG_ASSERT(nCurRow >= 0,"BrowseBox: nCurRow < 0");
+ DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
+}
+
+
+void BrowseBox::RowRemoved( long nRow, long nNumRows, bool bDoPaint )
+{
+
+ if ( nRow < 0 )
+ nRow = 0;
+ else if ( nRow >= nRowCount )
+ nRow = nRowCount - 1;
+
+ if ( nNumRows <= 0 )
+ return;
+
+ if ( nRowCount <= 0 )
+ return;
+
+ if ( bDoPaint )
+ {
+ // hide cursor and selection
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+ ToggleSelection();
+ DoHideCursor( "RowRemoved" );
+ }
+
+ // adjust total row count
+ nRowCount -= nNumRows;
+ if (nRowCount < 0) nRowCount = 0;
+ long nOldCurRow = nCurRow;
+
+ // adjust the selection
+ if ( bMultiSelection )
+ // uRow.pSel->Remove( nRow, nNumRows );
+ for ( long i = 0; i < nNumRows; i++ )
+ uRow.pSel->Remove( nRow );
+ else if ( nRow < uRow.nSel && uRow.nSel >= nNumRows )
+ uRow.nSel -= nNumRows;
+ else if ( nRow <= uRow.nSel )
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+
+ // adjust the cursor
+ if ( nRowCount == 0 ) // don't compare nRowCount with nNumRows as nNumRows already was subtracted from nRowCount
+ nCurRow = BROWSER_ENDOFSELECTION;
+ else if ( nRow < nCurRow )
+ {
+ nCurRow -= std::min( nCurRow - nRow, nNumRows );
+ // with the above nCurRow points a) to the first row after the removed block or b) to the same line
+ // as before, but moved up nNumRows
+ // case a) needs an additional correction if the last n lines were deleted, as 'the first row after the
+ // removed block' is an invalid position then
+ // FS - 09/28/99 - 68429
+ if (nCurRow == nRowCount)
+ --nCurRow;
+ }
+ else if( nRow == nCurRow && nCurRow == nRowCount )
+ nCurRow = nRowCount-1;
+
+ // is the deleted row visible?
+ Size aSz = pDataWin->GetOutputSizePixel();
+ if ( nRow >= nTopRow &&
+ nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
+ {
+ if ( bDoPaint )
+ {
+ // scroll up the rows behind the deleted row
+ // if there are Rows behind
+ if (nRow < nRowCount)
+ {
+ long nY = (nRow-nTopRow) * GetDataRowHeight();
+ pDataWin->SetClipRegion();
+ if( pDataWin->GetBackground().IsScrollable() )
+ {
+ pDataWin->Scroll( 0, - static_cast<short>(GetDataRowHeight()) * nNumRows,
+ tools::Rectangle( Point( 0, nY ), Size( aSz.Width(),
+ aSz.Height() - nY + nNumRows*GetDataRowHeight() ) ),
+ SCROLL_FLAGS );
+ }
+ else
+ pDataWin->Window::Invalidate( InvalidateFlags::NoChildren );
+ }
+ else
+ {
+ // Repaint the Rect of the deleted row
+ tools::Rectangle aRect(
+ Point( 0, (nRow-nTopRow)*GetDataRowHeight() ),
+ Size( pDataWin->GetSizePixel().Width(),
+ nNumRows * GetDataRowHeight() ) );
+ pDataWin->Invalidate( aRect );
+ }
+ }
+ }
+ // is the deleted row above of the visible area?
+ else if ( nRow < nTopRow )
+ nTopRow = nTopRow >= nNumRows ? nTopRow-nNumRows : 0;
+
+ if ( bDoPaint )
+ {
+ // reshow cursor and selection
+ ToggleSelection();
+ SAL_INFO("svtools", "BrowseBox::ShowCursor " << this );
+ DoShowCursor( "RowRemoved" );
+
+ // adjust the vertical scrollbar
+ UpdateScrollbars();
+ AutoSizeLastColumn();
+ }
+
+ if ( isAccessibleAlive() )
+ {
+ if ( nRowCount == 0 )
+ {
+ // all columns should be removed, so we remove the column header bar and append it again
+ // to avoid to notify every column remove
+ commitBrowseBoxEvent(
+ CHILD,
+ Any(),
+ makeAny( m_pImpl->getAccessibleHeaderBar( vcl::BBTYPE_ROWHEADERBAR ) )
+ );
+
+ // and now append it again
+ commitBrowseBoxEvent(
+ CHILD,
+ makeAny(m_pImpl->getAccessibleHeaderBar(vcl::BBTYPE_ROWHEADERBAR)),
+ Any()
+ );
+ commitBrowseBoxEvent(
+ CHILD,
+ Any(),
+ makeAny( m_pImpl->getAccessibleTable() )
+ );
+
+ // and now append it again
+ commitBrowseBoxEvent(
+ CHILD,
+ makeAny( m_pImpl->getAccessibleTable() ),
+ Any()
+ );
+ }
+ else
+ {
+ commitTableEvent(
+ TABLE_MODEL_CHANGED,
+ makeAny( AccessibleTableModelChange(
+ DELETE,
+ nRow,
+ nRow + nNumRows,
+ 0,
+ GetColumnCount()
+ )
+ ),
+ Any()
+ );
+
+ for (long i = nRow+1 ; i <= (nRow+nNumRows) ; ++i)
+ {
+ commitHeaderBarEvent(
+ CHILD,
+ Any(),
+ makeAny( CreateAccessibleRowHeader( i ) ),
+ false
+ );
+ }
+ }
+ }
+
+ if ( nOldCurRow != nCurRow )
+ CursorMoved();
+
+ DBG_ASSERT(nRowCount >= 0,"BrowseBox: nRowCount < 0");
+ DBG_ASSERT(nCurRow >= 0 || nRowCount == 0,"BrowseBox: nCurRow < 0 && nRowCount != 0");
+ DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
+}
+
+
+bool BrowseBox::GoToRow( long nRow)
+{
+ return GoToRow(nRow, false);
+}
+
+
+bool BrowseBox::GoToRow( long nRow, bool bRowColMove, bool bKeepSelection )
+{
+
+ long nOldCurRow = nCurRow;
+
+ // nothing to do?
+ if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) )
+ return true;
+
+ // out of range?
+ if ( nRow < 0 || nRow >= nRowCount )
+ return false;
+
+ // not allowed?
+ if ( !bRowColMove && !IsCursorMoveAllowed( nRow, nCurColId ) )
+ return false;
+
+ // compute the last visible row
+ Size aSz( pDataWin->GetSizePixel() );
+ sal_uInt16 nVisibleRows = sal_uInt16( aSz.Height() / GetDataRowHeight() - 1 );
+ long nLastRow = nTopRow + nVisibleRows;
+
+ // suspend Updates
+ pDataWin->EnterUpdateLock();
+
+ // remove old highlight, if necessary
+ if ( !bMultiSelection && !bKeepSelection )
+ ToggleSelection();
+ DoHideCursor( "GoToRow" );
+
+ // must we scroll?
+ bool bWasVisible = bSelectionIsVisible;
+ if (! bMultiSelection)
+ {
+ if( !bKeepSelection )
+ bSelectionIsVisible = false;
+ }
+ if ( nRow < nTopRow )
+ ScrollRows( nRow - nTopRow );
+ else if ( nRow > nLastRow )
+ ScrollRows( nRow - nLastRow );
+ bSelectionIsVisible = bWasVisible;
+
+ // adjust cursor (selection) and thumb
+ if ( GetUpdateMode() )
+ pVScroll->SetThumbPos( nTopRow );
+
+ // relative positioning (because nCurRow might have changed in the meantime)!
+ if (nCurRow != BROWSER_ENDOFSELECTION )
+ nCurRow = nCurRow + (nRow - nOldCurRow);
+
+ // make sure that the current position is valid
+ if (nCurRow == BROWSER_ENDOFSELECTION && nRowCount > 0)
+ nCurRow = 0;
+ else if ( nCurRow >= nRowCount )
+ nCurRow = nRowCount - 1;
+ aSelRange = Range( nCurRow, nCurRow );
+
+ // display new highlight if necessary
+ if ( !bMultiSelection && !bKeepSelection )
+ uRow.nSel = nRow;
+
+ // resume Updates
+ pDataWin->LeaveUpdateLock();
+
+ // Cursor+Highlight
+ if ( !bMultiSelection && !bKeepSelection)
+ ToggleSelection();
+ DoShowCursor( "GoToRow" );
+ if ( !bRowColMove && nOldCurRow != nCurRow )
+ CursorMoved();
+
+ if ( !bMultiSelection && !bKeepSelection )
+ {
+ if ( !bSelecting )
+ Select();
+ else
+ bSelect = true;
+ }
+ return true;
+}
+
+
+bool BrowseBox::GoToColumnId( sal_uInt16 nColId)
+{
+ return GoToColumnId(nColId, true);
+}
+
+
+bool BrowseBox::GoToColumnId( sal_uInt16 nColId, bool bMakeVisible, bool bRowColMove)
+{
+ if (!bColumnCursor)
+ return false;
+
+ // allowed?
+ if (!bRowColMove && !IsCursorMoveAllowed( nCurRow, nColId ) )
+ return false;
+
+ if ( nColId != nCurColId || (bMakeVisible && !IsFieldVisible(nCurRow, nColId, true)))
+ {
+ sal_uInt16 nNewPos = GetColumnPos(nColId);
+ BrowserColumn* pColumn = (nNewPos < mvCols.size()) ? mvCols[ nNewPos ].get() : nullptr;
+ DBG_ASSERT( pColumn, "no column object - invalid id?" );
+ if ( !pColumn )
+ return false;
+
+ DoHideCursor( "GoToColumnId" );
+ nCurColId = nColId;
+
+ bool bScrolled = false;
+
+ sal_uInt16 nFirstPos = nFirstCol;
+ sal_uInt16 nWidth = static_cast<sal_uInt16>(pColumn->Width());
+ sal_uInt16 nLastPos = GetColumnAtXPosPixel(
+ pDataWin->GetSizePixel().Width()-nWidth );
+ sal_uInt16 nFrozen = FrozenColCount();
+ if ( bMakeVisible && nLastPos &&
+ nNewPos >= nFrozen && ( nNewPos < nFirstPos || nNewPos > nLastPos ) )
+ {
+ if ( nNewPos < nFirstPos )
+ ScrollColumns( nNewPos-nFirstPos );
+ else if ( nNewPos > nLastPos )
+ ScrollColumns( nNewPos-nLastPos );
+ bScrolled = true;
+ }
+
+ DoShowCursor( "GoToColumnId" );
+ if (!bRowColMove)
+ {
+ //try to move to nCurRow, nColId
+ CursorMoveAttempt aAttempt(nCurRow, nColId, bScrolled);
+ //Detect if we are already in a call to BrowseBox::GoToColumnId
+ //but the attempt is impossible and we are simply recursing
+ //into BrowseBox::GoToColumnId with the same impossible to
+ //fulfill conditions
+ if (m_aGotoStack.empty() || aAttempt != m_aGotoStack.top())
+ {
+ m_aGotoStack.push(aAttempt);
+ CursorMoved();
+ m_aGotoStack.pop();
+ }
+ }
+ return true;
+ }
+ return true;
+}
+
+
+bool BrowseBox::GoToRowColumnId( long nRow, sal_uInt16 nColId )
+{
+
+ // out of range?
+ if ( nRow < 0 || nRow >= nRowCount )
+ return false;
+
+ if (!bColumnCursor)
+ return false;
+
+ // nothing to do ?
+ if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) &&
+ nColId == nCurColId && IsFieldVisible(nCurRow, nColId, true))
+ return true;
+
+ // allowed?
+ if (!IsCursorMoveAllowed(nRow, nColId))
+ return false;
+
+ DoHideCursor( "GoToRowColumnId" );
+ bool bMoved = GoToRow(nRow, true) && GoToColumnId(nColId, true, true);
+ DoShowCursor( "GoToRowColumnId" );
+
+ if (bMoved)
+ CursorMoved();
+
+ return bMoved;
+}
+
+
+void BrowseBox::SetNoSelection()
+{
+
+ // is there no selection
+ if ( ( !pColSel || !pColSel->GetSelectCount() ) &&
+ ( ( !bMultiSelection && uRow.nSel == BROWSER_ENDOFSELECTION ) ||
+ ( bMultiSelection && !uRow.pSel->GetSelectCount() ) ) )
+ // nothing to do
+ return;
+
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+ ToggleSelection();
+
+ // unselect all
+ if ( bMultiSelection )
+ uRow.pSel->SelectAll(false);
+ else
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+ if ( pColSel )
+ pColSel->SelectAll(false);
+ if ( !bSelecting )
+ Select();
+ else
+ bSelect = true;
+
+ // restore screen
+ SAL_INFO("svtools", "BrowseBox::ShowCursor " << this );
+
+ if ( isAccessibleAlive() )
+ {
+ commitTableEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any()
+ );
+ }
+}
+
+
+void BrowseBox::SelectAll()
+{
+
+ if ( !bMultiSelection )
+ return;
+
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+ ToggleSelection();
+
+ // select all rows
+ if ( pColSel )
+ pColSel->SelectAll(false);
+ uRow.pSel->SelectAll();
+
+ // don't highlight handle column
+ BrowserColumn *pFirstCol = mvCols[ 0 ].get();
+ long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
+
+ // highlight the row selection
+ if ( !bHideSelect )
+ {
+ tools::Rectangle aHighlightRect;
+ sal_uInt16 nVisibleRows =
+ static_cast<sal_uInt16>(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
+ for ( long nRow = std::max<long>( nTopRow, uRow.pSel->FirstSelected() );
+ nRow != BROWSER_ENDOFSELECTION && nRow < nTopRow + nVisibleRows;
+ nRow = uRow.pSel->NextSelected() )
+ aHighlightRect.Union( tools::Rectangle(
+ Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
+ Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) ) );
+ pDataWin->Invalidate( aHighlightRect );
+ }
+
+ if ( !bSelecting )
+ Select();
+ else
+ bSelect = true;
+
+ // restore screen
+ SAL_INFO("svtools", "BrowseBox::ShowCursor " << this );
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ commitTableEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any()
+ );
+ commitHeaderBarEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any(),
+ true
+ ); // column header event
+
+ commitHeaderBarEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any(),
+ false
+ ); // row header event
+}
+
+
+void BrowseBox::SelectRow( long nRow, bool _bSelect, bool bExpand )
+{
+
+ if ( !bMultiSelection )
+ {
+ // deselecting is impossible, selecting via cursor
+ if ( _bSelect )
+ GoToRow(nRow, false);
+ return;
+ }
+
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+
+ // remove old selection?
+ if ( !bExpand || !bMultiSelection )
+ {
+ ToggleSelection();
+ if ( bMultiSelection )
+ uRow.pSel->SelectAll(false);
+ else
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+ if ( pColSel )
+ pColSel->SelectAll(false);
+ }
+
+ // set new selection
+ if ( !bHideSelect
+ && ( ( bMultiSelection
+ && uRow.pSel->GetTotalRange().Max() >= nRow
+ && uRow.pSel->Select( nRow, _bSelect )
+ )
+ || ( !bMultiSelection
+ && ( uRow.nSel = nRow ) != BROWSER_ENDOFSELECTION )
+ )
+ )
+ {
+ // don't highlight handle column
+ BrowserColumn *pFirstCol = mvCols[ 0 ].get();
+ long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
+
+ // highlight only newly selected part
+ tools::Rectangle aRect(
+ Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
+ Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
+ pDataWin->Invalidate( aRect );
+ }
+
+ if ( !bSelecting )
+ Select();
+ else
+ bSelect = true;
+
+ // restore screen
+ SAL_INFO("svtools", "BrowseBox::ShowCursor " << this );
+
+ if ( !isAccessibleAlive() )
+ return;
+
+ commitTableEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any()
+ );
+ commitHeaderBarEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any(),
+ false
+ ); // row header event
+}
+
+
+long BrowseBox::GetSelectRowCount() const
+{
+
+ return bMultiSelection ? uRow.pSel->GetSelectCount() :
+ uRow.nSel == BROWSER_ENDOFSELECTION ? 0 : 1;
+}
+
+
+void BrowseBox::SelectColumnPos( sal_uInt16 nNewColPos, bool _bSelect, bool bMakeVisible )
+{
+
+ if ( !bColumnCursor || nNewColPos == BROWSER_INVALIDID )
+ return;
+
+ if ( !bMultiSelection )
+ {
+ if ( _bSelect )
+ GoToColumnId( mvCols[ nNewColPos ]->GetId(), bMakeVisible );
+ return;
+ }
+ else
+ {
+ if ( !GoToColumnId( mvCols[ nNewColPos ]->GetId(), bMakeVisible ) )
+ return;
+ }
+
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+ ToggleSelection();
+ if ( bMultiSelection )
+ uRow.pSel->SelectAll(false);
+ else
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+ pColSel->SelectAll(false);
+
+ if ( pColSel->Select( nNewColPos, _bSelect ) )
+ {
+ // GoToColumnId( mvCols->GetObject(nNewColPos)->GetId(), bMakeVisible );
+
+ // only highlight painted areas
+ pDataWin->Update();
+ tools::Rectangle aFieldRectPix( GetFieldRectPixel( nCurRow, nCurColId, false ) );
+ tools::Rectangle aRect(
+ Point( aFieldRectPix.Left() - MIN_COLUMNWIDTH, 0 ),
+ Size( mvCols[ nNewColPos ]->Width(),
+ pDataWin->GetOutputSizePixel().Height() ) );
+ pDataWin->Invalidate( aRect );
+ if ( !bSelecting )
+ Select();
+ else
+ bSelect = true;
+
+ if ( isAccessibleAlive() )
+ {
+ commitTableEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any()
+ );
+ commitHeaderBarEvent(
+ SELECTION_CHANGED,
+ Any(),
+ Any(),
+ true
+ ); // column header event
+ }
+ }
+
+ // restore screen
+ SAL_INFO("svtools", "BrowseBox::ShowCursor " << this );
+}
+
+
+sal_uInt16 BrowseBox::GetSelectColumnCount() const
+{
+
+ // while bAutoSelect (==!pColSel), 1 if any rows (yes rows!) else none
+ return pColSel ? static_cast<sal_uInt16>(pColSel->GetSelectCount()) :
+ nCurRow >= 0 ? 1 : 0;
+}
+
+
+long BrowseBox::FirstSelectedColumn( ) const
+{
+ return pColSel ? pColSel->FirstSelected() : BROWSER_ENDOFSELECTION;
+}
+
+
+long BrowseBox::FirstSelectedRow()
+{
+
+ return bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
+}
+
+
+long BrowseBox::NextSelectedRow()
+{
+
+ return bMultiSelection ? uRow.pSel->NextSelected() : BROWSER_ENDOFSELECTION;
+}
+
+
+long BrowseBox::LastSelectedRow()
+{
+
+ return bMultiSelection ? uRow.pSel->LastSelected() : uRow.nSel;
+}
+
+
+bool BrowseBox::IsRowSelected( long nRow ) const
+{
+
+ return bMultiSelection ? uRow.pSel->IsSelected(nRow) : nRow == uRow.nSel;
+}
+
+
+bool BrowseBox::IsColumnSelected( sal_uInt16 nColumnId ) const
+{
+
+ return pColSel ? pColSel->IsSelected( GetColumnPos(nColumnId) ) :
+ nCurColId == nColumnId;
+}
+
+
+void BrowseBox::MakeFieldVisible
+(
+ long nRow, // line number of the field (starting with 0)
+ sal_uInt16 nColId // column ID of the field
+)
+
+/* [Description]
+
+ Makes visible the field described in 'nRow' and 'nColId' by scrolling
+ accordingly.
+
+*/
+
+{
+ if (!pDataWin)
+ return;
+
+ Size aTestSize = pDataWin->GetSizePixel();
+
+ if ( !bBootstrapped || aTestSize.IsEmpty() )
+ return;
+
+ // is it visible already?
+ bool bVisible = IsFieldVisible( nRow, nColId, true/*bComplete*/ );
+ if ( bVisible )
+ return;
+
+ // calculate column position, field rectangle and painting area
+ sal_uInt16 nColPos = GetColumnPos( nColId );
+ tools::Rectangle aFieldRect = GetFieldRectPixel( nRow, nColId, false );
+ tools::Rectangle aDataRect( Point(0, 0), pDataWin->GetSizePixel() );
+
+ // positioned outside on the left?
+ if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
+ // => scroll to the right
+ ScrollColumns( nColPos - nFirstCol );
+
+ // while outside on the right
+ while ( aDataRect.Right() < aFieldRect.Right() )
+ {
+ // => scroll to the left
+ if ( ScrollColumns( 1 ) != 1 )
+ // no more need to scroll
+ break;
+ aFieldRect = GetFieldRectPixel( nRow, nColId, false );
+ }
+
+ // positioned outside above?
+ if ( nRow < nTopRow )
+ // scroll further to the bottom
+ ScrollRows( nRow - nTopRow );
+
+ // positioned outside below?
+ long nBottomRow = nTopRow + GetVisibleRows();
+ // decrement nBottomRow to make it the number of the last visible line
+ // (count starts with 0!).
+ // Example: BrowseBox contains exactly one entry. nBottomRow := 0 + 1 - 1
+ if( nBottomRow )
+ nBottomRow--;
+
+ if ( nRow > nBottomRow )
+ // scroll further to the top
+ ScrollRows( nRow - nBottomRow );
+}
+
+
+bool BrowseBox::IsFieldVisible( long nRow, sal_uInt16 nColumnId,
+ bool bCompletely ) const
+{
+
+ // hidden by frozen column?
+ sal_uInt16 nColPos = GetColumnPos( nColumnId );
+ if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
+ return false;
+
+ tools::Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
+ if ( aRect.IsEmpty() )
+ return false;
+
+ // get the visible area
+ tools::Rectangle aOutRect( Point(0, 0), pDataWin->GetOutputSizePixel() );
+
+ if ( bCompletely )
+ // test if the field is completely visible
+ return aOutRect.IsInside( aRect );
+ else
+ // test if the field is partly of completely visible
+ return !aOutRect.Intersection( aRect ).IsEmpty();
+}
+
+
+tools::Rectangle BrowseBox::GetFieldRectPixel( long nRow, sal_uInt16 nColumnId,
+ bool bRelToBrowser) const
+{
+
+ // get the rectangle relative to DataWin
+ tools::Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
+ if ( aRect.IsEmpty() )
+ return aRect;
+
+ // adjust relative to BrowseBox's output area
+ Point aTopLeft( aRect.TopLeft() );
+ if ( bRelToBrowser )
+ {
+ aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
+ aTopLeft = ScreenToOutputPixel( aTopLeft );
+ }
+
+ return tools::Rectangle( aTopLeft, aRect.GetSize() );
+}
+
+
+tools::Rectangle BrowseBox::GetRowRectPixel( long nRow ) const
+{
+
+ // get the rectangle relative to DataWin
+ tools::Rectangle aRect;
+ if ( nTopRow > nRow )
+ // row is above visible area
+ return aRect;
+ aRect = tools::Rectangle(
+ Point( 0, GetDataRowHeight() * (nRow-nTopRow) ),
+ Size( pDataWin->GetOutputSizePixel().Width(), GetDataRowHeight() ) );
+ if ( aRect.TopLeft().Y() > pDataWin->GetOutputSizePixel().Height() )
+ // row is below visible area
+ return aRect;
+
+ // adjust relative to BrowseBox's output area
+ Point aTopLeft( aRect.TopLeft() );
+ aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
+ aTopLeft = ScreenToOutputPixel( aTopLeft );
+
+ return tools::Rectangle( aTopLeft, aRect.GetSize() );
+}
+
+
+tools::Rectangle BrowseBox::ImplFieldRectPixel( long nRow, sal_uInt16 nColumnId ) const
+{
+
+ // compute the X-coordinate relative to DataWin by accumulation
+ long nColX = 0;
+ sal_uInt16 nFrozenCols = FrozenColCount();
+ size_t nCol;
+ for ( nCol = 0;
+ nCol < mvCols.size() && mvCols[ nCol ]->GetId() != nColumnId;
+ ++nCol )
+ if ( mvCols[ nCol ]->IsFrozen() || nCol >= nFirstCol )
+ nColX += mvCols[ nCol ]->Width();
+
+ if ( nCol >= mvCols.size() || ( nCol >= nFrozenCols && nCol < nFirstCol ) )
+ return tools::Rectangle();
+
+ // compute the Y-coordinate relative to DataWin
+ long nRowY = GetDataRowHeight();
+ if ( nRow != BROWSER_ENDOFSELECTION ) // #105497# OJ
+ nRowY = ( nRow - nTopRow ) * GetDataRowHeight();
+
+ // assemble the Rectangle relative to DataWin
+ return tools::Rectangle(
+ Point( nColX + MIN_COLUMNWIDTH, nRowY ),
+ Size( (mvCols[nCol]->Width() == LONG_MAX
+ ? LONG_MAX - (nColX + MIN_COLUMNWIDTH) : mvCols[ nCol ]->Width() - 2*MIN_COLUMNWIDTH),
+ GetDataRowHeight() - 1 ) );
+}
+
+
+long BrowseBox::GetRowAtYPosPixel( long nY, bool bRelToBrowser ) const
+{
+
+ // compute the Y-coordinate
+ if ( bRelToBrowser )
+ {
+ Point aDataTopLeft = pDataWin->OutputToScreenPixel( Point(0, 0) );
+ Point aTopLeft = OutputToScreenPixel( Point(0, 0) );
+ nY -= aDataTopLeft.Y() - aTopLeft.Y();
+ }
+
+ // no row there (e.g. in the header)
+ if ( nY < 0 || nY >= pDataWin->GetOutputSizePixel().Height() )
+ return -1;
+
+ return nY / GetDataRowHeight() + nTopRow;
+}
+
+
+tools::Rectangle BrowseBox::GetFieldRect( sal_uInt16 nColumnId ) const
+{
+
+ return GetFieldRectPixel( nCurRow, nColumnId );
+}
+
+
+sal_uInt16 BrowseBox::GetColumnAtXPosPixel( long nX ) const
+{
+
+ // accumulate the widths of the visible columns
+ long nColX = 0;
+ for ( size_t nCol = 0; nCol < mvCols.size(); ++nCol )
+ {
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+ if ( pCol->IsFrozen() || nCol >= nFirstCol )
+ nColX += pCol->Width();
+
+ if ( nColX > nX )
+ return nCol;
+ }
+
+ return BROWSER_INVALIDID;
+}
+
+bool BrowseBox::ReserveControlArea(sal_uInt16 nWidth)
+{
+ if (nWidth != nControlAreaWidth)
+ {
+ OSL_ENSURE(nWidth,"Control area of 0 is not allowed, Use USHRT_MAX instead!");
+ nControlAreaWidth = nWidth;
+ UpdateScrollbars();
+ return true;
+ }
+ return false;
+}
+
+tools::Rectangle BrowseBox::GetControlArea() const
+{
+ auto nHeight = aHScroll->GetSizePixel().Height();
+ return tools::Rectangle(
+ Point( 0, GetOutputSizePixel().Height() - nHeight ),
+ Size( GetOutputSizePixel().Width() - aHScroll->GetSizePixel().Width(),
+ nHeight ) );
+}
+
+void BrowseBox::SetMode( BrowserMode nMode )
+{
+
+ pDataWin->bAutoHScroll = BrowserMode::AUTO_HSCROLL == ( nMode & BrowserMode::AUTO_HSCROLL );
+ pDataWin->bAutoVScroll = BrowserMode::AUTO_VSCROLL == ( nMode & BrowserMode::AUTO_VSCROLL );
+ pDataWin->bNoHScroll = BrowserMode::NO_HSCROLL == ( nMode & BrowserMode::NO_HSCROLL );
+ pDataWin->bNoVScroll = BrowserMode::NO_VSCROLL == ( nMode & BrowserMode::NO_VSCROLL );
+
+ DBG_ASSERT( !( pDataWin->bAutoHScroll && pDataWin->bNoHScroll ),
+ "BrowseBox::SetMode: AutoHScroll *and* NoHScroll?" );
+ DBG_ASSERT( !( pDataWin->bAutoVScroll && pDataWin->bNoVScroll ),
+ "BrowseBox::SetMode: AutoVScroll *and* NoVScroll?" );
+ if ( pDataWin->bAutoHScroll )
+ pDataWin->bNoHScroll = false;
+ if ( pDataWin->bAutoVScroll )
+ pDataWin->bNoVScroll = false;
+
+ if ( pDataWin->bNoHScroll )
+ aHScroll->Hide();
+
+ nControlAreaWidth = USHRT_MAX;
+
+ long nOldRowSel = bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
+ MultiSelection *pOldRowSel = bMultiSelection ? uRow.pSel : nullptr;
+
+ pVScroll.disposeAndClear();
+
+ bMultiSelection = bool( nMode & BrowserMode::MULTISELECTION );
+ bColumnCursor = bool( nMode & BrowserMode::COLUMNSELECTION );
+ bKeepHighlight = bool( nMode & BrowserMode::KEEPHIGHLIGHT );
+
+ bHideSelect = ((nMode & BrowserMode::HIDESELECT) == BrowserMode::HIDESELECT);
+ // default: do not hide the cursor at all (untaken scrolling and such)
+ bHideCursor = TRISTATE_FALSE;
+
+ if ( BrowserMode::HIDECURSOR == ( nMode & BrowserMode::HIDECURSOR ) )
+ {
+ bHideCursor = TRISTATE_TRUE;
+ }
+
+ m_bFocusOnlyCursor = ((nMode & BrowserMode::CURSOR_WO_FOCUS) == BrowserMode::NONE);
+
+ bHLines = ( nMode & BrowserMode::HLINES ) == BrowserMode::HLINES;
+ bVLines = ( nMode & BrowserMode::VLINES ) == BrowserMode::VLINES;
+
+ constexpr WinBits nVScrollWinBits = WB_VSCROLL;
+ pVScroll = ( nMode & BrowserMode::TRACKING_TIPS ) == BrowserMode::TRACKING_TIPS
+ ? VclPtr<BrowserScrollBar>::Create( this, nVScrollWinBits, pDataWin.get() )
+ : VclPtr<ScrollBar>::Create( this, nVScrollWinBits );
+ pVScroll->SetLineSize( 1 );
+ pVScroll->SetPageSize(1);
+ pVScroll->SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
+
+ pDataWin->bAutoSizeLastCol =
+ BrowserMode::AUTOSIZE_LASTCOL == ( nMode & BrowserMode::AUTOSIZE_LASTCOL );
+
+ // create a headerbar. what happens, if a headerbar has to be created and
+ // there already are columns?
+ if ( BrowserMode::HEADERBAR_NEW == ( nMode & BrowserMode::HEADERBAR_NEW ) )
+ {
+ if (!pDataWin->pHeaderBar)
+ pDataWin->pHeaderBar = CreateHeaderBar( this );
+ }
+ else
+ {
+ pDataWin->pHeaderBar.disposeAndClear();
+ }
+
+ if ( bColumnCursor )
+ {
+ if (!pColSel)
+ pColSel.reset(new MultiSelection);
+ pColSel->SetTotalRange( Range( 0, mvCols.size()-1 ) );
+ }
+ else
+ {
+ pColSel.reset();
+ }
+
+ if ( bMultiSelection )
+ {
+ if ( pOldRowSel )
+ uRow.pSel = pOldRowSel;
+ else
+ uRow.pSel = new MultiSelection;
+ }
+ else
+ {
+ uRow.nSel = nOldRowSel;
+ delete pOldRowSel;
+ }
+
+ if ( bBootstrapped )
+ {
+ StateChanged( StateChangedType::InitShow );
+ if ( bMultiSelection && !pOldRowSel &&
+ nOldRowSel != BROWSER_ENDOFSELECTION )
+ uRow.pSel->Select( nOldRowSel );
+ }
+
+ if ( pDataWin )
+ pDataWin->Invalidate();
+
+ // no cursor on handle column
+ if ( nCurColId == HandleColumnId )
+ nCurColId = GetColumnId( 1 );
+
+ m_nCurrentMode = nMode;
+}
+
+
+void BrowseBox::VisibleRowsChanged( long, sal_uInt16 )
+{
+
+ // old behavior: automatically correct NumRows:
+ if ( nRowCount < GetRowCount() )
+ {
+ RowInserted(nRowCount,GetRowCount() - nRowCount, false);
+ }
+ else if ( nRowCount > GetRowCount() )
+ {
+ RowRemoved(nRowCount-(nRowCount - GetRowCount()),nRowCount - GetRowCount(), false);
+ }
+}
+
+
+bool BrowseBox::IsCursorMoveAllowed( long, sal_uInt16 ) const
+
+/* [Description]
+
+ This virtual method is always called before the cursor is moved directly.
+ By means of 'return false', we avoid doing this if e.g. a record
+ contradicts any rules.
+
+ This method is not called, if the cursor movement results from removing or
+ deleting a row/column (thus, in cases where only a "cursor correction" happens).
+
+ The base implementation currently always returns true.
+*/
+
+{
+ return true;
+}
+
+
+long BrowseBox::GetDataRowHeight() const
+{
+ return CalcZoom(nDataRowHeight ? nDataRowHeight : ImpGetDataRowHeight());
+}
+
+
+VclPtr<BrowserHeader> BrowseBox::CreateHeaderBar( BrowseBox* pParent )
+{
+ VclPtr<BrowserHeader> pNewBar = VclPtr<BrowserHeader>::Create( pParent );
+ pNewBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
+ return pNewBar;
+}
+
+void BrowseBox::SetHeaderBar( BrowserHeader* pHeaderBar )
+{
+ pDataWin->pHeaderBar.disposeAndClear();
+ pDataWin->pHeaderBar = pHeaderBar;
+ pDataWin->pHeaderBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
+}
+
+long BrowseBox::GetTitleHeight() const
+{
+ long nHeight;
+ // ask the header bar for the text height (if possible), as the header bar's font is adjusted with
+ // our (and the header's) zoom factor
+ HeaderBar* pHeaderBar = pDataWin->pHeaderBar;
+ if ( pHeaderBar )
+ nHeight = pHeaderBar->GetTextHeight();
+ else
+ nHeight = GetTextHeight();
+
+ return nTitleLines ? nTitleLines * nHeight + 4 : 0;
+}
+
+long BrowseBox::CalcReverseZoom(long nVal)
+{
+ if (IsZoom())
+ {
+ const Fraction& rZoom = GetZoom();
+ double n = static_cast<double>(nVal);
+ n *= static_cast<double>(rZoom.GetDenominator());
+ if (!rZoom.GetNumerator())
+ throw o3tl::divide_by_zero();
+ n /= static_cast<double>(rZoom.GetNumerator());
+ nVal = n>0 ? static_cast<long>(n + 0.5) : -static_cast<long>(-n + 0.5);
+ }
+
+ return nVal;
+}
+
+void BrowseBox::CursorMoved()
+{
+ // before implementing more here, please adjust the EditBrowseBox
+
+ if ( isAccessibleAlive() && HasFocus() )
+ commitTableEvent(
+ ACTIVE_DESCENDANT_CHANGED,
+ makeAny( CreateAccessibleCell( GetCurRow(),GetColumnPos( GetCurColumnId() ) ) ),
+ Any()
+ );
+}
+
+void BrowseBox::LoseFocus()
+{
+ SAL_INFO("svtools", "BrowseBox::LoseFocus " << this );
+
+ if ( bHasFocus )
+ {
+ SAL_INFO("svtools", "BrowseBox::HideCursor " << this );
+ DoHideCursor( "LoseFocus" );
+
+ if ( !bKeepHighlight )
+ {
+ ToggleSelection();
+ bSelectionIsVisible = false;
+ }
+
+ bHasFocus = false;
+ }
+ Control::LoseFocus();
+}
+
+
+void BrowseBox::GetFocus()
+{
+ SAL_INFO("svtools", "BrowseBox::GetFocus " << this );
+
+ if ( !bHasFocus )
+ {
+ if ( !bSelectionIsVisible )
+ {
+ bSelectionIsVisible = true;
+ if ( bBootstrapped )
+ ToggleSelection();
+ }
+
+ bHasFocus = true;
+ DoShowCursor( "GetFocus" );
+ }
+ Control::GetFocus();
+}
+
+
+sal_uInt16 BrowseBox::GetVisibleRows() const
+{
+ return static_cast<sal_uInt16>((pDataWin->GetOutputSizePixel().Height() - 1 )/ GetDataRowHeight() + 1);
+}
+
+vcl::Window& BrowseBox::GetDataWindow() const
+{
+ return *pDataWin;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/brwbox2.cxx b/svtools/source/brwbox/brwbox2.cxx
new file mode 100644
index 000000000..e9e725149
--- /dev/null
+++ b/svtools/source/brwbox/brwbox2.cxx
@@ -0,0 +1,1972 @@
+/* -*- 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 .
+ */
+
+#include <sal/log.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+#include <tools/debug.hxx>
+#include <svtools/brwbox.hxx>
+#include "datwin.hxx"
+#include <svtools/colorcfg.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/ptrstyle.hxx>
+#include <vcl/scrbar.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/status.hxx>
+
+#include <tools/multisel.hxx>
+#include <tools/fract.hxx>
+#include <algorithm>
+#include <memory>
+
+using namespace ::com::sun::star::datatransfer;
+
+
+void BrowseBox::StartDrag( sal_Int8 /* _nAction */, const Point& /* _rPosPixel */ )
+{
+ // not interested in this event
+}
+
+
+sal_Int8 BrowseBox::AcceptDrop( const AcceptDropEvent& _rEvt )
+{
+ AcceptDropEvent aTransformed( _rEvt );
+ aTransformed.maPosPixel = pDataWin->ScreenToOutputPixel( OutputToScreenPixel( _rEvt.maPosPixel ) );
+ return pDataWin->AcceptDrop( aTransformed );
+}
+
+
+sal_Int8 BrowseBox::ExecuteDrop( const ExecuteDropEvent& _rEvt )
+{
+ ExecuteDropEvent aTransformed( _rEvt );
+ aTransformed.maPosPixel = pDataWin->ScreenToOutputPixel( OutputToScreenPixel( _rEvt.maPosPixel ) );
+ return pDataWin->ExecuteDrop( aTransformed );
+}
+
+
+sal_Int8 BrowseBox::AcceptDrop( const BrowserAcceptDropEvent& )
+{
+ // not interested in this event
+ return DND_ACTION_NONE;
+}
+
+
+sal_Int8 BrowseBox::ExecuteDrop( const BrowserExecuteDropEvent& )
+{
+ // not interested in this event
+ return DND_ACTION_NONE;
+}
+
+
+const DataFlavorExVector& BrowseBox::GetDataFlavors() const
+{
+ if (pDataWin->bCallingDropCallback)
+ return pDataWin->GetDataFlavorExVector();
+ return GetDataFlavorExVector();
+}
+
+
+bool BrowseBox::IsDropFormatSupported( SotClipboardFormatId _nFormat )
+{
+ if ( pDataWin->bCallingDropCallback )
+ return pDataWin->IsDropFormatSupported( _nFormat );
+
+ return DropTargetHelper::IsDropFormatSupported( _nFormat );
+}
+
+
+void BrowseBox::Command( const CommandEvent& rEvt )
+{
+ if ( !pDataWin->bInCommand )
+ Control::Command( rEvt );
+}
+
+
+void BrowseBox::StateChanged( StateChangedType nStateChange )
+{
+ Control::StateChanged( nStateChange );
+
+ if ( StateChangedType::Mirroring == nStateChange )
+ {
+ pDataWin->EnableRTL( IsRTLEnabled() );
+
+ HeaderBar* pHeaderBar = pDataWin->pHeaderBar;
+ if ( pHeaderBar )
+ pHeaderBar->EnableRTL( IsRTLEnabled() );
+ aHScroll->EnableRTL( IsRTLEnabled() );
+ if( pVScroll )
+ pVScroll->EnableRTL( IsRTLEnabled() );
+ Resize();
+ }
+ else if ( StateChangedType::InitShow == nStateChange )
+ {
+ bBootstrapped = true; // must be set first!
+
+ Resize();
+ if ( bMultiSelection )
+ uRow.pSel->SetTotalRange( Range( 0, nRowCount - 1 ) );
+ if ( nRowCount == 0 )
+ nCurRow = BROWSER_ENDOFSELECTION;
+ else if ( nCurRow == BROWSER_ENDOFSELECTION )
+ nCurRow = 0;
+
+
+ if ( HasFocus() )
+ {
+ bSelectionIsVisible = true;
+ bHasFocus = true;
+ }
+ UpdateScrollbars();
+ AutoSizeLastColumn();
+ CursorMoved();
+ }
+ else if (StateChangedType::Zoom == nStateChange)
+ {
+ pDataWin->SetZoom(GetZoom());
+ HeaderBar* pHeaderBar = pDataWin->pHeaderBar;
+ if (pHeaderBar)
+ pHeaderBar->SetZoom(GetZoom());
+
+ // let the columns calculate their new widths and adjust the header bar
+ for (auto & pCol : mvCols)
+ {
+ pCol->ZoomChanged(GetZoom());
+ if ( pHeaderBar )
+ pHeaderBar->SetItemSize( pCol->GetId(), pCol->Width() );
+ }
+
+ // all our controls have to be repositioned
+ Resize();
+ }
+ else if (StateChangedType::Enable == nStateChange)
+ {
+ // do we have a handle column?
+ bool bHandleCol = !mvCols.empty() && (0 == mvCols[ 0 ]->GetId());
+ // do we have a header bar?
+ bool bHeaderBar = (nullptr != pDataWin->pHeaderBar.get());
+
+ if ( nTitleLines
+ && ( !bHeaderBar
+ || bHandleCol
+ )
+ )
+ // we draw the text in our header bar in a color dependent on the enabled state. So if this state changed
+ // -> redraw
+ Invalidate(tools::Rectangle(Point(0, 0), Size(GetOutputSizePixel().Width(), GetTitleHeight() - 1)));
+ }
+}
+
+
+void BrowseBox::Select()
+{
+}
+
+
+void BrowseBox::DoubleClick( const BrowserMouseEvent & )
+{
+}
+
+
+long BrowseBox::QueryMinimumRowHeight()
+{
+ return CalcZoom( 5 );
+}
+
+
+void BrowseBox::ImplStartTracking()
+{
+}
+
+
+void BrowseBox::ImplEndTracking()
+{
+}
+
+
+void BrowseBox::RowHeightChanged()
+{
+}
+
+
+void BrowseBox::ColumnResized( sal_uInt16 )
+{
+}
+
+
+void BrowseBox::ColumnMoved( sal_uInt16 )
+{
+}
+
+
+void BrowseBox::StartScroll()
+{
+ DoHideCursor( "StartScroll" );
+}
+
+
+void BrowseBox::EndScroll()
+{
+ UpdateScrollbars();
+ AutoSizeLastColumn();
+ DoShowCursor( "EndScroll" );
+}
+
+
+void BrowseBox::ToggleSelection()
+{
+
+ // selection highlight-toggling allowed?
+ if ( bHideSelect )
+ return;
+ if ( bNotToggleSel || !IsUpdateMode() || !bSelectionIsVisible )
+ return;
+
+ // only highlight painted areas!
+ bNotToggleSel = true;
+
+ // accumulate areas of rows to highlight
+ std::vector<tools::Rectangle> aHighlightList;
+ long nLastRowInRect = 0; // for the CFront
+
+ // don't highlight handle column
+ BrowserColumn *pFirstCol = mvCols.empty() ? nullptr : mvCols[ 0 ].get();
+ long nOfsX = (!pFirstCol || pFirstCol->GetId()) ? 0 : pFirstCol->Width();
+
+ // accumulate old row selection
+ long nBottomRow = nTopRow +
+ pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight();
+ if ( nBottomRow > GetRowCount() && GetRowCount() )
+ nBottomRow = GetRowCount();
+ for ( long nRow = bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
+ nRow != BROWSER_ENDOFSELECTION && nRow <= nBottomRow;
+ nRow = bMultiSelection ? uRow.pSel->NextSelected() : BROWSER_ENDOFSELECTION )
+ {
+ if ( nRow < nTopRow )
+ continue;
+
+ tools::Rectangle aAddRect(
+ Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
+ Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
+ if ( !aHighlightList.empty() && nLastRowInRect == ( nRow - 1 ) )
+ aHighlightList[ 0 ].Union( aAddRect );
+ else
+ aHighlightList.emplace( aHighlightList.begin(), aAddRect );
+ nLastRowInRect = nRow;
+ }
+
+ // unhighlight the old selection (if any)
+ while ( !aHighlightList.empty() )
+ {
+ pDataWin->Invalidate( aHighlightList.back() );
+ aHighlightList.pop_back();
+ }
+
+ // unhighlight old column selection (if any)
+ for ( long nColId = pColSel ? pColSel->FirstSelected() : BROWSER_ENDOFSELECTION;
+ nColId != BROWSER_ENDOFSELECTION;
+ nColId = pColSel->NextSelected() )
+ {
+ tools::Rectangle aRect( GetFieldRectPixel(nCurRow,
+ mvCols[ nColId ]->GetId(),
+ false ) );
+ aRect.AdjustLeft( -(MIN_COLUMNWIDTH) );
+ aRect.AdjustRight(MIN_COLUMNWIDTH );
+ aRect.SetTop( 0 );
+ aRect.SetBottom( pDataWin->GetOutputSizePixel().Height() );
+ pDataWin->Invalidate( aRect );
+ }
+
+ bNotToggleSel = false;
+}
+
+
+void BrowseBox::DrawCursor()
+{
+ bool bReallyHide = false;
+ if ( bHideCursor == TRISTATE_INDET )
+ {
+ if ( !GetSelectRowCount() && !GetSelectColumnCount() )
+ bReallyHide = true;
+ }
+ else if ( bHideCursor == TRISTATE_TRUE )
+ {
+ bReallyHide = true;
+ }
+
+ bReallyHide |= !bSelectionIsVisible || !IsUpdateMode() || bScrolling || nCurRow < 0;
+
+ if (PaintCursorIfHiddenOnce())
+ bReallyHide |= ( GetCursorHideCount() > 1 );
+ else
+ bReallyHide |= ( GetCursorHideCount() > 0 );
+
+ // no cursor on handle column
+ if ( nCurColId == HandleColumnId )
+ nCurColId = GetColumnId(1);
+
+ // calculate cursor rectangle
+ tools::Rectangle aCursor;
+ if ( bColumnCursor )
+ {
+ aCursor = GetFieldRectPixel( nCurRow, nCurColId, false );
+ aCursor.AdjustLeft( -(MIN_COLUMNWIDTH) );
+ aCursor.AdjustRight(1 );
+ aCursor.AdjustBottom(1 );
+ }
+ else
+ aCursor = tools::Rectangle(
+ Point( ( !mvCols.empty() && mvCols[ 0 ]->GetId() == 0 ) ?
+ mvCols[ 0 ]->Width() : 0,
+ (nCurRow - nTopRow) * GetDataRowHeight() + 1 ),
+ Size( pDataWin->GetOutputSizePixel().Width() + 1,
+ GetDataRowHeight() - 2 ) );
+ if ( bHLines )
+ {
+ if ( !bMultiSelection )
+ aCursor.AdjustTop( -1 );
+ aCursor.AdjustBottom( -1 );
+ }
+
+ if (m_aCursorColor == COL_TRANSPARENT)
+ {
+ // on these platforms, the StarView focus works correctly
+ if ( bReallyHide )
+ static_cast<Control*>(pDataWin.get())->HideFocus();
+ else
+ static_cast<Control*>(pDataWin.get())->ShowFocus( aCursor );
+ }
+ else
+ {
+ Color rCol = bReallyHide ? pDataWin->GetFillColor() : m_aCursorColor;
+ Color aOldFillColor = pDataWin->GetFillColor();
+ Color aOldLineColor = pDataWin->GetLineColor();
+ pDataWin->SetFillColor();
+ pDataWin->SetLineColor( rCol );
+ pDataWin->DrawRect( aCursor );
+ pDataWin->SetLineColor( aOldLineColor );
+ pDataWin->SetFillColor( aOldFillColor );
+ }
+}
+
+
+sal_uLong BrowseBox::GetColumnWidth( sal_uInt16 nId ) const
+{
+
+ sal_uInt16 nItemPos = GetColumnPos( nId );
+ if ( nItemPos >= mvCols.size() )
+ return 0;
+ return mvCols[ nItemPos ]->Width();
+}
+
+
+sal_uInt16 BrowseBox::GetColumnId( sal_uInt16 nPos ) const
+{
+
+ if ( nPos >= mvCols.size() )
+ return BROWSER_INVALIDID;
+ return mvCols[ nPos ]->GetId();
+}
+
+
+sal_uInt16 BrowseBox::GetColumnPos( sal_uInt16 nId ) const
+{
+ for ( size_t nPos = 0; nPos < mvCols.size(); ++nPos )
+ if ( mvCols[ nPos ]->GetId() == nId )
+ return nPos;
+ return BROWSER_INVALIDID;
+}
+
+
+bool BrowseBox::IsFrozen( sal_uInt16 nColumnId ) const
+{
+ for (auto const & pCol : mvCols)
+ if ( pCol->GetId() == nColumnId )
+ return pCol->IsFrozen();
+ return false;
+}
+
+
+void BrowseBox::ExpandRowSelection( const BrowserMouseEvent& rEvt )
+{
+
+ DoHideCursor( "ExpandRowSelection" );
+
+ // expand the last selection
+ if ( bMultiSelection )
+ {
+ Range aJustifiedRange( aSelRange );
+ aJustifiedRange.Justify();
+
+ bool bSelectThis = ( bSelect != aJustifiedRange.IsInside( rEvt.GetRow() ) );
+
+ if ( aJustifiedRange.IsInside( rEvt.GetRow() ) )
+ {
+ // down and up
+ while ( rEvt.GetRow() < aSelRange.Max() )
+ { // ZTC/Mac bug - don't put these statements together!
+ SelectRow( aSelRange.Max(), bSelectThis );
+ --aSelRange.Max();
+ }
+ while ( rEvt.GetRow() > aSelRange.Max() )
+ { // ZTC/Mac bug - don't put these statements together!
+ SelectRow( aSelRange.Max(), bSelectThis );
+ ++aSelRange.Max();
+ }
+ }
+ else
+ {
+ // up and down
+ bool bOldSelecting = bSelecting;
+ bSelecting = true;
+ while ( rEvt.GetRow() < aSelRange.Max() )
+ { // ZTC/Mac bug - don't put these statements together!
+ --aSelRange.Max();
+ if ( !IsRowSelected( aSelRange.Max() ) )
+ {
+ SelectRow( aSelRange.Max(), bSelectThis );
+ bSelect = true;
+ }
+ }
+ while ( rEvt.GetRow() > aSelRange.Max() )
+ { // ZTC/Mac bug - don't put these statements together!
+ ++aSelRange.Max();
+ if ( !IsRowSelected( aSelRange.Max() ) )
+ {
+ SelectRow( aSelRange.Max(), bSelectThis );
+ bSelect = true;
+ }
+ }
+ bSelecting = bOldSelecting;
+ if ( bSelect )
+ Select();
+ }
+ }
+ else
+ if (!IsRowSelected(rEvt.GetRow()))
+ SelectRow( rEvt.GetRow() );
+
+ GoToRow( rEvt.GetRow(), false );
+ DoShowCursor( "ExpandRowSelection" );
+}
+
+
+void BrowseBox::Resize()
+{
+ if ( !bBootstrapped && IsReallyVisible() )
+ BrowseBox::StateChanged( StateChangedType::InitShow );
+ if ( mvCols.empty() )
+ {
+ pDataWin->bResizeOnPaint = true;
+ return;
+ }
+ pDataWin->bResizeOnPaint = false;
+
+ // calc the size of the scrollbars
+ sal_uLong nSBSize = GetBarHeight();
+ if (IsZoom())
+ nSBSize = static_cast<sal_uLong>(nSBSize * static_cast<double>(GetZoom()));
+
+ DoHideCursor( "Resize" );
+ sal_uInt16 nOldVisibleRows = 0;
+ //fdo#42694, post #i111125# GetDataRowHeight() can be 0
+ if (GetDataRowHeight())
+ nOldVisibleRows = static_cast<sal_uInt16>(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
+
+ // did we need a horizontal scroll bar or is there a Control Area?
+ if ( !pDataWin->bNoHScroll &&
+ ( ( mvCols.size() - FrozenColCount() ) > 1 ) )
+ aHScroll->Show();
+ else
+ aHScroll->Hide();
+
+ // calculate the size of the data window
+ long nDataHeight = GetOutputSizePixel().Height() - GetTitleHeight();
+ if ( aHScroll->IsVisible() || ( nControlAreaWidth != USHRT_MAX ) )
+ nDataHeight -= nSBSize;
+
+ long nDataWidth = GetOutputSizePixel().Width();
+ if ( pVScroll->IsVisible() )
+ nDataWidth -= nSBSize;
+
+ // adjust position and size of data window
+ pDataWin->SetPosSizePixel(
+ Point( 0, GetTitleHeight() ),
+ Size( nDataWidth, nDataHeight ) );
+
+ sal_uInt16 nVisibleRows = 0;
+
+ if (GetDataRowHeight())
+ nVisibleRows = static_cast<sal_uInt16>(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
+
+ // TopRow is unchanged, but the number of visible lines has changed.
+ if ( nVisibleRows != nOldVisibleRows )
+ VisibleRowsChanged(nTopRow, nVisibleRows);
+
+ UpdateScrollbars();
+
+ // Control-Area
+ tools::Rectangle aInvalidArea( GetControlArea() );
+ aInvalidArea.SetRight( GetOutputSizePixel().Width() );
+ aInvalidArea.SetLeft( 0 );
+ Invalidate( aInvalidArea );
+
+ // external header-bar
+ HeaderBar* pHeaderBar = pDataWin->pHeaderBar;
+ if ( pHeaderBar )
+ {
+ // take the handle column into account
+ BrowserColumn *pFirstCol = mvCols[ 0 ].get();
+ long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();
+ pHeaderBar->SetPosSizePixel( Point( nOfsX, 0 ), Size( GetOutputSizePixel().Width() - nOfsX, GetTitleHeight() ) );
+ }
+
+ AutoSizeLastColumn(); // adjust last column width
+ DoShowCursor( "Resize" );
+}
+
+
+void BrowseBox::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
+{
+
+ // initializations
+ if (!bBootstrapped && IsReallyVisible())
+ BrowseBox::StateChanged(StateChangedType::InitShow);
+ if (mvCols.empty())
+ return;
+
+ BrowserColumn *pFirstCol = mvCols[ 0 ].get();
+ bool bHandleCol = pFirstCol && pFirstCol->GetId() == 0;
+ bool bHeaderBar = pDataWin->pHeaderBar.get() != nullptr;
+
+ // draw delimitational lines
+ if (!pDataWin->bNoHScroll)
+ rRenderContext.DrawLine(Point(0, aHScroll->GetPosPixel().Y()),
+ Point(GetOutputSizePixel().Width(),
+ aHScroll->GetPosPixel().Y()));
+
+ if (nTitleLines)
+ {
+ if (!bHeaderBar)
+ {
+ rRenderContext.DrawLine(Point(0, GetTitleHeight() - 1),
+ Point(GetOutputSizePixel().Width(), GetTitleHeight() - 1));
+ }
+ else if (bHandleCol)
+ {
+ rRenderContext.DrawLine(Point(0, GetTitleHeight() - 1),
+ Point(pFirstCol->Width(), GetTitleHeight() - 1));
+ }
+ }
+
+ // Title Bar
+ // If there is a handle column and if the header bar is available, only
+ // take the HandleColumn into account
+ if (!(nTitleLines && (!bHeaderBar || bHandleCol)))
+ return;
+
+ // iterate through columns to redraw
+ long nX = 0;
+ size_t nCol;
+ for (nCol = 0; nCol < mvCols.size() && nX < rRect.Right(); ++nCol)
+ {
+ // skip invisible columns between frozen and scrollable area
+ if (nCol < nFirstCol && !mvCols[nCol]->IsFrozen())
+ nCol = nFirstCol;
+
+ // only the handle column?
+ if (bHeaderBar && bHandleCol && nCol > 0)
+ break;
+
+ BrowserColumn* pCol = mvCols[nCol].get();
+
+ // draw the column and increment position
+ if ( pCol->Width() > 4 )
+ {
+ ButtonFrame aButtonFrame( Point( nX, 0 ),
+ Size( pCol->Width()-1, GetTitleHeight()-1 ),
+ pCol->Title(), !IsEnabled());
+ aButtonFrame.Draw(rRenderContext);
+ rRenderContext.DrawLine(Point(nX + pCol->Width() - 1, 0),
+ Point(nX + pCol->Width() - 1, GetTitleHeight() - 1));
+ }
+ else
+ {
+ rRenderContext.Push(PushFlags::FILLCOLOR);
+ rRenderContext.SetFillColor(COL_BLACK);
+ rRenderContext.DrawRect(tools::Rectangle(Point(nX, 0), Size(pCol->Width(), GetTitleHeight() - 1)));
+ rRenderContext.Pop();
+ }
+
+ // skip column
+ nX += pCol->Width();
+ }
+
+ // retouching
+ if ( !bHeaderBar && nCol == mvCols.size() )
+ {
+ const StyleSettings &rSettings = rRenderContext.GetSettings().GetStyleSettings();
+ Color aColFace(rSettings.GetFaceColor());
+ rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::LINECOLOR);
+ rRenderContext.SetFillColor(aColFace);
+ rRenderContext.SetLineColor(aColFace);
+ rRenderContext.DrawRect(tools::Rectangle(Point(nX, 0),
+ Point(rRect.Right(), GetTitleHeight() - 2 )));
+ rRenderContext.Pop();
+ }
+}
+
+void BrowseBox::Draw( OutputDevice* pDev, const Point& rPos, DrawFlags nFlags )
+{
+ // we need pixel coordinates
+ Size aRealSize = GetSizePixel();
+ Point aRealPos = pDev->LogicToPixel(rPos);
+
+ if ((aRealSize.Width() < 3) || (aRealSize.Height() < 3))
+ // we want to have two pixels frame ...
+ return;
+
+ vcl::Font aFont = pDataWin->GetDrawPixelFont( pDev );
+ // the 'normal' painting uses always the data window as device to output to, so we have to calc the new font
+ // relative to the data wins current settings
+
+ pDev->Push();
+ pDev->SetMapMode();
+ pDev->SetFont( aFont );
+
+ // draw a frame
+ const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
+ pDev->SetLineColor(rStyleSettings.GetDarkShadowColor());
+ pDev->DrawLine(Point(aRealPos.X(), aRealPos.Y()),
+ Point(aRealPos.X(), aRealPos.Y() + aRealSize.Height() - 1));
+ pDev->DrawLine(Point(aRealPos.X(), aRealPos.Y()),
+ Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y()));
+ pDev->SetLineColor(rStyleSettings.GetShadowColor());
+ pDev->DrawLine(Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + 1),
+ Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + aRealSize.Height() - 1));
+ pDev->DrawLine(Point(aRealPos.X() + aRealSize.Width() - 1, aRealPos.Y() + aRealSize.Height() - 1),
+ Point(aRealPos.X() + 1, aRealPos.Y() + aRealSize.Height() - 1));
+
+ HeaderBar* pBar = pDataWin->pHeaderBar;
+
+ // we're drawing onto a foreign device, so we have to fake the DataRowHeight for the subsequent ImplPaintData
+ // (as it is based on the settings of our data window, not the foreign device)
+ if (!nDataRowHeight)
+ ImpGetDataRowHeight();
+ long nHeightLogic = PixelToLogic(Size(0, nDataRowHeight), MapMode(MapUnit::Map10thMM)).Height();
+ long nForeignHeightPixel = pDev->LogicToPixel(Size(0, nHeightLogic), MapMode(MapUnit::Map10thMM)).Height();
+
+ long nOriginalHeight = nDataRowHeight;
+ nDataRowHeight = nForeignHeightPixel;
+
+ // this counts for the column widths, too
+ size_t nPos;
+ for ( nPos = 0; nPos < mvCols.size(); ++nPos )
+ {
+ BrowserColumn* pCurrent = mvCols[ nPos ].get();
+
+ long nWidthLogic = PixelToLogic(Size(pCurrent->Width(), 0), MapMode(MapUnit::Map10thMM)).Width();
+ long nForeignWidthPixel = pDev->LogicToPixel(Size(nWidthLogic, 0), MapMode(MapUnit::Map10thMM)).Width();
+
+ pCurrent->SetWidth(nForeignWidthPixel, GetZoom());
+ if ( pBar )
+ pBar->SetItemSize( pCurrent->GetId(), pCurrent->Width() );
+ }
+
+ // a smaller area for the content
+ aRealPos.AdjustX( 1 );
+ aRealPos.AdjustY( 1 );
+ aRealSize.AdjustWidth( -2 );
+ aRealSize.AdjustHeight( -2 );
+
+ // let the header bar draw itself
+ if ( pBar )
+ {
+ // the title height with respect to the font set for the given device
+ long nTitleHeight = PixelToLogic(Size(0, GetTitleHeight()), MapMode(MapUnit::Map10thMM)).Height();
+ nTitleHeight = pDev->LogicToPixel(Size(0, nTitleHeight), MapMode(MapUnit::Map10thMM)).Height();
+
+ BrowserColumn* pFirstCol = !mvCols.empty() ? mvCols[ 0 ].get() : nullptr;
+
+ Point aHeaderPos(pFirstCol && (pFirstCol->GetId() == 0) ? pFirstCol->Width() : 0, 0);
+ Size aHeaderSize(aRealSize.Width() - aHeaderPos.X(), nTitleHeight);
+
+ aHeaderPos += aRealPos;
+ // do this before converting to logics !
+
+ // the header's draw expects logic coordinates, again
+ aHeaderPos = pDev->PixelToLogic(aHeaderPos);
+
+ Size aOrigSize(pBar->GetSizePixel());
+ pBar->SetSizePixel(aHeaderSize);
+ pBar->Draw(pDev, aHeaderPos, nFlags);
+ pBar->SetSizePixel(aOrigSize);
+
+ // draw the "upper left cell" (the intersection between the header bar and the handle column)
+ if (pFirstCol && (pFirstCol->GetId() == 0) && (pFirstCol->Width() > 4))
+ {
+ ButtonFrame aButtonFrame( aRealPos,
+ Size( pFirstCol->Width()-1, nTitleHeight-1 ),
+ pFirstCol->Title(), !IsEnabled());
+ aButtonFrame.Draw( *pDev );
+
+ pDev->Push( PushFlags::LINECOLOR );
+ pDev->SetLineColor( COL_BLACK );
+
+ pDev->DrawLine( Point( aRealPos.X(), aRealPos.Y() + nTitleHeight-1 ),
+ Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() + nTitleHeight-1 ) );
+ pDev->DrawLine( Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() ),
+ Point( aRealPos.X() + pFirstCol->Width() - 1, aRealPos.Y() + nTitleHeight-1 ) );
+
+ pDev->Pop();
+ }
+
+ aRealPos.AdjustY(aHeaderSize.Height() );
+ aRealSize.AdjustHeight( -(aHeaderSize.Height()) );
+ }
+
+ // draw our own content (with clipping)
+ vcl::Region aRegion(tools::Rectangle(aRealPos, aRealSize));
+ pDev->SetClipRegion( pDev->PixelToLogic( aRegion ) );
+
+ // do we have to paint the background
+ bool bBackground = pDataWin->IsControlBackground();
+ if ( bBackground )
+ {
+ tools::Rectangle aRect( aRealPos, aRealSize );
+ pDev->SetFillColor( pDataWin->GetControlBackground() );
+ pDev->DrawRect( aRect );
+ }
+
+ ImplPaintData( *pDev, tools::Rectangle( aRealPos, aRealSize ), true );
+
+ // restore the column widths/data row height
+ nDataRowHeight = nOriginalHeight;
+ for ( nPos = 0; nPos < mvCols.size(); ++nPos )
+ {
+ BrowserColumn* pCurrent = mvCols[ nPos ].get();
+
+ long nForeignWidthLogic = pDev->PixelToLogic(Size(pCurrent->Width(), 0), MapMode(MapUnit::Map10thMM)).Width();
+ long nWidthPixel = LogicToPixel(Size(nForeignWidthLogic, 0), MapMode(MapUnit::Map10thMM)).Width();
+
+ pCurrent->SetWidth(nWidthPixel, GetZoom());
+ if ( pBar )
+ pBar->SetItemSize( pCurrent->GetId(), pCurrent->Width() );
+ }
+
+ pDev->Pop();
+}
+
+void BrowseBox::ImplPaintData(OutputDevice& _rOut, const tools::Rectangle& _rRect, bool _bForeignDevice)
+{
+ Point aOverallAreaPos = _bForeignDevice ? _rRect.TopLeft() : Point(0,0);
+ Size aOverallAreaSize = _bForeignDevice ? _rRect.GetSize() : pDataWin->GetOutputSizePixel();
+ Point aOverallAreaBRPos = _bForeignDevice ? _rRect.BottomRight() : Point( aOverallAreaSize.Width(), aOverallAreaSize.Height() );
+
+ long nDataRowHeigt = GetDataRowHeight();
+
+ // compute relative rows to redraw
+ sal_uLong nRelTopRow = 0;
+ sal_uLong nRelBottomRow = aOverallAreaSize.Height();
+ if (!_bForeignDevice && nDataRowHeigt)
+ {
+ nRelTopRow = (static_cast<sal_uLong>(_rRect.Top()) / nDataRowHeigt);
+ nRelBottomRow = static_cast<sal_uLong>(_rRect.Bottom()) / nDataRowHeigt;
+ }
+
+ // cache frequently used values
+ Point aPos( aOverallAreaPos.X(), nRelTopRow * nDataRowHeigt + aOverallAreaPos.Y() );
+ _rOut.SetLineColor( COL_WHITE );
+ const AllSettings& rAllSets = _rOut.GetSettings();
+ const StyleSettings &rSettings = rAllSets.GetStyleSettings();
+ const Color &rHighlightTextColor = rSettings.GetHighlightTextColor();
+ const Color &rHighlightFillColor = rSettings.GetHighlightColor();
+ Color aOldTextColor = _rOut.GetTextColor();
+ Color aOldFillColor = _rOut.GetFillColor();
+ Color aOldLineColor = _rOut.GetLineColor();
+ long nHLineX = 0 == mvCols[ 0 ]->GetId() ? mvCols[ 0 ]->Width() : 0;
+ nHLineX += aOverallAreaPos.X();
+
+ Color aDelimiterLineColor( ::svtools::ColorConfig().GetColorValue( ::svtools::CALCGRID ).nColor );
+
+ // redraw the invalid fields
+ for ( sal_uLong nRelRow = nRelTopRow;
+ nRelRow <= nRelBottomRow && static_cast<sal_uLong>(nTopRow)+nRelRow < o3tl::make_unsigned(nRowCount);
+ ++nRelRow, aPos.AdjustY(nDataRowHeigt ) )
+ {
+ // get row
+ // check valid area, to be on the safe side:
+ DBG_ASSERT( static_cast<sal_uInt16>(nTopRow+nRelRow) < nRowCount, "BrowseBox::ImplPaintData: invalid seek" );
+ if ( (nTopRow+long(nRelRow)) < 0 || static_cast<sal_uInt16>(nTopRow+nRelRow) >= nRowCount )
+ continue;
+
+ // prepare row
+ sal_uLong nRow = nTopRow+nRelRow;
+ if ( !SeekRow( nRow) ) {
+ OSL_FAIL("BrowseBox::ImplPaintData: SeekRow failed");
+ }
+ _rOut.SetClipRegion();
+ aPos.setX( aOverallAreaPos.X() );
+
+
+ // #73325# don't paint the row outside the painting rectangle (DG)
+ // prepare auto-highlight
+ tools::Rectangle aRowRect( Point( _rRect.TopLeft().X(), aPos.Y() ),
+ Size( _rRect.GetSize().Width(), nDataRowHeigt ) );
+
+ bool bRowSelected = !bHideSelect
+ && IsRowSelected( nRow );
+ if ( bRowSelected )
+ {
+ _rOut.SetTextColor( rHighlightTextColor );
+ _rOut.SetFillColor( rHighlightFillColor );
+ _rOut.SetLineColor();
+ _rOut.DrawRect( aRowRect );
+ }
+
+ // iterate through columns to redraw
+ size_t nCol;
+ for ( nCol = 0; nCol < mvCols.size(); ++nCol )
+ {
+ // get column
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+
+ // at end of invalid area
+ if ( aPos.X() >= _rRect.Right() )
+ break;
+
+ // skip invisible columns between frozen and scrollable area
+ if ( nCol < nFirstCol && !pCol->IsFrozen() )
+ {
+ nCol = nFirstCol;
+ pCol = (nCol < mvCols.size() ) ? mvCols[ nCol ].get() : nullptr;
+ if (!pCol)
+ { // FS - 21.05.99 - 66325
+ // actually this has been fixed elsewhere (in the right place),
+ // but let's make sure...
+ OSL_FAIL("BrowseBox::PaintData : nFirstCol is probably invalid !");
+ break;
+ }
+ }
+
+ // prepare Column-AutoHighlight
+ bool bColAutoHighlight = bColumnCursor
+ && IsColumnSelected( pCol->GetId() );
+ if ( bColAutoHighlight )
+ {
+ _rOut.SetClipRegion();
+ _rOut.SetTextColor( rHighlightTextColor );
+ _rOut.SetFillColor( rHighlightFillColor );
+ _rOut.SetLineColor();
+ tools::Rectangle aFieldRect( aPos,
+ Size( pCol->Width(), nDataRowHeigt ) );
+ _rOut.DrawRect( aFieldRect );
+ }
+
+ if (!m_bFocusOnlyCursor && (pCol->GetId() == GetCurColumnId()) && (nRow == static_cast<sal_uLong>(GetCurRow())))
+ DrawCursor();
+
+ // draw a single field.
+ // else something is drawn to, e.g. handle column
+ if (pCol->Width())
+ {
+ // clip the column's output to the field area
+ if (_bForeignDevice)
+ { // (not necessary if painting onto the data window)
+ Size aFieldSize(pCol->Width(), nDataRowHeigt);
+
+ if (aPos.X() + aFieldSize.Width() > aOverallAreaBRPos.X())
+ aFieldSize.setWidth( aOverallAreaBRPos.X() - aPos.X() );
+
+ if (aPos.Y() + aFieldSize.Height() > aOverallAreaBRPos.Y() + 1)
+ {
+ // for non-handle cols we don't clip vertically : we just don't draw the cell if the line isn't completely visible
+ if (pCol->GetId() != 0)
+ continue;
+ aFieldSize.setHeight( aOverallAreaBRPos.Y() + 1 - aPos.Y() );
+ }
+
+ vcl::Region aClipToField(tools::Rectangle(aPos, aFieldSize));
+ _rOut.SetClipRegion(aClipToField);
+ }
+ pCol->Draw( *this, _rOut, aPos );
+ if (_bForeignDevice)
+ _rOut.SetClipRegion();
+ }
+
+ // reset Column-auto-highlight
+ if ( bColAutoHighlight )
+ {
+ _rOut.SetTextColor( aOldTextColor );
+ _rOut.SetFillColor( aOldFillColor );
+ _rOut.SetLineColor( aOldLineColor );
+ }
+
+ // skip column
+ aPos.AdjustX(pCol->Width() );
+ }
+
+ // reset auto-highlight
+ if ( bRowSelected )
+ {
+ _rOut.SetTextColor( aOldTextColor );
+ _rOut.SetFillColor( aOldFillColor );
+ _rOut.SetLineColor( aOldLineColor );
+ }
+
+ if ( bHLines )
+ {
+ // draw horizontal delimitation lines
+ _rOut.SetClipRegion();
+ _rOut.Push( PushFlags::LINECOLOR );
+ _rOut.SetLineColor( aDelimiterLineColor );
+ long nY = aPos.Y() + nDataRowHeigt - 1;
+ if (nY <= aOverallAreaBRPos.Y())
+ _rOut.DrawLine( Point( nHLineX, nY ),
+ Point( bVLines
+ ? std::min(long(aPos.X() - 1), aOverallAreaBRPos.X())
+ : aOverallAreaBRPos.X(),
+ nY ) );
+ _rOut.Pop();
+ }
+ }
+
+ if (aPos.Y() > aOverallAreaBRPos.Y() + 1)
+ aPos.setY( aOverallAreaBRPos.Y() + 1 );
+ // needed for some of the following drawing
+
+ // retouching
+ _rOut.SetClipRegion();
+ aOldLineColor = _rOut.GetLineColor();
+ aOldFillColor = _rOut.GetFillColor();
+ _rOut.SetFillColor( rSettings.GetFaceColor() );
+ if ( !mvCols.empty() && ( mvCols[ 0 ]->GetId() == 0 ) && ( aPos.Y() <= _rRect.Bottom() ) )
+ {
+ // fill rectangle gray below handle column
+ // DG: fill it only until the end of the drawing rect and not to the end, as this may overpaint handle columns
+ _rOut.SetLineColor( COL_BLACK );
+ _rOut.DrawRect( tools::Rectangle(
+ Point( aOverallAreaPos.X() - 1, aPos.Y() - 1 ),
+ Point( aOverallAreaPos.X() + mvCols[ 0 ]->Width() - 1,
+ _rRect.Bottom() + 1) ) );
+ }
+ _rOut.SetFillColor( aOldFillColor );
+
+ // draw vertical delimitational line between frozen and scrollable cols
+ _rOut.SetLineColor( COL_BLACK );
+ long nFrozenWidth = GetFrozenWidth()-1;
+ _rOut.DrawLine( Point( aOverallAreaPos.X() + nFrozenWidth, aPos.Y() ),
+ Point( aOverallAreaPos.X() + nFrozenWidth, bHLines
+ ? aPos.Y() - 1
+ : aOverallAreaBRPos.Y() ) );
+
+ // draw vertical delimitational lines?
+ if ( bVLines )
+ {
+ _rOut.SetLineColor( aDelimiterLineColor );
+ Point aVertPos( aOverallAreaPos.X() - 1, aOverallAreaPos.Y() );
+ long nDeltaY = aOverallAreaBRPos.Y();
+ for ( size_t nCol = 0; nCol < mvCols.size(); ++nCol )
+ {
+ // get column
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+
+ // skip invisible columns between frozen and scrollable area
+ if ( nCol < nFirstCol && !pCol->IsFrozen() )
+ {
+ nCol = nFirstCol;
+ pCol = mvCols[ nCol ].get();
+ }
+
+ // skip column
+ aVertPos.AdjustX(pCol->Width() );
+
+ // at end of invalid area
+ // invalid area is first reached when X > Right
+ // and not >=
+ if ( aVertPos.X() > _rRect.Right() )
+ break;
+
+ // draw a single line
+ if ( pCol->GetId() != 0 )
+ _rOut.DrawLine( aVertPos, Point( aVertPos.X(),
+ bHLines
+ ? aPos.Y() - 1
+ : aPos.Y() + nDeltaY ) );
+ }
+ }
+
+ _rOut.SetLineColor( aOldLineColor );
+}
+
+void BrowseBox::PaintData( vcl::Window const & rWin, vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect )
+{
+ if (!bBootstrapped && IsReallyVisible())
+ BrowseBox::StateChanged(StateChangedType::InitShow);
+
+ // initializations
+ if (mvCols.empty() || !rWin.IsUpdateMode())
+ return;
+ if (pDataWin->bResizeOnPaint)
+ Resize();
+ // MI: who was that? Window::Update();
+
+ ImplPaintData(rRenderContext, rRect, false);
+}
+
+long BrowseBox::GetBarHeight() const
+{
+ // tdf#115941 because some platforms have things like overlay scrollbars, take a max
+ // of a statusbar height and a scrollbar height as the control area height
+
+ // (we can't ask the scrollbars for their size cause if we're zoomed they still have to be
+ // resized - which is done in UpdateScrollbars)
+
+ return std::max(aStatusBar->GetSizePixel().Height(), GetSettings().GetStyleSettings().GetScrollBarSize());
+}
+
+void BrowseBox::UpdateScrollbars()
+{
+
+ if ( !bBootstrapped || !IsUpdateMode() )
+ return;
+
+ // protect against recursion
+ if ( pDataWin->bInUpdateScrollbars )
+ {
+ pDataWin->bHadRecursion = true;
+ return;
+ }
+ pDataWin->bInUpdateScrollbars = true;
+
+ // the size of the corner window (and the width of the VSB/height of the HSB)
+ sal_uLong nCornerSize = GetBarHeight();
+ if (IsZoom())
+ nCornerSize = static_cast<sal_uLong>(nCornerSize * static_cast<double>(GetZoom()));
+
+ bool bNeedsVScroll = false;
+ long nMaxRows = 0;
+ if (GetDataRowHeight())
+ {
+ // needs VScroll?
+ nMaxRows = (pDataWin->GetSizePixel().Height()) / GetDataRowHeight();
+ bNeedsVScroll = pDataWin->bAutoVScroll
+ ? nTopRow || ( nRowCount > nMaxRows )
+ : !pDataWin->bNoVScroll;
+ }
+ Size aDataWinSize = pDataWin->GetSizePixel();
+ if ( !bNeedsVScroll )
+ {
+ if ( pVScroll->IsVisible() )
+ {
+ pVScroll->Hide();
+ Size aNewSize( aDataWinSize );
+ aNewSize.setWidth( GetOutputSizePixel().Width() );
+ aDataWinSize = aNewSize;
+ }
+ }
+ else if ( !pVScroll->IsVisible() )
+ {
+ Size aNewSize( aDataWinSize );
+ aNewSize.setWidth( GetOutputSizePixel().Width() - nCornerSize );
+ aDataWinSize = aNewSize;
+ }
+
+ // needs HScroll?
+ sal_uLong nLastCol = GetColumnAtXPosPixel( aDataWinSize.Width() - 1 );
+
+ sal_uInt16 nFrozenCols = FrozenColCount();
+ bool bNeedsHScroll = pDataWin->bAutoHScroll
+ ? ( nFirstCol > nFrozenCols ) || ( nLastCol <= mvCols.size() )
+ : !pDataWin->bNoHScroll;
+ if ( !bNeedsHScroll )
+ {
+ if ( aHScroll->IsVisible() )
+ {
+ aHScroll->Hide();
+ }
+ aDataWinSize.setHeight( GetOutputSizePixel().Height() - GetTitleHeight() );
+ if ( nControlAreaWidth != USHRT_MAX )
+ aDataWinSize.AdjustHeight( -sal_Int32(nCornerSize) );
+ }
+ else if ( !aHScroll->IsVisible() )
+ {
+ Size aNewSize( aDataWinSize );
+ aNewSize.setHeight( GetOutputSizePixel().Height() - GetTitleHeight() - nCornerSize );
+ aDataWinSize = aNewSize;
+ }
+
+ // adjust position and Width of horizontal scrollbar
+ sal_uLong nHScrX = nControlAreaWidth == USHRT_MAX
+ ? 0
+ : nControlAreaWidth;
+
+ aHScroll->SetPosSizePixel(
+ Point( nHScrX, GetOutputSizePixel().Height() - nCornerSize ),
+ Size( aDataWinSize.Width() - nHScrX, nCornerSize ) );
+
+ // total scrollable columns
+ short nScrollCols = short(mvCols.size()) - static_cast<short>(nFrozenCols);
+
+ // visible columns
+ short nVisibleHSize = nLastCol == BROWSER_INVALIDID
+ ? static_cast<short>( mvCols.size() - nFirstCol )
+ : static_cast<short>( nLastCol - nFirstCol );
+
+ short nRange = std::max( nScrollCols, short(0) );
+ aHScroll->SetVisibleSize( nVisibleHSize );
+ aHScroll->SetRange( Range( 0, nRange ));
+ if ( bNeedsHScroll && !aHScroll->IsVisible() )
+ aHScroll->Show();
+
+ // adjust position and height of vertical scrollbar
+ pVScroll->SetPageSize( nMaxRows );
+
+ if ( nTopRow > nRowCount )
+ {
+ nTopRow = nRowCount - 1;
+ OSL_FAIL("BrowseBox: nTopRow > nRowCount");
+ }
+
+ if ( pVScroll->GetThumbPos() != nTopRow )
+ pVScroll->SetThumbPos( nTopRow );
+ long nVisibleSize = std::min( std::min( nRowCount, nMaxRows ), long(nRowCount-nTopRow) );
+ pVScroll->SetVisibleSize( nVisibleSize ? nVisibleSize : 1 );
+ pVScroll->SetRange( Range( 0, nRowCount ) );
+ pVScroll->SetPosSizePixel(
+ Point( aDataWinSize.Width(), GetTitleHeight() ),
+ Size( nCornerSize, aDataWinSize.Height()) );
+ long nLclDataRowHeight = GetDataRowHeight();
+ if ( nLclDataRowHeight > 0 && nRowCount < long( aDataWinSize.Height() / nLclDataRowHeight ) )
+ ScrollRows( -nTopRow );
+ if ( bNeedsVScroll && !pVScroll->IsVisible() )
+ pVScroll->Show();
+
+ pDataWin->SetPosSizePixel(
+ Point( 0, GetTitleHeight() ),
+ aDataWinSize );
+
+ // needs corner-window?
+ // (do that AFTER positioning BOTH scrollbars)
+ sal_uLong nActualCorderWidth = 0;
+ if (aHScroll->IsVisible() && pVScroll && pVScroll->IsVisible() )
+ {
+ // if we have both scrollbars, the corner window fills the point of intersection of these two
+ nActualCorderWidth = nCornerSize;
+ }
+ else if ( !aHScroll->IsVisible() && ( nControlAreaWidth != USHRT_MAX ) )
+ {
+ // if we have no horizontal scrollbar, but a control area, we need the corner window to
+ // fill the space between the control are and the right border
+ nActualCorderWidth = GetOutputSizePixel().Width() - nControlAreaWidth;
+ }
+ if ( nActualCorderWidth )
+ {
+ if ( !pDataWin->pCornerWin )
+ pDataWin->pCornerWin = VclPtr<ScrollBarBox>::Create( this, 0 );
+ pDataWin->pCornerWin->SetPosSizePixel(
+ Point( GetOutputSizePixel().Width() - nActualCorderWidth, aHScroll->GetPosPixel().Y() ),
+ Size( nActualCorderWidth, nCornerSize ) );
+ pDataWin->pCornerWin->Show();
+ }
+ else
+ pDataWin->pCornerWin.disposeAndClear();
+
+ // scroll headerbar, if necessary
+ if ( pDataWin->pHeaderBar )
+ {
+ long nWidth = 0;
+ for ( size_t nCol = 0;
+ nCol < mvCols.size() && nCol < nFirstCol;
+ ++nCol )
+ {
+ // not the handle column
+ if ( mvCols[ nCol ]->GetId() )
+ nWidth += mvCols[ nCol ]->Width();
+ }
+
+ pDataWin->pHeaderBar->SetOffset( nWidth );
+ }
+
+ pDataWin->bInUpdateScrollbars = false;
+ if ( pDataWin->bHadRecursion )
+ {
+ pDataWin->bHadRecursion = false;
+ UpdateScrollbars();
+ }
+}
+
+
+void BrowseBox::SetUpdateMode( bool bUpdate )
+{
+
+ bool bWasUpdate = IsUpdateMode();
+ if ( bWasUpdate == bUpdate )
+ return;
+
+ Control::SetUpdateMode( bUpdate );
+ // If WB_CLIPCHILDREN is st at the BrowseBox (to minimize flicker),
+ // the data window is not invalidated by SetUpdateMode.
+ if( bUpdate )
+ pDataWin->Invalidate();
+ pDataWin->SetUpdateMode( bUpdate );
+
+
+ if ( bUpdate )
+ {
+ if ( bBootstrapped )
+ {
+ UpdateScrollbars();
+ AutoSizeLastColumn();
+ }
+ DoShowCursor( "SetUpdateMode" );
+ }
+ else
+ DoHideCursor( "SetUpdateMode" );
+}
+
+
+bool BrowseBox::GetUpdateMode() const
+{
+
+ return pDataWin->IsUpdateMode();
+}
+
+
+long BrowseBox::GetFrozenWidth() const
+{
+
+ long nWidth = 0;
+ for ( size_t nCol = 0;
+ nCol < mvCols.size() && mvCols[ nCol ]->IsFrozen();
+ ++nCol )
+ nWidth += mvCols[ nCol ]->Width();
+ return nWidth;
+}
+
+
+void BrowseBox::ColumnInserted( sal_uInt16 nPos )
+{
+ if ( pColSel )
+ pColSel->Insert( nPos );
+ UpdateScrollbars();
+}
+
+
+sal_uInt16 BrowseBox::FrozenColCount() const
+{
+ std::size_t nCol;
+ for ( nCol = 0;
+ nCol < mvCols.size() && mvCols[ nCol ]->IsFrozen();
+ ++nCol )
+ /* empty loop */;
+ return nCol; //TODO: BrowserColumns::size_type -> sal_uInt16!
+}
+
+
+IMPL_LINK(BrowseBox, ScrollHdl, ScrollBar*, pBar, void)
+{
+ if ( pBar->GetDelta() == 0 )
+ return;
+
+ if ( pBar == aHScroll.get() )
+ ScrollColumns( aHScroll->GetDelta() );
+ if ( pBar == pVScroll )
+ ScrollRows( pVScroll->GetDelta() );
+}
+
+
+IMPL_LINK( BrowseBox, StartDragHdl, HeaderBar*, pBar, void )
+{
+ pBar->SetDragSize( pDataWin->GetOutputSizePixel().Height() );
+}
+
+
+// usually only the first column was resized
+
+void BrowseBox::MouseButtonDown( const MouseEvent& rEvt )
+{
+
+ GrabFocus();
+
+ // only mouse events in the title-line are supported
+ const Point &rEvtPos = rEvt.GetPosPixel();
+ if ( rEvtPos.Y() >= GetTitleHeight() )
+ return;
+
+ long nX = 0;
+ long nWidth = GetOutputSizePixel().Width();
+ for ( size_t nCol = 0; nCol < mvCols.size() && nX < nWidth; ++nCol )
+ {
+ // is this column visible?
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+ if ( pCol->IsFrozen() || nCol >= nFirstCol )
+ {
+ // compute right end of column
+ long nR = nX + pCol->Width() - 1;
+
+ // at the end of a column (and not handle column)?
+ if ( pCol->GetId() && std::abs( nR - rEvtPos.X() ) < 2 )
+ {
+ // start resizing the column
+ bResizing = true;
+ nResizeCol = nCol;
+ nDragX = nResizeX = rEvtPos.X();
+ SetPointer( PointerStyle::HSplit );
+ CaptureMouse();
+ pDataWin->DrawLine( Point( nDragX, 0 ),
+ Point( nDragX, pDataWin->GetSizePixel().Height() ) );
+ nMinResizeX = nX + MIN_COLUMNWIDTH;
+ return;
+ }
+ else if ( nX < rEvtPos.X() && nR > rEvtPos.X() )
+ {
+ MouseButtonDown( BrowserMouseEvent(
+ this, rEvt, -1, nCol, pCol->GetId(), tools::Rectangle() ) );
+ return;
+ }
+ nX = nR + 1;
+ }
+ }
+
+ // event occurred out of data area
+ if ( rEvt.IsRight() )
+ pDataWin->Command(
+ CommandEvent( Point( 1, LONG_MAX ), CommandEventId::ContextMenu, true ) );
+ else
+ SetNoSelection();
+}
+
+
+void BrowseBox::MouseMove( const MouseEvent& rEvt )
+{
+ SAL_INFO("svtools", "BrowseBox::MouseMove( MouseEvent )" );
+
+ PointerStyle aNewPointer = PointerStyle::Arrow;
+
+ sal_uInt16 nX = 0;
+ for ( size_t nCol = 0;
+ nCol < mvCols.size() &&
+ ( nX + mvCols[ nCol ]->Width() ) < o3tl::make_unsigned(GetOutputSizePixel().Width());
+ ++nCol )
+ // is this column visible?
+ if ( mvCols[ nCol ]->IsFrozen() || nCol >= nFirstCol )
+ {
+ // compute right end of column
+ BrowserColumn *pCol = mvCols[ nCol ].get();
+ sal_uInt16 nR = static_cast<sal_uInt16>(nX + pCol->Width() - 1);
+
+ // show resize-pointer?
+ if ( bResizing || ( pCol->GetId() &&
+ std::abs( static_cast<long>(nR) - rEvt.GetPosPixel().X() ) < MIN_COLUMNWIDTH ) )
+ {
+ aNewPointer = PointerStyle::HSplit;
+ if ( bResizing )
+ {
+ // delete old auxiliary line
+ pDataWin->HideTracking() ;
+
+ // check allowed width and new delta
+ nDragX = std::max( rEvt.GetPosPixel().X(), nMinResizeX );
+ long nDeltaX = nDragX - nResizeX;
+ sal_uInt16 nId = GetColumnId(nResizeCol);
+ sal_uLong nOldWidth = GetColumnWidth(nId);
+ nDragX = nOldWidth + nDeltaX + nResizeX - nOldWidth;
+
+ // draw new auxiliary line
+ pDataWin->ShowTracking( tools::Rectangle( Point( nDragX, 0 ),
+ Size( 1, pDataWin->GetSizePixel().Height() ) ),
+ ShowTrackFlags::Split|ShowTrackFlags::TrackWindow );
+ }
+
+ }
+
+ nX = nR + 1;
+ }
+
+ SetPointer( aNewPointer );
+}
+
+
+void BrowseBox::MouseButtonUp( const MouseEvent & rEvt )
+{
+
+ if ( bResizing )
+ {
+ // delete auxiliary line
+ pDataWin->HideTracking();
+
+ // width changed?
+ nDragX = std::max( rEvt.GetPosPixel().X(), nMinResizeX );
+ if ( (nDragX - nResizeX) != static_cast<long>(mvCols[ nResizeCol ]->Width()) )
+ {
+ // resize column
+ long nMaxX = pDataWin->GetSizePixel().Width();
+ nDragX = std::min( nDragX, nMaxX );
+ long nDeltaX = nDragX - nResizeX;
+ sal_uInt16 nId = GetColumnId(nResizeCol);
+ SetColumnWidth( GetColumnId(nResizeCol), GetColumnWidth(nId) + nDeltaX );
+ ColumnResized( nId );
+ }
+
+ // end action
+ SetPointer( PointerStyle::Arrow );
+ ReleaseMouse();
+ bResizing = false;
+ }
+ else
+ MouseButtonUp( BrowserMouseEvent( pDataWin,
+ MouseEvent( Point( rEvt.GetPosPixel().X(),
+ rEvt.GetPosPixel().Y() - pDataWin->GetPosPixel().Y() ),
+ rEvt.GetClicks(), rEvt.GetMode(), rEvt.GetButtons(),
+ rEvt.GetModifier() ) ) );
+}
+
+
+static bool bExtendedMode = false;
+static bool bFieldMode = false;
+
+void BrowseBox::MouseButtonDown( const BrowserMouseEvent& rEvt )
+{
+
+ GrabFocus();
+
+ // adjust selection while and after double-click
+ if ( rEvt.GetClicks() == 2 )
+ {
+ SetNoSelection();
+ if ( rEvt.GetRow() >= 0 )
+ {
+ GoToRow( rEvt.GetRow() );
+ SelectRow( rEvt.GetRow(), true, false );
+ }
+ else
+ {
+ if ( bColumnCursor && rEvt.GetColumn() != 0 )
+ {
+ if ( rEvt.GetColumn() < mvCols.size() )
+ SelectColumnPos( rEvt.GetColumn(), true, false);
+ }
+ }
+ DoubleClick( rEvt );
+ }
+ // selections
+ else if ( ( rEvt.GetMode() & ( MouseEventModifiers::SELECT | MouseEventModifiers::SIMPLECLICK ) ) &&
+ ( bColumnCursor || rEvt.GetRow() >= 0 ) )
+ {
+ if ( rEvt.GetClicks() == 1 )
+ {
+ // initialise flags
+ bHit = false;
+
+ // selection out of range?
+ if ( rEvt.GetRow() >= nRowCount ||
+ rEvt.GetColumnId() == BROWSER_INVALIDID )
+ {
+ SetNoSelection();
+ return;
+ }
+
+ // while selecting, no cursor
+ bSelecting = true;
+ DoHideCursor( "MouseButtonDown" );
+
+ // DataRow?
+ if ( rEvt.GetRow() >= 0 )
+ {
+ // line selection?
+ if ( rEvt.GetColumnId() == HandleColumnId || !bColumnCursor )
+ {
+ if ( bMultiSelection )
+ {
+ // remove column-selection, if exists
+ if ( pColSel && pColSel->GetSelectCount() )
+ {
+ ToggleSelection();
+ if ( bMultiSelection )
+ uRow.pSel->SelectAll(false);
+ else
+ uRow.nSel = BROWSER_ENDOFSELECTION;
+ if ( pColSel )
+ pColSel->SelectAll(false);
+ bSelect = true;
+ }
+
+ // expanding mode?
+ if ( rEvt.GetMode() & MouseEventModifiers::RANGESELECT )
+ {
+ // select the further touched rows too
+ bSelect = true;
+ ExpandRowSelection( rEvt );
+ return;
+ }
+
+ // click in the selected area?
+ else if ( IsRowSelected( rEvt.GetRow() ) )
+ {
+ // wait for Drag&Drop
+ bHit = true;
+ bExtendedMode = bool( rEvt.GetMode() & MouseEventModifiers::MULTISELECT );
+ return;
+ }
+
+ // extension mode?
+ else if ( rEvt.GetMode() & MouseEventModifiers::MULTISELECT )
+ {
+ // determine the new selection range
+ // and selection/deselection
+ aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
+ SelectRow( rEvt.GetRow(),
+ !uRow.pSel->IsSelected( rEvt.GetRow() ) );
+ bSelect = true;
+ return;
+ }
+ }
+
+ // select directly
+ SetNoSelection();
+ GoToRow( rEvt.GetRow() );
+ SelectRow( rEvt.GetRow() );
+ aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
+ bSelect = true;
+ }
+ else // Column/Field-Selection
+ {
+ // click in selected column
+ if ( IsColumnSelected( rEvt.GetColumn() ) ||
+ IsRowSelected( rEvt.GetRow() ) )
+ {
+ bHit = true;
+ bFieldMode = true;
+ return;
+ }
+
+ SetNoSelection();
+ GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
+ bSelect = true;
+ }
+ }
+ else
+ {
+ if ( bMultiSelection && rEvt.GetColumnId() == HandleColumnId )
+ {
+ // toggle all-selection
+ if ( uRow.pSel->GetSelectCount() > ( GetRowCount() / 2 ) )
+ SetNoSelection();
+ else
+ SelectAll();
+ }
+ else
+ SelectColumnPos( GetColumnPos(rEvt.GetColumnId()), true, false);
+ }
+
+ // turn cursor on again, if necessary
+ bSelecting = false;
+ DoShowCursor( "MouseButtonDown" );
+ if ( bSelect )
+ Select();
+ }
+ }
+}
+
+
+void BrowseBox::MouseButtonUp( const BrowserMouseEvent &rEvt )
+{
+
+ // D&D was possible, but did not occur
+ if ( bHit )
+ {
+ aSelRange = Range( rEvt.GetRow(), rEvt.GetRow() );
+ if ( bExtendedMode )
+ SelectRow( rEvt.GetRow(), false );
+ else
+ {
+ SetNoSelection();
+ if ( bFieldMode )
+ GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
+ else
+ {
+ GoToRow( rEvt.GetRow() );
+ SelectRow( rEvt.GetRow() );
+ }
+ }
+ bSelect = true;
+ bExtendedMode = false;
+ bFieldMode = false;
+ bHit = false;
+ }
+
+ // activate cursor
+ if ( bSelecting )
+ {
+ bSelecting = false;
+ DoShowCursor( "MouseButtonUp" );
+ if ( bSelect )
+ Select();
+ }
+}
+
+
+void BrowseBox::KeyInput( const KeyEvent& rEvt )
+{
+ if ( !ProcessKey( rEvt ) )
+ Control::KeyInput( rEvt );
+}
+
+
+bool BrowseBox::ProcessKey( const KeyEvent& rEvt )
+{
+
+ sal_uInt16 nCode = rEvt.GetKeyCode().GetCode();
+ bool bShift = rEvt.GetKeyCode().IsShift();
+ bool bCtrl = rEvt.GetKeyCode().IsMod1();
+ bool bAlt = rEvt.GetKeyCode().IsMod2();
+
+ sal_uInt16 nId = BROWSER_NONE;
+
+ if ( !bAlt && !bCtrl && !bShift )
+ {
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_CURSORDOWN; break;
+ case KEY_UP: nId = BROWSER_CURSORUP; break;
+ case KEY_HOME: nId = BROWSER_CURSORHOME; break;
+ case KEY_END: nId = BROWSER_CURSOREND; break;
+ case KEY_TAB:
+ if ( !bColumnCursor )
+ break;
+ [[fallthrough]];
+ case KEY_RIGHT: nId = BROWSER_CURSORRIGHT; break;
+ case KEY_LEFT: nId = BROWSER_CURSORLEFT; break;
+ case KEY_SPACE: nId = BROWSER_SELECT; break;
+ }
+ if ( BROWSER_NONE != nId )
+ SetNoSelection();
+
+ switch ( nCode )
+ {
+ case KEY_PAGEDOWN: nId = BROWSER_CURSORPAGEDOWN; break;
+ case KEY_PAGEUP: nId = BROWSER_CURSORPAGEUP; break;
+ }
+ }
+
+ if ( !bAlt && !bCtrl && bShift )
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_SELECTDOWN; break;
+ case KEY_UP: nId = BROWSER_SELECTUP; break;
+ case KEY_TAB:
+ if ( !bColumnCursor )
+ break;
+ nId = BROWSER_CURSORLEFT; break;
+ case KEY_HOME: nId = BROWSER_SELECTHOME; break;
+ case KEY_END: nId = BROWSER_SELECTEND; break;
+ }
+
+
+ if ( !bAlt && bCtrl && !bShift )
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_CURSORDOWN; break;
+ case KEY_UP: nId = BROWSER_CURSORUP; break;
+ case KEY_PAGEDOWN: nId = BROWSER_CURSORENDOFFILE; break;
+ case KEY_PAGEUP: nId = BROWSER_CURSORTOPOFFILE; break;
+ case KEY_HOME: nId = BROWSER_CURSORTOPOFSCREEN; break;
+ case KEY_END: nId = BROWSER_CURSORENDOFSCREEN; break;
+ case KEY_SPACE: nId = BROWSER_ENHANCESELECTION; break;
+ case KEY_LEFT: nId = BROWSER_MOVECOLUMNLEFT; break;
+ case KEY_RIGHT: nId = BROWSER_MOVECOLUMNRIGHT; break;
+ }
+
+ if ( nId != BROWSER_NONE )
+ Dispatch( nId );
+ return nId != BROWSER_NONE;
+}
+
+
+void BrowseBox::Dispatch( sal_uInt16 nId )
+{
+
+ long nRowsOnPage = pDataWin->GetSizePixel().Height() / GetDataRowHeight();
+
+ switch ( nId )
+ {
+ case BROWSER_SELECTCOLUMN:
+ if ( ColCount() )
+ SelectColumnId( GetCurColumnId() );
+ break;
+
+ case BROWSER_CURSORDOWN:
+ if ( ( GetCurRow() + 1 ) < nRowCount )
+ GoToRow( GetCurRow() + 1, false );
+ break;
+ case BROWSER_CURSORUP:
+ if ( GetCurRow() > 0 )
+ GoToRow( GetCurRow() - 1, false );
+ break;
+ case BROWSER_SELECTHOME:
+ if ( GetRowCount() )
+ {
+ DoHideCursor( "BROWSER_SELECTHOME" );
+ for ( long nRow = GetCurRow(); nRow >= 0; --nRow )
+ SelectRow( nRow );
+ GoToRow( 0, true );
+ DoShowCursor( "BROWSER_SELECTHOME" );
+ }
+ break;
+ case BROWSER_SELECTEND:
+ if ( GetRowCount() )
+ {
+ DoHideCursor( "BROWSER_SELECTEND" );
+ long nRows = GetRowCount();
+ for ( long nRow = GetCurRow(); nRow < nRows; ++nRow )
+ SelectRow( nRow );
+ GoToRow( GetRowCount() - 1, true );
+ DoShowCursor( "BROWSER_SELECTEND" );
+ }
+ break;
+ case BROWSER_SELECTDOWN:
+ {
+ if ( GetRowCount() && ( GetCurRow() + 1 ) < nRowCount )
+ {
+ // deselect the current row, if it isn't the first
+ // and there is no other selected row above
+ long nRow = GetCurRow();
+ bool bLocalSelect = ( !IsRowSelected( nRow ) ||
+ GetSelectRowCount() == 1 || IsRowSelected( nRow - 1 ) );
+ SelectRow( nRow, bLocalSelect );
+ bool bDone = GoToRow( GetCurRow() + 1, false );
+ if ( bDone )
+ SelectRow( GetCurRow() );
+ }
+ else
+ ScrollRows( 1 );
+ break;
+ }
+ case BROWSER_SELECTUP:
+ if ( GetRowCount() )
+ {
+ // deselect the current row, if it isn't the first
+ // and there is no other selected row under
+ long nRow = GetCurRow();
+ bool bLocalSelect = ( !IsRowSelected( nRow ) ||
+ GetSelectRowCount() == 1 || IsRowSelected( nRow + 1 ) );
+ SelectRow( nCurRow, bLocalSelect );
+ bool bDone = GoToRow( nRow - 1, false );
+ if ( bDone )
+ SelectRow( GetCurRow() );
+ }
+ break;
+ case BROWSER_CURSORPAGEDOWN:
+ ScrollRows( nRowsOnPage );
+ break;
+ case BROWSER_CURSORPAGEUP:
+ ScrollRows( -nRowsOnPage );
+ break;
+ case BROWSER_CURSOREND:
+ if ( bColumnCursor )
+ {
+ sal_uInt16 nNewId = GetColumnId(ColCount() -1);
+ nNewId != HandleColumnId && GoToColumnId( nNewId );
+ break;
+ }
+ [[fallthrough]];
+ case BROWSER_CURSORENDOFFILE:
+ GoToRow( nRowCount - 1, false );
+ break;
+ case BROWSER_CURSORRIGHT:
+ if ( bColumnCursor )
+ {
+ sal_uInt16 nNewPos = GetColumnPos( GetCurColumnId() ) + 1;
+ sal_uInt16 nNewId = GetColumnId( nNewPos );
+ if (nNewId != BROWSER_INVALIDID) // At end of row ?
+ GoToColumnId( nNewId );
+ else
+ {
+ sal_uInt16 nColId = GetColumnId(0);
+ if ( nColId == BROWSER_INVALIDID || nColId == HandleColumnId )
+ nColId = GetColumnId(1);
+ if ( GetRowCount() )
+ {
+ if ( nCurRow < GetRowCount() - 1 )
+ {
+ GoToRowColumnId( nCurRow + 1, nColId );
+ }
+ }
+ else if ( ColCount() )
+ GoToColumnId( nColId );
+ }
+ }
+ else
+ ScrollColumns( 1 );
+ break;
+ case BROWSER_CURSORHOME:
+ if ( bColumnCursor )
+ {
+ sal_uInt16 nNewId = GetColumnId(1);
+ if (nNewId != HandleColumnId)
+ {
+ GoToColumnId( nNewId );
+ }
+ break;
+ }
+ [[fallthrough]];
+ case BROWSER_CURSORTOPOFFILE:
+ GoToRow( 0, false );
+ break;
+ case BROWSER_CURSORLEFT:
+ if ( bColumnCursor )
+ {
+ sal_uInt16 nNewPos = GetColumnPos( GetCurColumnId() ) - 1;
+ sal_uInt16 nNewId = GetColumnId( nNewPos );
+ if (nNewId != HandleColumnId)
+ GoToColumnId( nNewId );
+ else
+ {
+ if ( GetRowCount() )
+ {
+ if (nCurRow > 0)
+ {
+ GoToRowColumnId(nCurRow - 1, GetColumnId(ColCount() -1));
+ }
+ }
+ else if ( ColCount() )
+ GoToColumnId( GetColumnId(ColCount() -1) );
+ }
+ }
+ else
+ ScrollColumns( -1 );
+ break;
+ case BROWSER_ENHANCESELECTION:
+ if ( GetRowCount() )
+ SelectRow( GetCurRow(), !IsRowSelected( GetCurRow() ) );
+ break;
+ case BROWSER_SELECT:
+ if ( GetRowCount() )
+ SelectRow( GetCurRow(), !IsRowSelected( GetCurRow() ), false );
+ break;
+ case BROWSER_MOVECOLUMNLEFT:
+ case BROWSER_MOVECOLUMNRIGHT:
+ { // check if column moving is allowed
+ BrowserHeader* pHeaderBar = pDataWin->pHeaderBar;
+ if ( pHeaderBar && pHeaderBar->IsDragable() )
+ {
+ sal_uInt16 nColId = GetCurColumnId();
+ bool bColumnSelected = IsColumnSelected(nColId);
+ sal_uInt16 nNewPos = GetColumnPos(nColId);
+ bool bMoveAllowed = false;
+ if ( BROWSER_MOVECOLUMNLEFT == nId && nNewPos > 1 )
+ {
+ --nNewPos;
+ bMoveAllowed = true;
+ }
+ else if ( BROWSER_MOVECOLUMNRIGHT == nId && nNewPos < (ColCount()-1) )
+ {
+ ++nNewPos;
+ bMoveAllowed = true;
+ }
+
+ if ( bMoveAllowed )
+ {
+ SetColumnPos( nColId, nNewPos );
+ ColumnMoved( nColId );
+ MakeFieldVisible(GetCurRow(), nColId);
+ if ( bColumnSelected )
+ SelectColumnId(nColId);
+ }
+ }
+ }
+ break;
+ }
+}
+
+
+void BrowseBox::SetCursorColor(const Color& _rCol)
+{
+ if (_rCol == m_aCursorColor)
+ return;
+
+ // ensure the cursor is hidden
+ DoHideCursor("SetCursorColor");
+ if (!m_bFocusOnlyCursor)
+ DoHideCursor("SetCursorColor - force");
+
+ m_aCursorColor = _rCol;
+
+ if (!m_bFocusOnlyCursor)
+ DoShowCursor("SetCursorColor - force");
+ DoShowCursor("SetCursorColor");
+}
+
+tools::Rectangle BrowseBox::calcHeaderRect(bool _bIsColumnBar, bool _bOnScreen)
+{
+ vcl::Window* pParent = nullptr;
+ if ( !_bOnScreen )
+ pParent = GetAccessibleParentWindow();
+
+ Point aTopLeft;
+ long nWidth;
+ long nHeight;
+ if ( _bIsColumnBar )
+ {
+ nWidth = pDataWin->GetOutputSizePixel().Width();
+ nHeight = GetDataRowHeight();
+ }
+ else
+ {
+ aTopLeft.setY( GetDataRowHeight() );
+ nWidth = GetColumnWidth(0);
+ nHeight = GetWindowExtentsRelative( pParent ).GetHeight() - aTopLeft.Y() - GetControlArea().GetSize().Height();
+ }
+ aTopLeft += GetWindowExtentsRelative( pParent ).TopLeft();
+ return tools::Rectangle(aTopLeft,Size(nWidth,nHeight));
+}
+
+tools::Rectangle BrowseBox::calcTableRect(bool _bOnScreen)
+{
+ vcl::Window* pParent = nullptr;
+ if ( !_bOnScreen )
+ pParent = GetAccessibleParentWindow();
+
+ tools::Rectangle aRect( GetWindowExtentsRelative( pParent ) );
+ tools::Rectangle aRowBar = calcHeaderRect(false, pParent == nullptr);
+
+ long nX = aRowBar.Right() - aRect.Left();
+ long nY = aRowBar.Top() - aRect.Top();
+ Size aSize(aRect.GetSize());
+
+ return tools::Rectangle(aRowBar.TopRight(), Size(aSize.Width() - nX, aSize.Height() - nY - GetBarHeight()) );
+}
+
+tools::Rectangle BrowseBox::GetFieldRectPixelAbs( sal_Int32 _nRowId, sal_uInt16 _nColId, bool /*_bIsHeader*/, bool _bOnScreen )
+{
+ vcl::Window* pParent = nullptr;
+ if ( !_bOnScreen )
+ pParent = GetAccessibleParentWindow();
+
+ tools::Rectangle aRect = GetFieldRectPixel(_nRowId,_nColId,_bOnScreen);
+
+ Point aTopLeft = aRect.TopLeft();
+ aTopLeft += GetWindowExtentsRelative( pParent ).TopLeft();
+
+ return tools::Rectangle(aTopLeft,aRect.GetSize());
+}
+
+// ------------------------------------------------------------------------- EOF
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/brwbox3.cxx b/svtools/source/brwbox/brwbox3.cxx
new file mode 100644
index 000000000..0c4f60316
--- /dev/null
+++ b/svtools/source/brwbox/brwbox3.cxx
@@ -0,0 +1,559 @@
+/* -*- 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 .
+ */
+
+#include <svtools/brwbox.hxx>
+#include <vcl/AccessibleBrowseBoxObjType.hxx>
+#include <vcl/accessiblefactory.hxx>
+#include <unotools/accessiblestatesethelper.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+#include <tools/multisel.hxx>
+#include "brwimpl.hxx"
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+
+// Accessibility ==============================================================
+
+using namespace ::com::sun::star::uno;
+using ::com::sun::star::accessibility::XAccessible;
+using namespace ::com::sun::star::accessibility;
+
+
+namespace svt
+{
+ using namespace ::com::sun::star::lang;
+ using namespace utl;
+
+ static Reference< XAccessible > getHeaderCell( BrowseBoxImpl::THeaderCellMap& _raHeaderCells,
+ sal_Int32 _nPos,
+ vcl::AccessibleBrowseBoxObjType _eType,
+ const Reference< XAccessible >& _rParent,
+ BrowseBox& _rBrowseBox,
+ vcl::IAccessibleFactory const & rFactory
+ )
+ {
+ Reference< XAccessible > xRet;
+ BrowseBoxImpl::THeaderCellMap::iterator aFind = _raHeaderCells.find( _nPos );
+ if ( aFind == _raHeaderCells.end() )
+ {
+ Reference< XAccessible > xAccessible = rFactory.createAccessibleBrowseBoxHeaderCell(
+ _nPos,
+ _rParent,
+ _rBrowseBox,
+ nullptr,
+ _eType
+ );
+ aFind = _raHeaderCells.emplace( _nPos, xAccessible ).first;
+ }
+ if ( aFind != _raHeaderCells.end() )
+ xRet = aFind->second;
+ return xRet;
+ }
+
+
+ Reference< XAccessible > BrowseBoxImpl::getAccessibleHeaderBar( vcl::AccessibleBrowseBoxObjType _eObjType )
+ {
+ if ( m_pAccessible && m_pAccessible->isAlive() )
+ return m_pAccessible->getHeaderBar( _eObjType );
+ return nullptr;
+ }
+
+
+ Reference< XAccessible > BrowseBoxImpl::getAccessibleTable( )
+ {
+ if ( m_pAccessible && m_pAccessible->isAlive() )
+ return m_pAccessible->getTable( );
+ return nullptr;
+ }
+}
+
+
+Reference< XAccessible > BrowseBox::CreateAccessible()
+{
+ vcl::Window* pParent = GetAccessibleParentWindow();
+ DBG_ASSERT( pParent, "BrowseBox::CreateAccessible - parent not found" );
+
+ if( pParent && !m_pImpl->m_pAccessible)
+ {
+ Reference< XAccessible > xAccParent = pParent->GetAccessible();
+ if( xAccParent.is() )
+ {
+ m_pImpl->m_pAccessible = getAccessibleFactory().createAccessibleBrowseBox(
+ xAccParent, *this
+ );
+ }
+ }
+
+ Reference< XAccessible > xAccessible;
+ if ( m_pImpl->m_pAccessible )
+ xAccessible = m_pImpl->m_pAccessible->getMyself();
+
+ return xAccessible;
+}
+
+
+// Children -------------------------------------------------------------------
+
+Reference< XAccessible > BrowseBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos )
+{
+ // BBINDEX_TABLE must be the table
+ OSL_ENSURE(m_pImpl->m_pAccessible,"Invalid call: Accessible is null");
+
+ return m_pImpl->m_aFactoryAccess.getFactory().createAccessibleBrowseBoxTableCell(
+ m_pImpl->getAccessibleTable(),
+ *this,
+ nullptr,
+ _nRow,
+ _nColumnPos,
+ OFFSET_DEFAULT
+ );
+}
+
+
+Reference< XAccessible > BrowseBox::CreateAccessibleRowHeader( sal_Int32 _nRow )
+{
+ return svt::getHeaderCell(
+ m_pImpl->m_aRowHeaderCellMap,
+ _nRow,
+ vcl::BBTYPE_ROWHEADERCELL,
+ m_pImpl->getAccessibleHeaderBar(vcl::BBTYPE_ROWHEADERBAR),
+ *this,
+ m_pImpl->m_aFactoryAccess.getFactory()
+ );
+}
+
+
+Reference< XAccessible > BrowseBox::CreateAccessibleColumnHeader( sal_uInt16 _nColumnPos )
+{
+ return svt::getHeaderCell(
+ m_pImpl->m_aColHeaderCellMap,
+ _nColumnPos,
+ vcl::BBTYPE_COLUMNHEADERCELL,
+ m_pImpl->getAccessibleHeaderBar(vcl::BBTYPE_COLUMNHEADERBAR),
+ *this,
+ m_pImpl->m_aFactoryAccess.getFactory()
+ );
+}
+
+
+sal_Int32 BrowseBox::GetAccessibleControlCount() const
+{
+ return 0;
+}
+
+
+Reference< XAccessible > BrowseBox::CreateAccessibleControl( sal_Int32 )
+{
+ SAL_WARN( "svtools", "BrowseBox::CreateAccessibleControl: to be overwritten!" );
+ return nullptr;
+}
+
+
+// Conversions ----------------------------------------------------------------
+
+bool BrowseBox::ConvertPointToCellAddress(
+ sal_Int32& rnRow, sal_uInt16& rnColumnPos, const Point& rPoint )
+{
+ //! TODO has to be checked
+ rnRow = GetRowAtYPosPixel(rPoint.Y());
+ rnColumnPos = GetColumnAtXPosPixel(rPoint.X());
+ return rnRow != BROWSER_INVALIDID && rnColumnPos != BROWSER_INVALIDID;
+}
+
+
+bool BrowseBox::ConvertPointToRowHeader( sal_Int32& rnRow, const Point& rPoint )
+{
+ rnRow = GetRowAtYPosPixel(rPoint.Y());
+ // sal_uInt16 nColumnId = GetColumnAtXPosPixel(rPoint.X());
+ return rnRow != BROWSER_INVALIDID;// && nColumnId == 0;
+}
+
+
+bool BrowseBox::ConvertPointToColumnHeader( sal_uInt16& _rnColumnPos, const Point& _rPoint )
+{
+ _rnColumnPos = GetColumnAtXPosPixel(_rPoint.X());
+ return _rnColumnPos != BROWSER_INVALIDID;
+}
+
+
+bool BrowseBox::ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint )
+{
+ //! TODO has to be checked
+ sal_Int32 nRow = 0;
+ sal_uInt16 nColumn = 0;
+ bool bRet = ConvertPointToCellAddress(nRow,nColumn,_rPoint);
+ if ( bRet )
+ _rnIndex = nRow * ColCount() + nColumn;
+
+ return bRet;
+}
+
+
+// Object data and state ------------------------------------------------------
+
+OUString BrowseBox::GetAccessibleObjectName( ::vcl::AccessibleBrowseBoxObjType eObjType,sal_Int32 _nPosition) const
+{
+ OUString aRetText;
+ switch( eObjType )
+ {
+ case ::vcl::BBTYPE_BROWSEBOX:
+ aRetText = "BrowseBox";
+ break;
+ case ::vcl::BBTYPE_TABLE:
+ aRetText = "Table";
+ break;
+ case ::vcl::BBTYPE_ROWHEADERBAR:
+ aRetText = "RowHeaderBar";
+ break;
+ case ::vcl::BBTYPE_COLUMNHEADERBAR:
+ aRetText = "ColumnHeaderBar";
+ break;
+ case ::vcl::BBTYPE_TABLECELL:
+ if( ColCount() !=0 && GetRowCount()!=0)
+ {
+
+ sal_Int32 columnId = _nPosition % ColCount() +1;
+ aRetText = GetColumnDescription( sal_Int16( columnId ) );
+ sal_Int32 rowId = _nPosition / GetRowCount() + 1;
+ aRetText += OUString::number(rowId);
+ }
+ else
+ aRetText = "TableCell";
+#if OSL_DEBUG_LEVEL > 0
+ aRetText += " ["
+ + OUString::number(sal_Int32(GetCurRow()))
+ + ","
+ + OUString::number(sal_Int32(GetCurColumnId()))
+ + "]";
+#endif
+ break;
+ case ::vcl::BBTYPE_ROWHEADERCELL:
+ {
+ sal_Int32 rowId = _nPosition + 1;
+ aRetText = OUString::number( rowId );
+ }
+#if OSL_DEBUG_LEVEL > 0
+ aRetText += " ["
+ + OUString::number(sal_Int32(GetCurRow()))
+ + ","
+ + OUString::number(sal_Int32(GetCurColumnId()))
+ + "]";
+#endif
+ break;
+ case ::vcl::BBTYPE_COLUMNHEADERCELL:
+ aRetText = GetColumnDescription( sal_Int16( _nPosition ) );
+#if OSL_DEBUG_LEVEL > 0
+ aRetText += " ["
+ + OUString::number(sal_Int32(GetCurRow()))
+ + ","
+ + OUString::number(sal_Int32(GetCurColumnId()))
+ + "]";
+#endif
+ break;
+ default:
+ OSL_FAIL("BrowseBox::GetAccessibleName: invalid enum!");
+ }
+ return aRetText;
+}
+
+
+OUString BrowseBox::GetAccessibleObjectDescription( ::vcl::AccessibleBrowseBoxObjType eObjType,sal_Int32 ) const
+{
+ OUString aRetText;
+ switch( eObjType )
+ {
+ case ::vcl::BBTYPE_BROWSEBOX:
+ aRetText = "BrowseBox description";
+ break;
+ case ::vcl::BBTYPE_TABLE:
+ // aRetText = "TABLE description";
+ break;
+ case ::vcl::BBTYPE_ROWHEADERBAR:
+ // aRetText = "ROWHEADERBAR description";
+ break;
+ case ::vcl::BBTYPE_COLUMNHEADERBAR:
+ // aRetText = "COLUMNHEADERBAR description";
+ break;
+ case ::vcl::BBTYPE_TABLECELL:
+ // aRetText = "TABLECELL description";
+ break;
+ case ::vcl::BBTYPE_ROWHEADERCELL:
+ // aRetText = "ROWHEADERCELL description";
+ break;
+ case ::vcl::BBTYPE_COLUMNHEADERCELL:
+ // aRetText = "COLUMNHEADERCELL description";
+ break;
+ case ::vcl::BBTYPE_CHECKBOXCELL:
+ break;
+ }
+ return aRetText;
+}
+
+
+OUString BrowseBox::GetRowDescription( sal_Int32 ) const
+{
+ return OUString();
+}
+
+
+OUString BrowseBox::GetColumnDescription( sal_uInt16 _nColumn ) const
+{
+ return GetColumnTitle( GetColumnId( _nColumn ) );
+}
+
+
+void BrowseBox::FillAccessibleStateSet(
+ ::utl::AccessibleStateSetHelper& rStateSet,
+ ::vcl::AccessibleBrowseBoxObjType eObjType ) const
+{
+ switch( eObjType )
+ {
+ case ::vcl::BBTYPE_BROWSEBOX:
+ case ::vcl::BBTYPE_TABLE:
+
+ rStateSet.AddState( AccessibleStateType::FOCUSABLE );
+ if ( HasFocus() )
+ rStateSet.AddState( AccessibleStateType::FOCUSED );
+ if ( IsActive() )
+ rStateSet.AddState( AccessibleStateType::ACTIVE );
+ if ( GetUpdateMode() )
+ rStateSet.AddState( AccessibleStateType::EDITABLE );
+ if ( IsEnabled() )
+ {
+ rStateSet.AddState( AccessibleStateType::ENABLED );
+ rStateSet.AddState( AccessibleStateType::SENSITIVE );
+ }
+ if ( IsReallyVisible() )
+ rStateSet.AddState( AccessibleStateType::VISIBLE );
+ if ( eObjType == ::vcl::BBTYPE_TABLE )
+ rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
+
+ break;
+ case ::vcl::BBTYPE_ROWHEADERBAR:
+ rStateSet.AddState( AccessibleStateType::FOCUSABLE );
+ rStateSet.AddState( AccessibleStateType::VISIBLE );
+ if ( GetSelectRowCount() )
+ rStateSet.AddState( AccessibleStateType::FOCUSED );
+ rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
+ break;
+ case ::vcl::BBTYPE_COLUMNHEADERBAR:
+ rStateSet.AddState( AccessibleStateType::FOCUSABLE );
+ rStateSet.AddState( AccessibleStateType::VISIBLE );
+ if ( GetSelectColumnCount() )
+ rStateSet.AddState( AccessibleStateType::FOCUSED );
+ rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
+ break;
+ case ::vcl::BBTYPE_TABLECELL:
+ {
+ sal_Int32 nRow = GetCurRow();
+ sal_uInt16 nColumn = GetCurColumnId();
+ if ( IsFieldVisible(nRow,nColumn) )
+ rStateSet.AddState( AccessibleStateType::VISIBLE );
+ if ( !IsFrozen( nColumn ) )
+ rStateSet.AddState( AccessibleStateType::FOCUSABLE );
+ rStateSet.AddState( AccessibleStateType::TRANSIENT );
+ }
+ break;
+ case ::vcl::BBTYPE_ROWHEADERCELL:
+ case ::vcl::BBTYPE_COLUMNHEADERCELL:
+ case ::vcl::BBTYPE_CHECKBOXCELL:
+ OSL_FAIL("Illegal call here!");
+ break;
+ }
+}
+
+void BrowseBox::FillAccessibleStateSetForCell( ::utl::AccessibleStateSetHelper& _rStateSet,
+ sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const
+{
+ //! TODO check if the state is valid for table cells
+ if ( IsCellVisible( _nRow, _nColumnPos ) )
+ _rStateSet.AddState( AccessibleStateType::VISIBLE );
+ if ( GetCurrRow() == _nRow && GetCurrColumn() == _nColumnPos )
+ _rStateSet.AddState( AccessibleStateType::FOCUSED );
+ else // only transient when column is not focused
+ _rStateSet.AddState( AccessibleStateType::TRANSIENT );
+}
+
+
+void BrowseBox::GrabTableFocus()
+{
+ GrabFocus();
+}
+
+OUString BrowseBox::GetCellText(long, sal_uInt16 ) const
+{
+ SAL_WARN("svtools", "This method has to be implemented by the derived classes! BUG!!");
+ return OUString();
+}
+
+
+void BrowseBox::commitHeaderBarEvent(sal_Int16 nEventId,
+ const Any& rNewValue, const Any& rOldValue, bool _bColumnHeaderBar )
+{
+ if ( isAccessibleAlive() )
+ m_pImpl->m_pAccessible->commitHeaderBarEvent( nEventId,
+ rNewValue, rOldValue, _bColumnHeaderBar );
+}
+
+void BrowseBox::commitTableEvent( sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
+{
+ if ( isAccessibleAlive() )
+ m_pImpl->m_pAccessible->commitTableEvent( _nEventId, _rNewValue, _rOldValue );
+}
+
+void BrowseBox::commitBrowseBoxEvent( sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
+{
+ if ( isAccessibleAlive() )
+ m_pImpl->m_pAccessible->commitEvent( _nEventId, _rNewValue, _rOldValue);
+}
+
+::vcl::IAccessibleFactory& BrowseBox::getAccessibleFactory()
+{
+ return m_pImpl->m_aFactoryAccess.getFactory();
+}
+
+bool BrowseBox::isAccessibleAlive( ) const
+{
+ return ( nullptr != m_pImpl->m_pAccessible ) && m_pImpl->m_pAccessible->isAlive();
+}
+
+// IAccessibleTableProvider
+
+sal_Int32 BrowseBox::GetCurrRow() const
+{
+ return GetCurRow();
+}
+
+sal_uInt16 BrowseBox::GetCurrColumn() const
+{
+ return GetColumnPos( GetCurColumnId() );
+}
+
+bool BrowseBox::HasRowHeader() const
+{
+ return ( GetColumnId( 0 ) == HandleColumnId ); // HandleColumn == RowHeader
+}
+
+bool BrowseBox::GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn )
+{
+ return GoToRowColumnId( _nRow, GetColumnId( _nColumn ) );
+}
+
+void BrowseBox::SelectColumn( sal_uInt16 _nColumn, bool _bSelect )
+{
+ SelectColumnPos( _nColumn, _bSelect );
+}
+
+bool BrowseBox::IsColumnSelected( long _nColumn ) const
+{
+ return ( pColSel && (0 <= _nColumn) && (_nColumn <= 0xFFF) ) &&
+ pColSel->IsSelected( static_cast< sal_uInt16 >( _nColumn ) );
+}
+
+sal_Int32 BrowseBox::GetSelectedRowCount() const
+{
+ return GetSelectRowCount();
+}
+
+sal_Int32 BrowseBox::GetSelectedColumnCount() const
+{
+ const MultiSelection* pColumnSel = GetColumnSelection();
+ return pColumnSel ? pColumnSel->GetSelectCount() : 0;
+}
+
+void BrowseBox::GetAllSelectedRows( css::uno::Sequence< sal_Int32 >& _rRows ) const
+{
+ sal_Int32 nCount = GetSelectRowCount();
+ if( nCount )
+ {
+ _rRows.realloc( nCount );
+ _rRows[ 0 ] = const_cast< BrowseBox* >( this )->FirstSelectedRow();
+ for( sal_Int32 nIndex = 1; nIndex < nCount; ++nIndex )
+ _rRows[ nIndex ] = const_cast< BrowseBox* >( this )->NextSelectedRow();
+ DBG_ASSERT( const_cast< BrowseBox* >( this )->NextSelectedRow() == BROWSER_ENDOFSELECTION,
+ "BrowseBox::GetAllSelectedRows - too many selected rows found" );
+ }
+}
+
+void BrowseBox::GetAllSelectedColumns( css::uno::Sequence< sal_Int32 >& _rColumns ) const
+{
+ const MultiSelection* pColumnSel = GetColumnSelection();
+ sal_Int32 nCount = GetSelectedColumnCount();
+ if( !(pColumnSel && nCount) )
+ return;
+
+ _rColumns.realloc( nCount );
+
+ sal_Int32 nIndex = 0;
+ const size_t nRangeCount = pColumnSel->GetRangeCount();
+ for( size_t nRange = 0; nRange < nRangeCount; ++nRange )
+ {
+ const Range& rRange = pColumnSel->GetRange( nRange );
+ // loop has to include aRange.Max()
+ for( sal_Int32 nCol = rRange.Min(); nCol <= static_cast<sal_Int32>(rRange.Max()); ++nCol )
+ {
+ DBG_ASSERT( nIndex < nCount,
+ "GetAllSelectedColumns - range overflow" );
+ _rColumns[ nIndex ] = nCol;
+ ++nIndex;
+ }
+ }
+}
+
+bool BrowseBox::IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const
+{
+ return IsFieldVisible( _nRow, GetColumnId( _nColumnPos ) );
+}
+
+OUString BrowseBox::GetAccessibleCellText(long _nRow, sal_uInt16 _nColPos) const
+{
+ return GetCellText( _nRow, GetColumnId( _nColPos ) );
+}
+
+
+bool BrowseBox::GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, int nLen, MetricVector& rVector )
+{
+ return Control::GetGlyphBoundRects( rOrigin, rStr, nIndex, nLen, rVector );
+}
+
+tools::Rectangle BrowseBox::GetWindowExtentsRelative( vcl::Window *pRelativeWindow ) const
+{
+ return Control::GetWindowExtentsRelative( pRelativeWindow );
+}
+
+void BrowseBox::GrabFocus()
+{
+ Control::GrabFocus();
+}
+
+Reference< XAccessible > BrowseBox::GetAccessible()
+{
+ return Control::GetAccessible();
+}
+
+vcl::Window* BrowseBox::GetAccessibleParentWindow() const
+{
+ return Control::GetAccessibleParentWindow();
+}
+
+vcl::Window* BrowseBox::GetWindowInstance()
+{
+ return this;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/brwhead.cxx b/svtools/source/brwbox/brwhead.cxx
new file mode 100644
index 000000000..fa42bfe29
--- /dev/null
+++ b/svtools/source/brwbox/brwhead.cxx
@@ -0,0 +1,107 @@
+/* -*- 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 .
+ */
+
+
+#include <svtools/brwhead.hxx>
+#include <svtools/brwbox.hxx>
+#include <vcl/commandevent.hxx>
+
+
+BrowserHeader::BrowserHeader( BrowseBox* pParent, WinBits nWinBits )
+ :HeaderBar( pParent, nWinBits )
+ ,_pBrowseBox( pParent )
+{
+ long nHeight = pParent->IsZoom() ? pParent->CalcZoom(pParent->GetTitleHeight()) : pParent->GetTitleHeight();
+
+ SetPosSizePixel( Point( 0, 0),
+ Size( pParent->GetOutputSizePixel().Width(),
+ nHeight ) );
+ Show();
+}
+
+
+BrowserHeader::~BrowserHeader()
+{
+ disposeOnce();
+}
+
+void BrowserHeader::dispose()
+{
+ _pBrowseBox.clear();
+ HeaderBar::dispose();
+}
+
+
+void BrowserHeader::Command( const CommandEvent& rCEvt )
+{
+ if ( !GetCurItemId() && CommandEventId::ContextMenu == rCEvt.GetCommand() )
+ {
+ Point aPos( rCEvt.GetMousePosPixel() );
+ if ( _pBrowseBox->IsFrozen(0) )
+ aPos.AdjustX(_pBrowseBox->GetColumnWidth(0) );
+ _pBrowseBox->GetDataWindow().Command( CommandEvent(
+ Point( aPos.X(), aPos.Y() - GetSizePixel().Height() ),
+ CommandEventId::ContextMenu, rCEvt.IsMouseEvent() ) );
+ }
+}
+
+
+void BrowserHeader::EndDrag()
+{
+ // call before other actions, it looks more nice in most cases
+ HeaderBar::EndDrag();
+ PaintImmediately();
+
+ // not aborted?
+ sal_uInt16 nId = GetCurItemId();
+ if ( !nId )
+ return;
+
+ // handle column?
+ if ( nId == USHRT_MAX-1 )
+ nId = 0;
+
+ if ( !IsItemMode() )
+ {
+ // column resize
+ _pBrowseBox->SetColumnWidth( nId, GetItemSize( nId ) );
+ _pBrowseBox->ColumnResized( nId );
+ SetItemSize( nId, _pBrowseBox->GetColumnWidth( nId ) );
+ }
+ else
+ {
+ // column drag
+ // did the position actually change?
+ // take the handle column into account
+ sal_uInt16 nOldPos = _pBrowseBox->GetColumnPos(nId),
+ nNewPos = GetItemPos( nId );
+
+ if (_pBrowseBox->GetColumnId(0) == BrowseBox::HandleColumnId)
+ nNewPos++;
+
+ if (nOldPos != nNewPos)
+ {
+ _pBrowseBox->SetColumnPos( nId, nNewPos );
+ _pBrowseBox->ColumnMoved( nId );
+ }
+ }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/brwimpl.hxx b/svtools/source/brwbox/brwimpl.hxx
new file mode 100644
index 000000000..95623570c
--- /dev/null
+++ b/svtools/source/brwbox/brwimpl.hxx
@@ -0,0 +1,80 @@
+/* -*- 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 <vcl/accessibletableprovider.hxx>
+#include <vcl/svtaccessiblefactory.hxx>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/accessibility/XAccessible.hpp>
+#include <osl/diagnose.h>
+#include <tools/diagnose_ex.h>
+
+#include <map>
+
+namespace svt
+{
+ class BrowseBoxImpl
+ {
+ // member
+ public:
+ typedef ::std::map< sal_Int32, css::uno::Reference< css::accessibility::XAccessible > > THeaderCellMap;
+
+ struct THeaderCellMapFunctorDispose
+ {
+ void operator()(const THeaderCellMap::value_type& _aType)
+ {
+ css::uno::Reference< css::lang::XComponent > xComp( _aType.second, css::uno::UNO_QUERY );
+ OSL_ENSURE( xComp.is() || !_aType.second.is(), "THeaderCellMapFunctorDispose: invalid accessible cell (no XComponent)!" );
+ if ( xComp.is() )
+ try
+ {
+ xComp->dispose();
+ }
+ catch( const css::uno::Exception& )
+ {
+ TOOLS_WARN_EXCEPTION( "svtools", "THeaderCellMapFunctorDispose" );
+ }
+ }
+ };
+
+ public:
+ vcl::AccessibleFactoryAccess m_aFactoryAccess;
+ vcl::IAccessibleBrowseBox* m_pAccessible;
+ THeaderCellMap m_aColHeaderCellMap;
+ THeaderCellMap m_aRowHeaderCellMap;
+
+ public:
+ BrowseBoxImpl() : m_pAccessible(nullptr)
+ {
+ }
+
+
+ /// @see AccessibleBrowseBox::getHeaderBar
+ css::uno::Reference< css::accessibility::XAccessible >
+ getAccessibleHeaderBar( vcl::AccessibleBrowseBoxObjType _eObjType );
+
+ /// @see AccessibleBrowseBox::getTable
+ css::uno::Reference< css::accessibility::XAccessible >
+ getAccessibleTable( );
+
+ };
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/datwin.cxx b/svtools/source/brwbox/datwin.cxx
new file mode 100644
index 000000000..f22ddb19e
--- /dev/null
+++ b/svtools/source/brwbox/datwin.cxx
@@ -0,0 +1,691 @@
+/* -*- 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 .
+ */
+
+
+#include "datwin.hxx"
+#include <o3tl/numeric.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/help.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/scrbar.hxx>
+#include <vcl/ptrstyle.hxx>
+#include <tools/debug.hxx>
+#include <tools/fract.hxx>
+
+
+void ButtonFrame::Draw( OutputDevice& rDev )
+{
+ Color aOldFillColor = rDev.GetFillColor();
+ Color aOldLineColor = rDev.GetLineColor();
+
+ const StyleSettings &rSettings = rDev.GetSettings().GetStyleSettings();
+ Color aColLight( rSettings.GetLightColor() );
+ Color aColShadow( rSettings.GetShadowColor() );
+ Color aColFace( rSettings.GetFaceColor() );
+
+ rDev.SetLineColor( aColFace );
+ rDev.SetFillColor( aColFace );
+ rDev.DrawRect( aRect );
+
+ if( rDev.GetOutDevType() != OUTDEV_WINDOW )
+ {
+ rDev.SetLineColor( aColLight );
+ rDev.DrawLine( aRect.TopLeft(), Point( aRect.Right(), aRect.Top() ) );
+ rDev.DrawLine( aRect.TopLeft(), Point( aRect.Left(), aRect.Bottom() - 1 ) );
+ rDev.SetLineColor( aColShadow );
+ rDev.DrawLine( aRect.BottomRight(), Point( aRect.Right(), aRect.Top() ) );
+ rDev.DrawLine( aRect.BottomRight(), Point( aRect.Left(), aRect.Bottom() ) );
+ }
+
+ if ( !aText.isEmpty() )
+ {
+ OUString aVal = rDev.GetEllipsisString(aText,aInnerRect.GetWidth() - 2*MIN_COLUMNWIDTH);
+
+ vcl::Font aFont( rDev.GetFont() );
+ bool bOldTransp = aFont.IsTransparent();
+ if ( !bOldTransp )
+ {
+ aFont.SetTransparent( true );
+ rDev.SetFont( aFont );
+ }
+
+ Color aOldColor = rDev.GetTextColor();
+ if (m_bDrawDisabled)
+ rDev.SetTextColor(rSettings.GetDisableColor());
+
+ rDev.DrawText( Point(
+ ( aInnerRect.Left() + aInnerRect.Right() ) / 2 - ( rDev.GetTextWidth(aVal) / 2 ),
+ aInnerRect.Top() ), aVal );
+
+ // restore settings
+ if ( !bOldTransp )
+ {
+ aFont.SetTransparent(false);
+ rDev.SetFont( aFont );
+ }
+ if (m_bDrawDisabled)
+ rDev.SetTextColor(aOldColor);
+ }
+
+ rDev.SetLineColor( aOldLineColor );
+ rDev.SetFillColor( aOldFillColor );
+}
+
+BrowserColumn::BrowserColumn( sal_uInt16 nItemId,
+ const OUString& rTitle, sal_uLong nWidthPixel, const Fraction& rCurrentZoom )
+: _nId( nItemId ),
+ _nWidth( nWidthPixel ),
+ _aTitle( rTitle ),
+ _bFrozen( false )
+{
+ double n = static_cast<double>(_nWidth);
+ n *= static_cast<double>(rCurrentZoom.GetDenominator());
+ if (!rCurrentZoom.GetNumerator())
+ throw o3tl::divide_by_zero();
+ n /= static_cast<double>(rCurrentZoom.GetNumerator());
+ _nOriginalWidth = n>0 ? static_cast<long>(n+0.5) : -static_cast<long>(-n+0.5);
+}
+
+BrowserColumn::~BrowserColumn()
+{
+}
+
+void BrowserColumn::SetWidth(sal_uLong nNewWidthPixel, const Fraction& rCurrentZoom)
+{
+ _nWidth = nNewWidthPixel;
+ // Avoid overflow when called with LONG_MAX from
+ // BrowseBox::AutoSizeLastColumn:
+ if (_nWidth == LONG_MAX)
+ {
+ _nOriginalWidth = _nWidth;
+ }
+ else
+ {
+ double n = static_cast<double>(_nWidth);
+ n *= static_cast<double>(rCurrentZoom.GetDenominator());
+ if (!rCurrentZoom.GetNumerator())
+ throw o3tl::divide_by_zero();
+ n /= static_cast<double>(rCurrentZoom.GetNumerator());
+ _nOriginalWidth = n>0 ? static_cast<long>(n+0.5) : -static_cast<long>(-n+0.5);
+ }
+}
+
+void BrowserColumn::Draw( BrowseBox const & rBox, OutputDevice& rDev, const Point& rPos )
+{
+ if ( _nId == 0 )
+ {
+ // paint handle column
+ ButtonFrame( rPos, Size( Width()-1, rBox.GetDataRowHeight()-1 ),
+ "", false ).Draw( rDev );
+ Color aOldLineColor = rDev.GetLineColor();
+ rDev.SetLineColor( COL_BLACK );
+ rDev.DrawLine(
+ Point( rPos.X(), rPos.Y()+rBox.GetDataRowHeight()-1 ),
+ Point( rPos.X() + Width() - 1, rPos.Y()+rBox.GetDataRowHeight()-1 ) );
+ rDev.DrawLine(
+ Point( rPos.X() + Width() - 1, rPos.Y() ),
+ Point( rPos.X() + Width() - 1, rPos.Y()+rBox.GetDataRowHeight()-1 ) );
+ rDev.SetLineColor( aOldLineColor );
+
+ rBox.DoPaintField( rDev,
+ tools::Rectangle(
+ Point( rPos.X() + 2, rPos.Y() + 2 ),
+ Size( Width()-1, rBox.GetDataRowHeight()-1 ) ),
+ GetId(),
+ BrowseBox::BrowserColumnAccess() );
+ }
+ else
+ {
+ // paint data column
+ long nWidth = Width() == LONG_MAX ? rBox.GetDataWindow().GetSizePixel().Width() : Width();
+
+ rBox.DoPaintField( rDev,
+ tools::Rectangle(
+ Point( rPos.X() + MIN_COLUMNWIDTH, rPos.Y() ),
+ Size( nWidth-2*MIN_COLUMNWIDTH, rBox.GetDataRowHeight()-1 ) ),
+ GetId(),
+ BrowseBox::BrowserColumnAccess() );
+ }
+}
+
+
+void BrowserColumn::ZoomChanged(const Fraction& rNewZoom)
+{
+ double n(_nOriginalWidth * rNewZoom);
+ _nWidth = n>0 ? static_cast<long>(n+0.5) : -static_cast<long>(-n+0.5);
+}
+
+
+BrowserDataWin::BrowserDataWin( BrowseBox* pParent )
+ :Control( pParent, WB_CLIPCHILDREN )
+ ,DragSourceHelper( this )
+ ,DropTargetHelper( this )
+ ,pHeaderBar( nullptr )
+ ,pCornerWin( nullptr )
+ ,bInDtor( false )
+ ,bInPaint( false )
+ ,bInCommand( false )
+ ,bNoHScroll( false )
+ ,bNoVScroll( false )
+ ,bAutoHScroll(false)
+ ,bAutoVScroll(false)
+ ,bUpdateMode( true )
+ ,bAutoSizeLastCol(false)
+ ,bResizeOnPaint( false )
+ ,bUpdateOnUnlock( false )
+ ,bInUpdateScrollbars( false )
+ ,bHadRecursion( false )
+ ,bCallingDropCallback( false )
+ ,nUpdateLock( 0 )
+ ,nCursorHidden( 0 )
+ ,m_nDragRowDividerLimit( 0 )
+ ,m_nDragRowDividerOffset( 0 )
+{
+ aMouseTimer.SetInvokeHandler( LINK( this, BrowserDataWin, RepeatedMouseMove ) );
+ aMouseTimer.SetTimeout( 100 );
+}
+
+
+BrowserDataWin::~BrowserDataWin()
+{
+ disposeOnce();
+}
+
+void BrowserDataWin::dispose()
+{
+ bInDtor = true;
+
+ aInvalidRegion.clear();
+ pHeaderBar.clear();
+ pCornerWin.clear();
+ DragSourceHelper::dispose();
+ DropTargetHelper::dispose();
+ Control::dispose();
+}
+
+
+void BrowserDataWin::LeaveUpdateLock()
+{
+ if ( !--nUpdateLock )
+ {
+ DoOutstandingInvalidations();
+ if (bUpdateOnUnlock )
+ {
+ Control::PaintImmediately();
+ bUpdateOnUnlock = false;
+ }
+ }
+}
+
+void InitSettings_Impl(vcl::Window* pWin)
+{
+ const StyleSettings& rStyleSettings = pWin->GetSettings().GetStyleSettings();
+
+ pWin->ApplyControlFont(*pWin, rStyleSettings.GetFieldFont());
+ pWin->ApplyControlForeground(*pWin, rStyleSettings.GetWindowTextColor());
+ pWin->ApplyControlBackground(*pWin, rStyleSettings.GetWindowColor());
+}
+
+
+void BrowserDataWin::Update()
+{
+ if ( !nUpdateLock )
+ Control::PaintImmediately();
+ else
+ bUpdateOnUnlock = true;
+}
+
+
+void BrowserDataWin::DataChanged( const DataChangedEvent& rDCEvt )
+{
+ if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
+ (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
+ {
+ InitSettings_Impl(this);
+ Invalidate();
+ InitSettings_Impl(GetParent());
+ GetParent()->Invalidate();
+ GetParent()->Resize();
+ }
+ else
+ Control::DataChanged( rDCEvt );
+}
+
+
+void BrowserDataWin::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
+{
+ if (!nUpdateLock && GetUpdateMode())
+ {
+ if (bInPaint)
+ {
+ aInvalidRegion.emplace_back(rRect);
+ return;
+ }
+ bInPaint = true;
+ GetParent()->PaintData(*this, rRenderContext, rRect);
+ bInPaint = false;
+ DoOutstandingInvalidations();
+ }
+ else
+ {
+ aInvalidRegion.emplace_back(rRect);
+ }
+}
+
+
+BrowseEvent BrowserDataWin::CreateBrowseEvent( const Point& rPosPixel )
+{
+ BrowseBox *pBox = GetParent();
+
+ // seek to row under mouse
+ long nRelRow = rPosPixel.Y() < 0
+ ? -1
+ : rPosPixel.Y() / pBox->GetDataRowHeight();
+ long nRow = nRelRow < 0 ? -1 : nRelRow + pBox->nTopRow;
+
+ // find column under mouse
+ long nMouseX = rPosPixel.X();
+ long nColX = 0;
+ size_t nCol;
+ for ( nCol = 0;
+ nCol < pBox->mvCols.size() && nColX < GetSizePixel().Width();
+ ++nCol )
+ if ( pBox->mvCols[ nCol ]->IsFrozen() || nCol >= pBox->nFirstCol )
+ {
+ nColX += pBox->mvCols[ nCol ]->Width();
+ if ( nMouseX < nColX )
+ break;
+ }
+ sal_uInt16 nColId = BROWSER_INVALIDID;
+ if ( nCol < pBox->mvCols.size() )
+ nColId = pBox->mvCols[ nCol ]->GetId();
+
+ // compute the field rectangle and field relative MouseEvent
+ tools::Rectangle aFieldRect;
+ if ( nCol < pBox->mvCols.size() )
+ {
+ nColX -= pBox->mvCols[ nCol ]->Width();
+ aFieldRect = tools::Rectangle(
+ Point( nColX, nRelRow * pBox->GetDataRowHeight() ),
+ Size( pBox->mvCols[ nCol ]->Width(),
+ pBox->GetDataRowHeight() ) );
+ }
+
+ // assemble and return the BrowseEvent
+ return BrowseEvent( this, nRow, nCol, nColId, aFieldRect );
+}
+
+
+sal_Int8 BrowserDataWin::AcceptDrop( const AcceptDropEvent& _rEvt )
+{
+ bCallingDropCallback = true;
+ sal_Int8 nReturn = GetParent()->AcceptDrop( BrowserAcceptDropEvent( this, _rEvt ) );
+ bCallingDropCallback = false;
+ return nReturn;
+}
+
+
+sal_Int8 BrowserDataWin::ExecuteDrop( const ExecuteDropEvent& _rEvt )
+{
+ bCallingDropCallback = true;
+ sal_Int8 nReturn = GetParent()->ExecuteDrop( BrowserExecuteDropEvent( this, _rEvt ) );
+ bCallingDropCallback = false;
+ return nReturn;
+}
+
+
+void BrowserDataWin::StartDrag( sal_Int8 _nAction, const Point& _rPosPixel )
+{
+ if ( !GetParent()->bRowDividerDrag )
+ {
+ Point aEventPos( _rPosPixel );
+ aEventPos.AdjustY(GetParent()->GetTitleHeight() );
+ GetParent()->StartDrag( _nAction, aEventPos );
+ }
+}
+
+
+void BrowserDataWin::Command( const CommandEvent& rEvt )
+{
+ // scroll mouse event?
+ BrowseBox *pBox = GetParent();
+ if ( ( (rEvt.GetCommand() == CommandEventId::Wheel) ||
+ (rEvt.GetCommand() == CommandEventId::StartAutoScroll) ||
+ (rEvt.GetCommand() == CommandEventId::AutoScroll) ) &&
+ ( HandleScrollCommand( rEvt, pBox->aHScroll.get(), pBox->pVScroll ) ) )
+ return;
+
+ Point aEventPos( rEvt.GetMousePosPixel() );
+ long nRow = pBox->GetRowAtYPosPixel( aEventPos.Y(), false);
+ MouseEvent aMouseEvt( aEventPos, 1, MouseEventModifiers::SELECT, MOUSE_LEFT );
+ if ( CommandEventId::ContextMenu == rEvt.GetCommand() && rEvt.IsMouseEvent() &&
+ nRow < pBox->GetRowCount() && !pBox->IsRowSelected(nRow) )
+ {
+ bInCommand = true;
+ MouseButtonDown( aMouseEvt );
+ if( bInDtor )
+ return;
+ MouseButtonUp( aMouseEvt );
+ if( bInDtor )
+ return;
+ bInCommand = false;
+ }
+
+ aEventPos.AdjustY(GetParent()->GetTitleHeight() );
+ CommandEvent aEvt( aEventPos, rEvt.GetCommand(),
+ rEvt.IsMouseEvent(), rEvt.GetEventData() );
+ bInCommand = true;
+ GetParent()->Command( aEvt );
+ if( bInDtor )
+ return;
+ bInCommand = false;
+
+ if ( CommandEventId::StartDrag == rEvt.GetCommand() )
+ MouseButtonUp( aMouseEvt );
+
+ Control::Command( rEvt );
+}
+
+
+bool BrowserDataWin::ImplRowDividerHitTest( const BrowserMouseEvent& _rEvent )
+{
+ if ( ! ( GetParent()->IsInteractiveRowHeightEnabled()
+ && ( _rEvent.GetRow() >= 0 )
+ && ( _rEvent.GetRow() < GetParent()->GetRowCount() )
+ && ( _rEvent.GetColumnId() == BrowseBox::HandleColumnId )
+ )
+ )
+ return false;
+
+ long nDividerDistance = GetParent()->GetDataRowHeight() - ( _rEvent.GetPosPixel().Y() % GetParent()->GetDataRowHeight() );
+ return ( nDividerDistance <= 4 );
+}
+
+
+void BrowserDataWin::MouseButtonDown( const MouseEvent& rEvt )
+{
+ aLastMousePos = OutputToScreenPixel( rEvt.GetPosPixel() );
+
+ BrowserMouseEvent aBrowserEvent( this, rEvt );
+ if ( ( aBrowserEvent.GetClicks() == 1 ) && ImplRowDividerHitTest( aBrowserEvent ) )
+ {
+ StartRowDividerDrag( aBrowserEvent.GetPosPixel() );
+ return;
+ }
+
+ GetParent()->MouseButtonDown( BrowserMouseEvent( this, rEvt ) );
+}
+
+
+void BrowserDataWin::MouseMove( const MouseEvent& rEvt )
+{
+ // avoid pseudo MouseMoves
+ Point aNewPos = OutputToScreenPixel( rEvt.GetPosPixel() );
+ if ( aNewPos == aLastMousePos )
+ return;
+ aLastMousePos = aNewPos;
+
+ // transform to a BrowseEvent
+ BrowserMouseEvent aBrowserEvent( this, rEvt );
+ GetParent()->MouseMove( aBrowserEvent );
+
+ // pointer shape
+ PointerStyle ePointerStyle = PointerStyle::Arrow;
+ if ( ImplRowDividerHitTest( aBrowserEvent ) )
+ ePointerStyle = PointerStyle::VSizeBar;
+ SetPointer( ePointerStyle );
+
+ // dragging out of the visible area?
+ if ( rEvt.IsLeft() &&
+ ( rEvt.GetPosPixel().Y() > GetSizePixel().Height() ||
+ rEvt.GetPosPixel().Y() < 0 ) )
+ {
+ // repeat the event
+ aRepeatEvt = rEvt;
+ aMouseTimer.Start();
+ }
+ else
+ // killing old repeat-event
+ if ( aMouseTimer.IsActive() )
+ aMouseTimer.Stop();
+}
+
+
+IMPL_LINK_NOARG(BrowserDataWin, RepeatedMouseMove, Timer *, void)
+{
+ GetParent()->MouseMove( BrowserMouseEvent( this, aRepeatEvt ) );
+}
+
+void BrowserDataWin::MouseButtonUp( const MouseEvent& rEvt )
+{
+ // avoid pseudo MouseMoves
+ Point aNewPos = OutputToScreenPixel( rEvt.GetPosPixel() );
+ aLastMousePos = aNewPos;
+
+ // simulate a move to the current position
+ MouseMove( rEvt );
+
+ // actual button up handling
+ ReleaseMouse();
+ if ( aMouseTimer.IsActive() )
+ aMouseTimer.Stop();
+ GetParent()->MouseButtonUp( BrowserMouseEvent( this, rEvt ) );
+}
+
+
+void BrowserDataWin::StartRowDividerDrag( const Point& _rStartPos )
+{
+ long nDataRowHeight = GetParent()->GetDataRowHeight();
+ // the exact separation pos of the two rows
+ long nDragRowDividerCurrentPos = _rStartPos.Y();
+ if ( ( nDragRowDividerCurrentPos % nDataRowHeight ) > nDataRowHeight / 2 )
+ nDragRowDividerCurrentPos += nDataRowHeight;
+ nDragRowDividerCurrentPos /= nDataRowHeight;
+ nDragRowDividerCurrentPos *= nDataRowHeight;
+
+ m_nDragRowDividerOffset = nDragRowDividerCurrentPos - _rStartPos.Y();
+
+ m_nDragRowDividerLimit = nDragRowDividerCurrentPos - nDataRowHeight;
+
+ GetParent()->bRowDividerDrag = true;
+ GetParent()->ImplStartTracking();
+
+ tools::Rectangle aDragSplitRect( 0, m_nDragRowDividerLimit, GetOutputSizePixel().Width(), nDragRowDividerCurrentPos );
+ ShowTracking( aDragSplitRect );
+
+ StartTracking();
+}
+
+
+void BrowserDataWin::Tracking( const TrackingEvent& rTEvt )
+{
+ if ( !GetParent()->bRowDividerDrag )
+ return;
+
+ Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
+ // stop resizing at our bottom line
+ if ( aMousePos.Y() > GetOutputSizePixel().Height() )
+ aMousePos.setY( GetOutputSizePixel().Height() );
+
+ if ( rTEvt.IsTrackingEnded() )
+ {
+ HideTracking();
+ GetParent()->bRowDividerDrag = false;
+ GetParent()->ImplEndTracking();
+
+ if ( !rTEvt.IsTrackingCanceled() )
+ {
+ long nNewRowHeight = aMousePos.Y() + m_nDragRowDividerOffset - m_nDragRowDividerLimit;
+
+ // care for minimum row height
+ if ( nNewRowHeight < GetParent()->QueryMinimumRowHeight() )
+ nNewRowHeight = GetParent()->QueryMinimumRowHeight();
+
+ GetParent()->SetDataRowHeight( nNewRowHeight );
+ GetParent()->RowHeightChanged();
+ }
+ }
+ else
+ {
+ long nDragRowDividerCurrentPos = aMousePos.Y() + m_nDragRowDividerOffset;
+
+ // care for minimum row height
+ if ( nDragRowDividerCurrentPos < m_nDragRowDividerLimit + GetParent()->QueryMinimumRowHeight() )
+ nDragRowDividerCurrentPos = m_nDragRowDividerLimit + GetParent()->QueryMinimumRowHeight();
+
+ tools::Rectangle aDragSplitRect( 0, m_nDragRowDividerLimit, GetOutputSizePixel().Width(), nDragRowDividerCurrentPos );
+ ShowTracking( aDragSplitRect );
+ }
+}
+
+
+void BrowserDataWin::KeyInput( const KeyEvent& rEvt )
+{
+ // pass to parent window
+ if ( !GetParent()->ProcessKey( rEvt ) )
+ Control::KeyInput( rEvt );
+}
+
+
+void BrowserDataWin::RequestHelp( const HelpEvent& rHEvt )
+{
+ GetParent()->RequestHelp( rHEvt );
+}
+
+
+BrowseEvent::BrowseEvent( vcl::Window* pWindow,
+ long nAbsRow, sal_uInt16 nColumn, sal_uInt16 nColumnId,
+ const tools::Rectangle& rRect ):
+ pWin(pWindow),
+ nRow(nAbsRow),
+ aRect(rRect),
+ nCol(nColumn),
+ nColId(nColumnId)
+{
+}
+
+
+BrowserMouseEvent::BrowserMouseEvent( BrowserDataWin *pWindow,
+ const MouseEvent& rEvt ):
+ MouseEvent(rEvt),
+ BrowseEvent( pWindow->CreateBrowseEvent( rEvt.GetPosPixel() ) )
+{
+}
+
+
+BrowserMouseEvent::BrowserMouseEvent( vcl::Window *pWindow, const MouseEvent& rEvt,
+ long nAbsRow, sal_uInt16 nColumn, sal_uInt16 nColumnId,
+ const tools::Rectangle& rRect ):
+ MouseEvent(rEvt),
+ BrowseEvent( pWindow, nAbsRow, nColumn, nColumnId, rRect )
+{
+}
+
+
+BrowserAcceptDropEvent::BrowserAcceptDropEvent( BrowserDataWin *pWindow, const AcceptDropEvent& rEvt )
+ :AcceptDropEvent(rEvt)
+ ,BrowseEvent( pWindow->CreateBrowseEvent( rEvt.maPosPixel ) )
+{
+}
+
+
+BrowserExecuteDropEvent::BrowserExecuteDropEvent( BrowserDataWin *pWindow, const ExecuteDropEvent& rEvt )
+ :ExecuteDropEvent(rEvt)
+ ,BrowseEvent( pWindow->CreateBrowseEvent( rEvt.maPosPixel ) )
+{
+}
+
+
+void BrowserDataWin::SetUpdateMode( bool bMode )
+{
+ DBG_ASSERT( !bUpdateMode || aInvalidRegion.empty(), "invalid region not empty" );
+ if ( bMode == bUpdateMode )
+ return;
+
+ bUpdateMode = bMode;
+ if ( bMode )
+ DoOutstandingInvalidations();
+}
+
+
+void BrowserDataWin::DoOutstandingInvalidations()
+{
+ for (const auto& rRect : aInvalidRegion)
+ Control::Invalidate( rRect );
+ aInvalidRegion.clear();
+}
+
+
+void BrowserDataWin::Invalidate( InvalidateFlags nFlags )
+{
+ if ( !GetUpdateMode() )
+ {
+ aInvalidRegion.clear();
+ aInvalidRegion.emplace_back( Point( 0, 0 ), GetOutputSizePixel() );
+ }
+ else
+ Window::Invalidate( nFlags );
+}
+
+
+void BrowserDataWin::Invalidate( const tools::Rectangle& rRect, InvalidateFlags nFlags )
+{
+ if ( !GetUpdateMode() )
+ aInvalidRegion.emplace_back( rRect );
+ else
+ Window::Invalidate( rRect, nFlags );
+}
+
+BrowserScrollBar::~BrowserScrollBar()
+{
+ disposeOnce();
+}
+
+void BrowserScrollBar::dispose()
+{
+ _pDataWin.clear();
+ ScrollBar::dispose();
+}
+
+void BrowserScrollBar::Tracking( const TrackingEvent& rTEvt )
+{
+ sal_uLong nPos = GetThumbPos();
+ if ( nPos != _nLastPos )
+ {
+ OUString aTip = OUString::number(nPos) + "/";
+ if ( !_pDataWin->GetRealRowCount().isEmpty() )
+ aTip += _pDataWin->GetRealRowCount();
+ else
+ aTip += OUString::number(GetRangeMax());
+
+ tools::Rectangle aRect(GetPointerPosPixel(), Size(GetTextWidth(aTip), GetTextHeight()));
+ Help::ShowQuickHelp(this, aRect, aTip);
+ _nLastPos = nPos;
+ }
+
+ ScrollBar::Tracking( rTEvt );
+}
+
+void BrowserScrollBar::EndScroll()
+{
+ Help::HideBalloonAndQuickHelp();
+ ScrollBar::EndScroll();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/datwin.hxx b/svtools/source/brwbox/datwin.hxx
new file mode 100644
index 000000000..1105708cc
--- /dev/null
+++ b/svtools/source/brwbox/datwin.hxx
@@ -0,0 +1,189 @@
+/* -*- 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 <svtools/brwbox.hxx>
+#include <svtools/brwhead.hxx>
+#include <vcl/scrbar.hxx>
+#include <vcl/timer.hxx>
+#include <vcl/transfer.hxx>
+#include <vector>
+
+#define MIN_COLUMNWIDTH 2
+
+class ButtonFrame
+{
+ tools::Rectangle aRect;
+ tools::Rectangle aInnerRect;
+ OUString aText;
+ bool m_bDrawDisabled;
+
+public:
+ ButtonFrame( const Point& rPt, const Size& rSz,
+ const OUString &rText,
+ bool _bDrawDisabled)
+ :aRect( rPt, rSz )
+ ,aInnerRect( Point( aRect.Left()+1, aRect.Top()+1 ),
+ Size( aRect.GetWidth()-2, aRect.GetHeight()-2 ) )
+ ,aText(rText)
+ ,m_bDrawDisabled(_bDrawDisabled)
+ {
+ }
+
+ void Draw( OutputDevice& rDev );
+};
+
+
+class BrowserColumn final
+{
+ sal_uInt16 _nId;
+ sal_uLong _nOriginalWidth;
+ sal_uLong _nWidth;
+ OUString _aTitle;
+ bool _bFrozen;
+
+public:
+ BrowserColumn( sal_uInt16 nItemId,
+ const OUString& rTitle, sal_uLong nWidthPixel, const Fraction& rCurrentZoom );
+ ~BrowserColumn();
+
+ sal_uInt16 GetId() const { return _nId; }
+
+ sal_uLong Width() { return _nWidth; }
+ OUString& Title() { return _aTitle; }
+
+ bool IsFrozen() const { return _bFrozen; }
+ void Freeze() { _bFrozen = true; }
+
+ void Draw( BrowseBox const & rBox, OutputDevice& rDev,
+ const Point& rPos );
+
+ void SetWidth(sal_uLong nNewWidthPixel, const Fraction& rCurrentZoom);
+ void ZoomChanged(const Fraction& rNewZoom);
+};
+
+
+class BrowserDataWin
+ :public Control
+ ,public DragSourceHelper
+ ,public DropTargetHelper
+{
+public:
+ VclPtr<BrowserHeader> pHeaderBar; // only for BrowserMode::HEADERBAR_NEW
+ VclPtr<ScrollBarBox> 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<tools::Rectangle> 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
+
+ long m_nDragRowDividerLimit;
+ 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
+ { return static_cast<BrowseBox*>( Window::GetParent() ); }
+ 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;
+
+protected:
+ void StartRowDividerDrag( const Point& _rStartPos );
+ bool ImplRowDividerHitTest( const BrowserMouseEvent& _rEvent );
+};
+
+
+class BrowserScrollBar: public ScrollBar
+{
+ sal_uLong _nLastPos;
+ VclPtr<BrowserDataWin> _pDataWin;
+
+public:
+ BrowserScrollBar( vcl::Window* pParent, WinBits nStyle,
+ BrowserDataWin *pDataWin )
+ : ScrollBar( pParent, nStyle ),
+ _nLastPos( ULONG_MAX ),
+ _pDataWin( pDataWin )
+ {}
+ virtual ~BrowserScrollBar() override;
+ virtual void dispose() override;
+ //ScrollBar( vcl::Window* pParent, const ResId& rResId );
+
+ virtual void Tracking( const TrackingEvent& rTEvt ) override;
+ virtual void EndScroll() override;
+};
+
+
+void InitSettings_Impl( vcl::Window *pWin );
+
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/ebbcontrols.cxx b/svtools/source/brwbox/ebbcontrols.cxx
new file mode 100644
index 000000000..e402f0a42
--- /dev/null
+++ b/svtools/source/brwbox/ebbcontrols.cxx
@@ -0,0 +1,566 @@
+/*
+ * 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 .
+ */
+
+#include <svtools/editbrowsebox.hxx>
+#include <vcl/button.hxx>
+#include <vcl/spinfld.hxx>
+#include <vcl/fmtfield.hxx>
+#include <vcl/xtextedt.hxx>
+#include <vcl/textview.hxx>
+
+namespace svt
+{
+
+ //= ComboBoxControl
+ ComboBoxControl::ComboBoxControl(vcl::Window* pParent)
+ : ControlBase(pParent, "svt/ui/combocontrol.ui", "ComboControl")
+ , m_xWidget(m_xBuilder->weld_combo_box("combobox"))
+ {
+ m_xWidget->set_entry_width_chars(1); // so a smaller than default width can be used
+ m_xWidget->connect_changed(LINK(this, ComboBoxControl, SelectHdl));
+ }
+
+ void ComboBoxControl::dispose()
+ {
+ m_xWidget.reset();
+ ControlBase::dispose();
+ }
+
+ IMPL_LINK_NOARG(ComboBoxControl, SelectHdl, weld::ComboBox&, void)
+ {
+ CallModifyHdls();
+ }
+
+ //= ComboBoxCellController
+ ComboBoxCellController::ComboBoxCellController(ComboBoxControl* pWin)
+ :CellController(pWin)
+ {
+ static_cast<ComboBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ComboBoxCellController, ModifyHdl));
+ }
+
+ IMPL_LINK_NOARG(ComboBoxCellController, ModifyHdl, LinkParamNone*, void)
+ {
+ callModifyHdl();
+ }
+
+ bool ComboBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
+ {
+ weld::ComboBox& rBox = GetComboBox();
+ switch (rEvt.GetKeyCode().GetCode())
+ {
+ case KEY_END:
+ case KEY_RIGHT:
+ {
+ int nStartPos, nEndPos;
+ bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
+ return bNoSelection && nEndPos == rBox.get_active_text().getLength();
+ }
+ case KEY_HOME:
+ case KEY_LEFT:
+ {
+ int nStartPos, nEndPos;
+ bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
+ return bNoSelection && nStartPos == 0;
+ }
+ case KEY_UP:
+ case KEY_DOWN:
+ if (rBox.get_popup_shown())
+ return false;
+ if (!rEvt.GetKeyCode().IsShift() &&
+ rEvt.GetKeyCode().IsMod1())
+ return false;
+ // drop down the list box
+ else if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
+ return false;
+ [[fallthrough]];
+ case KEY_PAGEUP:
+ case KEY_PAGEDOWN:
+ case KEY_RETURN:
+ if (rBox.get_popup_shown())
+ return false;
+ [[fallthrough]];
+ default:
+ return true;
+ }
+ }
+
+ bool ComboBoxCellController::IsModified() const
+ {
+ return GetComboBox().get_value_changed_from_saved();
+ }
+
+ void ComboBoxCellController::ClearModified()
+ {
+ GetComboBox().save_value();
+ }
+
+ //= ListBoxControl
+ ListBoxControl::ListBoxControl(vcl::Window* pParent)
+ : ControlBase(pParent, "svt/ui/listcontrol.ui", "ListControl")
+ , m_xWidget(m_xBuilder->weld_combo_box("listbox"))
+ {
+ m_xWidget->set_size_request(42, -1); // so a later narrow size request can stick
+ m_xWidget->connect_changed(LINK(this, ListBoxControl, SelectHdl));
+ }
+
+ void ListBoxControl::dispose()
+ {
+ m_xWidget.reset();
+ ControlBase::dispose();
+ }
+
+ IMPL_LINK_NOARG(ListBoxControl, SelectHdl, weld::ComboBox&, void)
+ {
+ CallModifyHdls();
+ }
+
+ //= ListBoxCellController
+ ListBoxCellController::ListBoxCellController(ListBoxControl* pWin)
+ :CellController(pWin)
+ {
+ static_cast<ListBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ListBoxCellController, ListBoxSelectHdl));
+ }
+
+ bool ListBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
+ {
+ const weld::ComboBox& rBox = GetListBox();
+ switch (rEvt.GetKeyCode().GetCode())
+ {
+ case KEY_UP:
+ case KEY_DOWN:
+ if (!rEvt.GetKeyCode().IsShift() &&
+ rEvt.GetKeyCode().IsMod1())
+ return false;
+ // drop down the list box
+ else
+ if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
+ return false;
+ [[fallthrough]];
+ case KEY_PAGEUP:
+ case KEY_PAGEDOWN:
+ if (rBox.get_popup_shown())
+ return false;
+ [[fallthrough]];
+ default:
+ return true;
+ }
+ }
+
+ bool ListBoxCellController::IsModified() const
+ {
+ return GetListBox().get_value_changed_from_saved();
+ }
+
+ void ListBoxCellController::ClearModified()
+ {
+ GetListBox().save_value();
+ }
+
+ IMPL_LINK_NOARG(ListBoxCellController, ListBoxSelectHdl, LinkParamNone*, void)
+ {
+ callModifyHdl();
+ }
+
+ //= CheckBoxControl
+ CheckBoxControl::CheckBoxControl(vcl::Window* pParent)
+ :Control(pParent, 0)
+ {
+ const Wallpaper& rParentBackground = pParent->GetBackground();
+ if ( (pParent->GetStyle() & WB_CLIPCHILDREN) || rParentBackground.IsFixed() )
+ SetBackground( rParentBackground );
+ else
+ {
+ SetPaintTransparent( true );
+ SetBackground();
+ }
+
+ EnableChildTransparentMode();
+
+ pBox = VclPtr<CheckBox>::Create(this,WB_CENTER|WB_VCENTER);
+ pBox->EnableTriState( true );
+ pBox->SetLegacyNoTextAlign( true );
+ pBox->EnableChildTransparentMode();
+ pBox->SetPaintTransparent( true );
+ pBox->SetClickHdl( LINK( this, CheckBoxControl, OnClick ) );
+ pBox->Show();
+ }
+
+ CheckBoxControl::~CheckBoxControl()
+ {
+ disposeOnce();
+ }
+
+ void CheckBoxControl::dispose()
+ {
+ pBox.disposeAndClear();
+ Control::dispose();
+ }
+
+
+ IMPL_LINK_NOARG(CheckBoxControl, OnClick, Button*, void)
+ {
+ m_aClickLink.Call(pBox);
+ m_aModifyLink.Call(nullptr);
+ }
+
+
+ void CheckBoxControl::Resize()
+ {
+ Control::Resize();
+ pBox->SetPosSizePixel(Point(0,0),GetSizePixel());
+ }
+
+
+ void CheckBoxControl::DataChanged( const DataChangedEvent& _rEvent )
+ {
+ if ( _rEvent.GetType() == DataChangedEventType::SETTINGS )
+ pBox->SetSettings( GetSettings() );
+ }
+
+
+ void CheckBoxControl::StateChanged( StateChangedType nStateChange )
+ {
+ Control::StateChanged(nStateChange);
+ if ( nStateChange == StateChangedType::Zoom )
+ pBox->SetZoom(GetZoom());
+ }
+
+ void CheckBoxControl::Draw( OutputDevice* pDev, const Point& rPos, DrawFlags nFlags )
+ {
+ pBox->Draw(pDev, rPos, nFlags);
+ }
+
+ void CheckBoxControl::GetFocus()
+ {
+ if (pBox)
+ pBox->GrabFocus();
+ }
+
+
+ void CheckBoxControl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rClientRect)
+ {
+ Control::Paint(rRenderContext, rClientRect);
+ if (HasFocus())
+ ShowFocus(tools::Rectangle());
+ }
+
+
+ bool CheckBoxControl::PreNotify(NotifyEvent& rEvt)
+ {
+ switch (rEvt.GetType())
+ {
+ case MouseNotifyEvent::GETFOCUS:
+ ShowFocus(tools::Rectangle());
+ break;
+ case MouseNotifyEvent::LOSEFOCUS:
+ HideFocus();
+ break;
+ default:
+ break;
+ }
+ return Control::PreNotify(rEvt);
+ }
+
+
+ //= CheckBoxCellController
+
+
+ CheckBoxCellController::CheckBoxCellController(CheckBoxControl* pWin)
+ : CellController(pWin)
+ {
+ static_cast<CheckBoxControl &>(GetWindow()).SetModifyHdl( LINK(this, CheckBoxCellController, ModifyHdl) );
+ }
+
+ bool CheckBoxCellController::WantMouseEvent() const
+ {
+ return true;
+ }
+
+
+ CheckBox& CheckBoxCellController::GetCheckBox() const
+ {
+ return static_cast<CheckBoxControl &>(GetWindow()).GetBox();
+ }
+
+
+ bool CheckBoxCellController::IsModified() const
+ {
+ return GetCheckBox().IsValueChangedFromSaved();
+ }
+
+
+ void CheckBoxCellController::ClearModified()
+ {
+ GetCheckBox().SaveValue();
+ }
+
+
+ IMPL_LINK_NOARG(CheckBoxCellController, ModifyHdl, LinkParamNone*, void)
+ {
+ callModifyHdl();
+ }
+
+ //= MultiLineEditImplementation
+
+
+ OUString MultiLineEditImplementation::GetText( LineEnd aSeparator ) const
+ {
+ return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetText( aSeparator );
+ }
+
+
+ OUString MultiLineEditImplementation::GetSelected( LineEnd aSeparator ) const
+ {
+ return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetSelected( aSeparator );
+ }
+
+
+ //= EditCellController
+
+
+ EditCellController::EditCellController( Edit* _pEdit )
+ :CellController( _pEdit )
+ ,m_pEditImplementation( new EditImplementation( *_pEdit ) )
+ ,m_bOwnImplementation( true )
+ {
+ m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
+ }
+
+
+ EditCellController::EditCellController( IEditImplementation* _pImplementation )
+ :CellController( &_pImplementation->GetControl() )
+ ,m_pEditImplementation( _pImplementation )
+ ,m_bOwnImplementation( false )
+ {
+ m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
+ }
+
+
+ EditCellController::~EditCellController( )
+ {
+ if ( m_bOwnImplementation )
+ DELETEZ( m_pEditImplementation );
+ }
+
+
+ void EditCellController::SetModified()
+ {
+ m_pEditImplementation->SetModified();
+ }
+
+
+ void EditCellController::ClearModified()
+ {
+ m_pEditImplementation->ClearModified();
+ }
+
+
+ bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
+ {
+ bool bResult;
+ switch (rEvt.GetKeyCode().GetCode())
+ {
+ case KEY_END:
+ case KEY_RIGHT:
+ {
+ Selection aSel = m_pEditImplementation->GetSelection();
+ bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).getLength();
+ } break;
+ case KEY_HOME:
+ case KEY_LEFT:
+ {
+ Selection aSel = m_pEditImplementation->GetSelection();
+ bResult = !aSel && aSel.Min() == 0;
+ } break;
+ default:
+ bResult = true;
+ }
+ return bResult;
+ }
+
+
+ bool EditCellController::IsModified() const
+ {
+ return m_pEditImplementation->IsModified();
+ }
+
+
+ IMPL_LINK_NOARG(EditCellController, ModifyHdl, Edit&, void)
+ {
+ callModifyHdl();
+ }
+
+ //= SpinCellController
+
+
+ SpinCellController::SpinCellController(SpinField* pWin)
+ :CellController(pWin)
+ {
+ GetSpinWindow().SetModifyHdl( LINK(this, SpinCellController, ModifyHdl) );
+ }
+
+ const SpinField& SpinCellController::GetSpinWindow() const
+ {
+ return static_cast<const SpinField &>(GetWindow());
+ }
+
+ SpinField& SpinCellController::GetSpinWindow()
+ {
+ return static_cast<SpinField &>(GetWindow());
+ }
+
+ void SpinCellController::SetModified()
+ {
+ GetSpinWindow().SetModifyFlag();
+ }
+
+
+ void SpinCellController::ClearModified()
+ {
+ GetSpinWindow().ClearModifyFlag();
+ }
+
+
+ bool SpinCellController::MoveAllowed(const KeyEvent& rEvt) const
+ {
+ bool bResult;
+ switch (rEvt.GetKeyCode().GetCode())
+ {
+ case KEY_END:
+ case KEY_RIGHT:
+ {
+ Selection aSel = GetSpinWindow().GetSelection();
+ bResult = !aSel && aSel.Max() == GetSpinWindow().GetText().getLength();
+ } break;
+ case KEY_HOME:
+ case KEY_LEFT:
+ {
+ Selection aSel = GetSpinWindow().GetSelection();
+ bResult = !aSel && aSel.Min() == 0;
+ } break;
+ default:
+ bResult = true;
+ }
+ return bResult;
+ }
+
+
+ bool SpinCellController::IsModified() const
+ {
+ return GetSpinWindow().IsModified();
+ }
+
+ IMPL_LINK_NOARG(SpinCellController, ModifyHdl, Edit&, void)
+ {
+ callModifyHdl();
+ }
+
+ //= FormattedFieldCellController
+
+
+ FormattedFieldCellController::FormattedFieldCellController( FormattedField* _pFormatted )
+ :EditCellController( _pFormatted )
+ {
+ }
+
+
+ void FormattedFieldCellController::CommitModifications()
+ {
+ static_cast< FormattedField& >( GetWindow() ).Commit();
+ }
+
+
+ //= MultiLineTextCell
+
+
+ void MultiLineTextCell::Modify()
+ {
+ GetTextEngine()->SetModified( true );
+ VclMultiLineEdit::Modify();
+ }
+
+
+ bool MultiLineTextCell::dispatchKeyEvent( const KeyEvent& _rEvent )
+ {
+ Selection aOldSelection( GetSelection() );
+
+ bool bWasModified = IsModified();
+ ClearModifyFlag( );
+
+ bool bHandled = GetTextView()->KeyInput( _rEvent );
+
+ bool bIsModified = IsModified();
+ if ( bWasModified && !bIsModified )
+ // not sure whether this can really happen
+ SetModifyFlag();
+
+ if ( bHandled ) // the view claimed it handled the key input
+ {
+ // unfortunately, KeyInput also returns <TRUE/> (means "I handled this key input")
+ // when nothing really changed. Let's care for this.
+ Selection aNewSelection( GetSelection() );
+ if ( aNewSelection != aOldSelection // selection changed
+ || bIsModified // or some other modification
+ )
+ return true;
+ }
+ return false;
+ }
+
+
+ bool MultiLineTextCell::PreNotify( NotifyEvent& rNEvt )
+ {
+ if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
+ {
+ if ( IsWindowOrChild( rNEvt.GetWindow() ) )
+ {
+ // give the text view a chance to handle the keys
+ // this is necessary since a lot of keys which are normally handled
+ // by this view (in KeyInput) are intercepted by the EditBrowseBox,
+ // which uses them for other reasons. An example is the KeyUp key,
+ // which is used by both the text view and the edit browse box
+
+ const KeyEvent* pKeyEvent = rNEvt.GetKeyEvent();
+ const vcl::KeyCode& rKeyCode = pKeyEvent->GetKeyCode();
+ sal_uInt16 nCode = rKeyCode.GetCode();
+
+ if ( ( nCode == KEY_RETURN ) && ( rKeyCode.GetModifier() == KEY_MOD1 ) )
+ {
+ KeyEvent aEvent( pKeyEvent->GetCharCode(),
+ vcl::KeyCode( KEY_RETURN ),
+ pKeyEvent->GetRepeat()
+ );
+ if ( dispatchKeyEvent( aEvent ) )
+ return true;
+ }
+
+ if ( ( nCode != KEY_TAB ) && ( nCode != KEY_RETURN ) ) // everything but tab and enter
+ {
+ if ( dispatchKeyEvent( *pKeyEvent ) )
+ return true;
+ }
+ }
+ }
+ return VclMultiLineEdit::PreNotify( rNEvt );
+ }
+
+
+} // namespace svt
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/editbrowsebox.cxx b/svtools/source/brwbox/editbrowsebox.cxx
new file mode 100644
index 000000000..12ef6d6fd
--- /dev/null
+++ b/svtools/source/brwbox/editbrowsebox.cxx
@@ -0,0 +1,1326 @@
+/* -*- 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 .
+ */
+
+#include <svtools/editbrowsebox.hxx>
+
+#include <vcl/svapp.hxx>
+#include <tools/debug.hxx>
+#include <vcl/window.hxx>
+
+#include <vcl/button.hxx>
+#include <vcl/edit.hxx>
+#include <vcl/settings.hxx>
+
+#include <bitmaps.hlst>
+
+#include <algorithm>
+#include "editbrowseboximpl.hxx"
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+
+
+namespace svt
+{
+
+ namespace
+ {
+
+ GetFocusFlags getRealGetFocusFlags( vcl::Window* _pWindow )
+ {
+ GetFocusFlags nFlags = GetFocusFlags::NONE;
+ while ( _pWindow && nFlags == GetFocusFlags::NONE )
+ {
+ nFlags = _pWindow->GetGetFocusFlags( );
+ _pWindow = _pWindow->GetParent();
+ }
+ return nFlags;
+ }
+ }
+
+ using namespace ::com::sun::star::uno;
+ using namespace com::sun::star::accessibility::AccessibleEventId;
+
+
+ IEditImplementation::~IEditImplementation()
+ {
+ }
+
+ //= EditBrowserHeader
+
+ void EditBrowserHeader::DoubleClick()
+ {
+ sal_uInt16 nColId = GetCurItemId();
+ if (nColId)
+ {
+ sal_uInt32 nAutoWidth = static_cast<EditBrowseBox*>(GetParent())->GetAutoColumnWidth(nColId);
+ if (nAutoWidth != static_cast<EditBrowseBox*>(GetParent())->GetColumnWidth(nColId))
+ {
+ static_cast<EditBrowseBox*>(GetParent())->SetColumnWidth(nColId, nAutoWidth);
+ static_cast<EditBrowseBox*>(GetParent())->ColumnResized(nColId);
+ }
+ }
+ }
+
+ //= EditBrowseBox
+
+ void EditBrowseBox::BrowserMouseEventPtr::Clear()
+ {
+ pEvent.reset();
+ }
+
+ void EditBrowseBox::BrowserMouseEventPtr::Set(const BrowserMouseEvent* pEvt, bool bIsDown)
+ {
+ if (pEvt == pEvent.get())
+ {
+ bDown = bIsDown;
+ return;
+ }
+ pEvent.reset();
+ if (pEvt)
+ {
+ pEvent.reset(new BrowserMouseEvent(pEvt->GetWindow(),
+ *pEvt,
+ pEvt->GetRow(),
+ pEvt->GetColumn(),
+ pEvt->GetColumnId(),
+ pEvt->GetRect()));
+ bDown = bIsDown;
+ }
+ }
+
+ EditBrowseBox::EditBrowseBox( vcl::Window* pParent, EditBrowseBoxFlags nBrowserFlags, WinBits nBits, BrowserMode _nMode )
+ :BrowseBox( pParent, nBits, _nMode )
+ ,nStartEvent(nullptr)
+ ,nEndEvent(nullptr)
+ ,nCellModifiedEvent(nullptr)
+ ,m_pFocusWhileRequest(nullptr)
+ ,nPaintRow(-1)
+ ,nEditRow(-1)
+ ,nEditCol(0)
+ ,bHasFocus(false)
+ ,bPaintStatus(true)
+ ,bActiveBeforeTracking( false )
+ ,m_nBrowserFlags(nBrowserFlags)
+ ,pHeader(nullptr)
+ {
+ m_aImpl.reset(new EditBrowseBoxImpl);
+
+ SetCompoundControl(true);
+
+ ImplInitSettings(true, true, true);
+
+ pCheckBoxPaint = VclPtr<CheckBoxControl>::Create(&GetDataWindow());
+ pCheckBoxPaint->SetPaintTransparent( true );
+ pCheckBoxPaint->SetBackground();
+ }
+
+ void EditBrowseBox::Init()
+ {
+ // late construction
+ }
+
+ EditBrowseBox::~EditBrowseBox()
+ {
+ disposeOnce();
+ }
+
+ void EditBrowseBox::dispose()
+ {
+ if (nStartEvent)
+ Application::RemoveUserEvent(nStartEvent);
+ if (nEndEvent)
+ Application::RemoveUserEvent(nEndEvent);
+ if (nCellModifiedEvent)
+ Application::RemoveUserEvent(nCellModifiedEvent);
+
+ pCheckBoxPaint.disposeAndClear();
+ m_pFocusWhileRequest.clear();
+ pHeader.clear();
+ BrowseBox::dispose();
+ }
+
+
+ void EditBrowseBox::RemoveRows()
+ {
+ BrowseBox::Clear();
+ nEditRow = nPaintRow = -1;
+ nEditCol = 0;
+ }
+
+
+ VclPtr<BrowserHeader> EditBrowseBox::CreateHeaderBar(BrowseBox* pParent)
+ {
+ pHeader = imp_CreateHeaderBar(pParent);
+ if (!IsUpdateMode())
+ pHeader->SetUpdateMode(false);
+ return pHeader;
+ }
+
+
+ VclPtr<BrowserHeader> EditBrowseBox::imp_CreateHeaderBar(BrowseBox* pParent)
+ {
+ return VclPtr<EditBrowserHeader>::Create(pParent);
+ }
+
+
+ void EditBrowseBox::LoseFocus()
+ {
+ BrowseBox::LoseFocus();
+ DetermineFocus();
+ }
+
+
+ void EditBrowseBox::GetFocus()
+ {
+ BrowseBox::GetFocus();
+
+ // This should handle the case that the BrowseBox (or one of its children)
+ // gets the focus from outside by pressing Tab
+ if (IsEditing() && Controller()->GetWindow().IsVisible())
+ Controller()->GetWindow().GrabFocus();
+
+ DetermineFocus( getRealGetFocusFlags( this ) );
+ }
+
+
+ bool EditBrowseBox::SeekRow(long nRow)
+ {
+ nPaintRow = nRow;
+ return true;
+ }
+
+
+ IMPL_LINK_NOARG(EditBrowseBox, StartEditHdl, void*, void)
+ {
+ nStartEvent = nullptr;
+ if (IsEditing())
+ {
+ EnableAndShow();
+ if (!ControlHasFocus() && (m_pFocusWhileRequest.get() == Application::GetFocusWindow()))
+ aController->GetWindow().GrabFocus();
+ }
+ }
+
+ void EditBrowseBox::PaintField( vcl::RenderContext& rDev, const tools::Rectangle& rRect,
+ sal_uInt16 nColumnId ) const
+ {
+ if (nColumnId == HandleColumnId)
+ {
+ if (bPaintStatus)
+ PaintStatusCell(rDev, rRect);
+ }
+ else
+ {
+ // don't paint the current cell
+ if (&rDev == &GetDataWindow())
+ // but only if we're painting onto our data win (which is the usual painting)
+ if (nPaintRow == nEditRow)
+ {
+ if (IsEditing() && nEditCol == nColumnId && aController->GetWindow().IsVisible())
+ return;
+ }
+ PaintCell(rDev, rRect, nColumnId);
+ }
+ }
+
+ Image EditBrowseBox::GetImage(RowStatus eStatus) const
+ {
+ BitmapEx aBitmap;
+ bool bNeedMirror = IsRTLEnabled();
+ switch (eStatus)
+ {
+ case CURRENT:
+ aBitmap = BitmapEx(BMP_CURRENT);
+ break;
+ case CURRENTNEW:
+ aBitmap = BitmapEx(BMP_CURRENTNEW);
+ break;
+ case MODIFIED:
+ aBitmap = BitmapEx(BMP_MODIFIED);
+ bNeedMirror = false; // the pen is not mirrored
+ break;
+ case NEW:
+ aBitmap = BitmapEx(BMP_NEW);
+ break;
+ case DELETED:
+ aBitmap = BitmapEx(BMP_DELETED);
+ break;
+ case PRIMARYKEY:
+ aBitmap = BitmapEx(BMP_PRIMARYKEY);
+ break;
+ case CURRENT_PRIMARYKEY:
+ aBitmap = BitmapEx(BMP_CURRENT_PRIMARYKEY);
+ break;
+ case FILTER:
+ aBitmap = BitmapEx(BMP_FILTER);
+ break;
+ case HEADERFOOTER:
+ aBitmap = BitmapEx(BMP_HEADERFOOTER);
+ break;
+ case CLEAN:
+ break;
+ }
+ if ( bNeedMirror )
+ {
+ aBitmap.Mirror( BmpMirrorFlags::Horizontal );
+ }
+ return Image(aBitmap);
+ }
+
+ void EditBrowseBox::PaintStatusCell(OutputDevice& rDev, const tools::Rectangle& rRect) const
+ {
+ if (nPaintRow < 0)
+ return;
+
+ RowStatus eStatus = GetRowStatus( nPaintRow );
+ EditBrowseBoxFlags nBrowserFlags = GetBrowserFlags();
+
+ if (nBrowserFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT)
+ return;
+
+ // draw the text of the header column
+ if (nBrowserFlags & EditBrowseBoxFlags::HANDLE_COLUMN_TEXT )
+ {
+ rDev.DrawText( rRect, GetCellText( nPaintRow, 0 ),
+ DrawTextFlags::Center | DrawTextFlags::VCenter | DrawTextFlags::Clip );
+ }
+ // draw an image
+ else if (eStatus != CLEAN && rDev.GetOutDevType() == OUTDEV_WINDOW)
+ {
+ Image aImage(GetImage(eStatus));
+ // calc the image position
+ Size aImageSize(aImage.GetSizePixel());
+ aImageSize.setWidth( CalcZoom(aImageSize.Width()) );
+ aImageSize.setHeight( CalcZoom(aImageSize.Height()) );
+ Point aPos( rRect.TopLeft() );
+
+ if ( ( aImageSize.Width() > rRect.GetWidth() ) || ( aImageSize.Height() > rRect.GetHeight() ) )
+ rDev.SetClipRegion(vcl::Region(rRect));
+
+ if ( aImageSize.Width() < rRect.GetWidth() )
+ aPos.AdjustX(( rRect.GetWidth() - aImageSize.Width() ) / 2 );
+
+ if ( aImageSize.Height() < rRect.GetHeight() )
+ aPos.AdjustY(( rRect.GetHeight() - aImageSize.Height() ) / 2 );
+
+ if ( IsZoom() )
+ rDev.DrawImage( aPos, aImageSize, aImage );
+ else
+ rDev.DrawImage( aPos, aImage );
+
+ if (rDev.IsClipRegion())
+ rDev.SetClipRegion();
+ }
+ }
+
+
+ void EditBrowseBox::ImplStartTracking()
+ {
+ bActiveBeforeTracking = IsEditing();
+ if ( bActiveBeforeTracking )
+ {
+ DeactivateCell();
+ PaintImmediately();
+ }
+
+ BrowseBox::ImplStartTracking();
+ }
+
+
+ void EditBrowseBox::ImplEndTracking()
+ {
+ if ( bActiveBeforeTracking )
+ ActivateCell();
+ bActiveBeforeTracking = false;
+
+ BrowseBox::ImplEndTracking();
+ }
+
+
+ void EditBrowseBox::RowHeightChanged()
+ {
+ if ( IsEditing() )
+ {
+ tools::Rectangle aRect( GetCellRect( nEditRow, nEditCol, false ) );
+ CellControllerRef aCellController( Controller() );
+ ResizeController( aCellController, aRect );
+ aCellController->GetWindow().GrabFocus();
+ }
+
+ BrowseBox::RowHeightChanged();
+ }
+
+
+ EditBrowseBox::RowStatus EditBrowseBox::GetRowStatus(long) const
+ {
+ return CLEAN;
+ }
+
+
+ void EditBrowseBox::KeyInput( const KeyEvent& rEvt )
+ {
+ sal_uInt16 nCode = rEvt.GetKeyCode().GetCode();
+ bool bShift = rEvt.GetKeyCode().IsShift();
+ bool bCtrl = rEvt.GetKeyCode().IsMod1();
+
+ switch (nCode)
+ {
+ case KEY_RETURN:
+ if (!bCtrl && !bShift && IsTabAllowed(true))
+ {
+ Dispatch(BROWSER_CURSORRIGHT);
+ }
+ else
+ BrowseBox::KeyInput(rEvt);
+ return;
+ case KEY_TAB:
+ if (!bCtrl && !bShift)
+ {
+ if (IsTabAllowed(true))
+ Dispatch(BROWSER_CURSORRIGHT);
+ else
+ // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
+ // that tab isn't allowed here. So give the Control class a chance
+ Control::KeyInput(rEvt);
+ return;
+ }
+ else if (!bCtrl && bShift)
+ {
+ if (IsTabAllowed(false))
+ Dispatch(BROWSER_CURSORLEFT);
+ else
+ // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
+ // that tab isn't allowed here. So give the Control class a chance
+ Control::KeyInput(rEvt);
+ return;
+ }
+ [[fallthrough]];
+ default:
+ BrowseBox::KeyInput(rEvt);
+ }
+ }
+
+
+ void EditBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt)
+ {
+ // absorb double clicks
+ if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
+ return;
+
+ // we are about to leave the current cell. If there is a "this cell has been modified" notification
+ // pending (asynchronously), this may be deadly -> do it synchronously
+ if ( nCellModifiedEvent )
+ {
+ Application::RemoveUserEvent( nCellModifiedEvent );
+ nCellModifiedEvent = nullptr;
+ LINK( this, EditBrowseBox, CellModifiedHdl ).Call( nullptr );
+ }
+
+ if (rEvt.GetColumnId() == HandleColumnId)
+ { // it was the handle column. save the current cell content if necessary
+ // (clicking on the handle column results in selecting the current row)
+ if (IsEditing() && aController->IsModified())
+ SaveModified();
+ }
+
+ aMouseEvent.Set(&rEvt,true);
+ BrowseBox::MouseButtonDown(rEvt);
+ aMouseEvent.Clear();
+
+ if (m_nBrowserFlags & EditBrowseBoxFlags::ACTIVATE_ON_BUTTONDOWN)
+ {
+ // the base class does not travel upon MouseButtonDown, but implActivateCellOnMouseEvent assumes we traveled ...
+ GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
+ if (rEvt.GetRow() >= 0)
+ implActivateCellOnMouseEvent(rEvt, false);
+ }
+ }
+
+
+ void EditBrowseBox::MouseButtonUp( const BrowserMouseEvent& rEvt )
+ {
+ // absorb double clicks
+ if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
+ return;
+
+ aMouseEvent.Set(&rEvt,false);
+ BrowseBox::MouseButtonUp(rEvt);
+ aMouseEvent.Clear();
+
+ if (!(m_nBrowserFlags & EditBrowseBoxFlags::ACTIVATE_ON_BUTTONDOWN))
+ if (rEvt.GetRow() >= 0)
+ implActivateCellOnMouseEvent(rEvt, true);
+ }
+
+ bool EditBrowseBox::ControlHasFocus() const
+ {
+ Window* pControlWindow = aController ? &aController->GetWindow() : nullptr;
+ if (ControlBase* pControlBase = dynamic_cast<ControlBase*>(pControlWindow))
+ return pControlBase->ControlHasFocus();
+ return pControlWindow && pControlWindow->HasChildPathFocus();
+ }
+
+ void EditBrowseBox::implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, bool _bUp)
+ {
+ if (!IsEditing())
+ ActivateCell();
+ else if (IsEditing() && !aController->GetWindow().IsEnabled())
+ DeactivateCell();
+ else if (IsEditing() && !ControlHasFocus())
+ AsynchGetFocus();
+
+ if (!(IsEditing() && aController->GetWindow().IsEnabled() && aController->WantMouseEvent()))
+ return;
+
+// forwards the event to the control
+
+ // If the field has been moved previously, we have to adjust the position
+
+ aController->GetWindow().GrabFocus();
+
+ // the position of the event relative to the controller's window
+ Point aPos = _rEvt.GetPosPixel() - _rEvt.GetRect().TopLeft();
+ // the (child) window which should really get the event
+ vcl::Window* pRealHandler = aController->GetWindow().FindWindow(aPos);
+ if (pRealHandler)
+ // the coords relative to this real handler
+ aPos -= pRealHandler->GetPosPixel();
+ else
+ pRealHandler = &aController->GetWindow();
+
+ // the faked event
+ MouseEvent aEvent(aPos, _rEvt.GetClicks(), _rEvt.GetMode(),
+ _rEvt.GetButtons(),
+ _rEvt.GetModifier());
+
+ pRealHandler->MouseButtonDown(aEvent);
+ if (_bUp)
+ pRealHandler->MouseButtonUp(aEvent);
+
+ vcl::Window *pWin = &aController->GetWindow();
+ if (!pWin->IsTracking())
+ {
+ for (pWin = pWin->GetWindow(GetWindowType::FirstChild);
+ pWin && !pWin->IsTracking();
+ pWin = pWin->GetWindow(GetWindowType::Next))
+ {
+ }
+ }
+ if (pWin && pWin->IsTracking())
+ pWin->EndTracking();
+ }
+
+
+ void EditBrowseBox::Dispatch( sal_uInt16 _nId )
+ {
+ if ( _nId == BROWSER_ENHANCESELECTION )
+ { // this is a workaround for the bug in the base class:
+ // if the row selection is to be extended (which is what BROWSER_ENHANCESELECTION tells us)
+ // then the base class does not revert any column selections, while, for doing a "simple"
+ // selection (BROWSER_SELECT), it does. In fact, it does not only revert the col selection then,
+ // but also any current row selections.
+ // This clearly tells me that the both ids are for row selection only - there this behaviour does
+ // make sense.
+ // But here, where we have column selection, too, we take care of this ourself.
+ if ( GetSelectColumnCount( ) )
+ {
+ while ( GetSelectColumnCount( ) )
+ SelectColumnPos(
+ sal::static_int_cast< sal_uInt16 >(FirstSelectedColumn()),
+ false );
+ Select();
+ }
+ }
+ BrowseBox::Dispatch( _nId );
+ }
+
+ bool EditBrowseBox::PreNotify(NotifyEvent& rEvt)
+ {
+ if (rEvt.GetType() == MouseNotifyEvent::KEYINPUT)
+ {
+ if ( (IsEditing() && ControlHasFocus())
+ || rEvt.GetWindow() == &GetDataWindow()
+ || (!IsEditing() && HasChildPathFocus())
+ )
+ {
+ const KeyEvent* pKeyEvent = rEvt.GetKeyEvent();
+ sal_uInt16 nCode = pKeyEvent->GetKeyCode().GetCode();
+ bool bShift = pKeyEvent->GetKeyCode().IsShift();
+ bool bCtrl = pKeyEvent->GetKeyCode().IsMod1();
+ bool bAlt = pKeyEvent->GetKeyCode().IsMod2();
+ bool bLocalSelect = false;
+ bool bNonEditOnly = false;
+ sal_uInt16 nId = BROWSER_NONE;
+
+ if (!bAlt && !bCtrl && !bShift )
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_CURSORDOWN; break;
+ case KEY_UP: nId = BROWSER_CURSORUP; break;
+ case KEY_PAGEDOWN: nId = BROWSER_CURSORPAGEDOWN; break;
+ case KEY_PAGEUP: nId = BROWSER_CURSORPAGEUP; break;
+ case KEY_HOME: nId = BROWSER_CURSORHOME; break;
+ case KEY_END: nId = BROWSER_CURSOREND; break;
+
+ case KEY_TAB:
+ // ask if traveling to the next cell is allowed
+ if (IsTabAllowed(true))
+ nId = BROWSER_CURSORRIGHT;
+ break;
+
+ case KEY_RETURN:
+ // save the cell content (if necessary)
+ if (IsEditing() && aController->IsModified() && !SaveModified())
+ {
+ // maybe we're not visible ...
+ EnableAndShow();
+ aController->GetWindow().GrabFocus();
+ return true;
+ }
+ // ask if traveling to the next cell is allowed
+ if (IsTabAllowed(true))
+ nId = BROWSER_CURSORRIGHT;
+
+ break;
+ case KEY_RIGHT: nId = BROWSER_CURSORRIGHT; break;
+ case KEY_LEFT: nId = BROWSER_CURSORLEFT; break;
+ case KEY_SPACE: nId = BROWSER_SELECT; bNonEditOnly = bLocalSelect = true; break;
+ }
+
+ if ( !bAlt && !bCtrl && bShift )
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_SELECTDOWN; bLocalSelect = true; break;
+ case KEY_UP: nId = BROWSER_SELECTUP; bLocalSelect = true; break;
+ case KEY_HOME: nId = BROWSER_SELECTHOME; bLocalSelect = true; break;
+ case KEY_END: nId = BROWSER_SELECTEND; bLocalSelect = true; break;
+ case KEY_TAB:
+ if (IsTabAllowed(false))
+ nId = BROWSER_CURSORLEFT;
+ break;
+ }
+
+ if ( !bAlt && bCtrl && bShift )
+ switch ( nCode )
+ {
+ case KEY_SPACE: nId = BROWSER_SELECTCOLUMN; bLocalSelect = true; break;
+ }
+
+
+ if ( !bAlt && bCtrl && !bShift )
+ switch ( nCode )
+ {
+ case KEY_DOWN: nId = BROWSER_SCROLLUP; break;
+ case KEY_UP: nId = BROWSER_SCROLLDOWN; break;
+ case KEY_PAGEDOWN: nId = BROWSER_CURSORENDOFFILE; break;
+ case KEY_PAGEUP: nId = BROWSER_CURSORTOPOFFILE; break;
+ case KEY_HOME: nId = BROWSER_CURSORTOPOFSCREEN; break;
+ case KEY_END: nId = BROWSER_CURSORENDOFSCREEN; break;
+ case KEY_SPACE: nId = BROWSER_ENHANCESELECTION; bLocalSelect = true; break;
+ }
+
+
+ if ( ( nId != BROWSER_NONE )
+ && ( !IsEditing()
+ || ( !bNonEditOnly
+ && aController->MoveAllowed( *pKeyEvent )
+ )
+ )
+ )
+ {
+ if (nId == BROWSER_SELECT || BROWSER_SELECTCOLUMN == nId )
+ {
+ // save the cell content (if necessary)
+ if (IsEditing() && aController->IsModified() && !SaveModified())
+ {
+ // maybe we're not visible ...
+ EnableAndShow();
+ aController->GetWindow().GrabFocus();
+ return true;
+ }
+ }
+
+ Dispatch(nId);
+
+ if (bLocalSelect && (GetSelectRowCount() || GetSelection() != nullptr))
+ DeactivateCell();
+ return true;
+ }
+ }
+ }
+ return BrowseBox::PreNotify(rEvt);
+ }
+
+ bool EditBrowseBox::IsTabAllowed(bool) const
+ {
+ return true;
+ }
+
+
+ bool EditBrowseBox::EventNotify(NotifyEvent& rEvt)
+ {
+ switch (rEvt.GetType())
+ {
+ case MouseNotifyEvent::GETFOCUS:
+ DetermineFocus( getRealGetFocusFlags( this ) );
+ break;
+
+ case MouseNotifyEvent::LOSEFOCUS:
+ DetermineFocus();
+ break;
+
+ default:
+ break;
+ }
+ return BrowseBox::EventNotify(rEvt);
+ }
+
+
+ void EditBrowseBox::StateChanged( StateChangedType nType )
+ {
+ BrowseBox::StateChanged( nType );
+
+ bool bNeedCellReActivation = false;
+ if ( nType == StateChangedType::Mirroring )
+ {
+ bNeedCellReActivation = true;
+ }
+ else if ( nType == StateChangedType::Zoom )
+ {
+ ImplInitSettings( true, false, false );
+ bNeedCellReActivation = true;
+ }
+ else if ( nType == StateChangedType::ControlFont )
+ {
+ ImplInitSettings( true, false, false );
+ Invalidate();
+ }
+ else if ( nType == StateChangedType::ControlForeground )
+ {
+ ImplInitSettings( false, true, false );
+ Invalidate();
+ }
+ else if ( nType == StateChangedType::ControlBackground )
+ {
+ ImplInitSettings( false, false, true );
+ Invalidate();
+ }
+ else if (nType == StateChangedType::Style)
+ {
+ WinBits nStyle = GetStyle();
+ if (!(nStyle & WB_NOTABSTOP) )
+ nStyle |= WB_TABSTOP;
+
+ SetStyle(nStyle);
+ }
+ if ( bNeedCellReActivation )
+ {
+ if ( IsEditing() )
+ {
+ DeactivateCell();
+ ActivateCell();
+ }
+ }
+ }
+
+
+ void EditBrowseBox::DataChanged( const DataChangedEvent& rDCEvt )
+ {
+ BrowseBox::DataChanged( rDCEvt );
+
+ if ((( rDCEvt.GetType() == DataChangedEventType::SETTINGS ) ||
+ ( rDCEvt.GetType() == DataChangedEventType::DISPLAY )) &&
+ ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE ))
+ {
+ ImplInitSettings( true, true, true );
+ Invalidate();
+ }
+ }
+
+ void EditBrowseBox::ImplInitSettings( bool bFont, bool bForeground, bool bBackground )
+ {
+ const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
+
+ if (bFont)
+ {
+ vcl::Font aFont = rStyleSettings.GetFieldFont();
+ if (IsControlFont())
+ {
+ GetDataWindow().SetControlFont(GetControlFont());
+ aFont.Merge(GetControlFont());
+ }
+ else
+ GetDataWindow().SetControlFont();
+
+ GetDataWindow().SetZoomedPointFont(GetDataWindow(), aFont);
+ }
+
+ if (bFont || bForeground)
+ {
+ Color aTextColor = rStyleSettings.GetFieldTextColor();
+ if (IsControlForeground())
+ {
+ aTextColor = GetControlForeground();
+ GetDataWindow().SetControlForeground(aTextColor);
+ }
+ else
+ GetDataWindow().SetControlForeground();
+
+ GetDataWindow().SetTextColor( aTextColor );
+ }
+
+ if (!bBackground) // FIXME: Outside of Paint Hierarchy
+ return;
+
+ if (GetDataWindow().IsControlBackground())
+ {
+ GetDataWindow().SetControlBackground(GetControlBackground());
+ GetDataWindow().SetBackground(GetDataWindow().GetControlBackground());
+ GetDataWindow().SetFillColor(GetDataWindow().GetControlBackground());
+ }
+ else
+ {
+ GetDataWindow().SetControlBackground();
+ GetDataWindow().SetBackground(rStyleSettings.GetFieldColor());
+ GetDataWindow().SetFillColor(rStyleSettings.GetFieldColor());
+ }
+ }
+
+
+ bool EditBrowseBox::IsCursorMoveAllowed(long nNewRow, sal_uInt16 nNewColId) const
+ {
+ sal_uInt16 nInfo = 0;
+
+ if (GetSelectColumnCount() || (aMouseEvent.Is() && aMouseEvent->GetRow() < 0))
+ nInfo |= COLSELECT;
+ if ((GetSelection() != nullptr && GetSelectRowCount()) ||
+ (aMouseEvent.Is() && aMouseEvent->GetColumnId() == HandleColumnId))
+ nInfo |= ROWSELECT;
+ if (!nInfo && nNewRow != nEditRow)
+ nInfo |= ROWCHANGE;
+ if (!nInfo && nNewColId != nEditCol)
+ nInfo |= COLCHANGE;
+
+ if (nInfo == 0) // nothing happened
+ return true;
+
+ // save the cell content
+ if (IsEditing() && aController->IsModified() && !const_cast<EditBrowseBox *>(this)->SaveModified())
+ {
+ // maybe we're not visible ...
+ EnableAndShow();
+ aController->GetWindow().GrabFocus();
+ return false;
+ }
+
+ EditBrowseBox * pTHIS = const_cast<EditBrowseBox *> (this);
+
+ // save the cell content if
+ // a) a selection is being made
+ // b) the row is changing
+ if (IsModified() && (nInfo & (ROWCHANGE | COLSELECT | ROWSELECT)) &&
+ !pTHIS->SaveRow())
+ {
+ if (nInfo & COLSELECT ||
+ nInfo & ROWSELECT)
+ {
+ // cancel selected
+ pTHIS->SetNoSelection();
+ }
+
+ if (IsEditing())
+ {
+ if (!Controller()->GetWindow().IsVisible())
+ {
+ EnableAndShow();
+ }
+ aController->GetWindow().GrabFocus();
+ }
+ return false;
+ }
+
+ if (nNewRow != nEditRow)
+ {
+ vcl::Window& rWindow = GetDataWindow();
+ if ((nEditRow >= 0) && !(GetBrowserFlags() & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT))
+ {
+ tools::Rectangle aRect = GetFieldRectPixel(nEditRow, 0, false );
+ // status cell should be painted if and only if text is displayed
+ pTHIS->bPaintStatus = ( GetBrowserFlags() & EditBrowseBoxFlags::HANDLE_COLUMN_TEXT ) == EditBrowseBoxFlags::HANDLE_COLUMN_TEXT;
+ rWindow.Invalidate(aRect);
+ pTHIS->bPaintStatus = true;
+ }
+
+ // don't paint during row change
+ rWindow.EnablePaint(false);
+
+ // the last veto chance for derived classes
+ if (!pTHIS->CursorMoving(nNewRow, nNewColId))
+ {
+ pTHIS->InvalidateStatusCell(nEditRow);
+ rWindow.EnablePaint(true);
+ return false;
+ }
+ else
+ {
+ rWindow.EnablePaint(true);
+ return true;
+ }
+ }
+ else
+ return pTHIS->CursorMoving(nNewRow, nNewColId);
+ }
+
+
+ void EditBrowseBox::ColumnMoved(sal_uInt16 nId)
+ {
+ BrowseBox::ColumnMoved(nId);
+ if (IsEditing())
+ {
+ tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
+ CellControllerRef aControllerRef = Controller();
+ ResizeController(aControllerRef, aRect);
+ Controller()->GetWindow().GrabFocus();
+ }
+ }
+
+
+ bool EditBrowseBox::SaveRow()
+ {
+ return true;
+ }
+
+
+ bool EditBrowseBox::CursorMoving(long, sal_uInt16)
+ {
+ DeactivateCell(false);
+ return true;
+ }
+
+
+ void EditBrowseBox::CursorMoved()
+ {
+ long nNewRow = GetCurRow();
+ if (nEditRow != nNewRow)
+ {
+ if (!(GetBrowserFlags() & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT))
+ InvalidateStatusCell(nNewRow);
+ nEditRow = nNewRow;
+ }
+ ActivateCell();
+ GetDataWindow().EnablePaint(true);
+ // should not be called here because the descant event is not needed here
+ //BrowseBox::CursorMoved();
+ }
+
+
+ void EditBrowseBox::EndScroll()
+ {
+ if (IsEditing())
+ {
+ tools::Rectangle aRect = GetCellRect(nEditRow, nEditCol, false);
+ ResizeController(aController,aRect);
+ AsynchGetFocus();
+ }
+ BrowseBox::EndScroll();
+ }
+
+
+ void EditBrowseBox::ActivateCell(long nRow, sal_uInt16 nCol, bool bCellFocus)
+ {
+ if (IsEditing())
+ return;
+
+ nEditCol = nCol;
+
+ if ((GetSelectRowCount() && GetSelection() != nullptr) || GetSelectColumnCount() ||
+ (aMouseEvent.Is() && (aMouseEvent.IsDown() || aMouseEvent->GetClicks() > 1))) // nothing happens on MouseDown
+ {
+ return;
+ }
+
+ if (!(nEditRow >= 0 && nEditCol > HandleColumnId))
+ return;
+
+ aController = GetController(nRow, nCol);
+ if (aController.is())
+ {
+ tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
+ ResizeController(aController, aRect);
+
+ InitController(aController, nEditRow, nEditCol);
+
+ aController->ClearModified();
+ aController->SetModifyHdl(LINK(this,EditBrowseBox,ModifyHdl));
+ EnableAndShow();
+
+ if ( isAccessibleAlive() )
+ implCreateActiveAccessible();
+
+ // activate the cell only of the browser has the focus
+ if ( bHasFocus && bCellFocus )
+ AsynchGetFocus();
+ }
+ else
+ {
+ // no controller -> we have a new "active descendant"
+ if ( isAccessibleAlive() && HasFocus() )
+ {
+ commitTableEvent(
+ ACTIVE_DESCENDANT_CHANGED,
+ makeAny( CreateAccessibleCell( nRow, GetColumnPos( nCol -1) ) ),
+ Any()
+ );
+ }
+ }
+ }
+
+
+ void EditBrowseBox::DeactivateCell(bool bUpdate)
+ {
+ if (!IsEditing())
+ return;
+
+ if ( isAccessibleAlive() )
+ {
+ commitBrowseBoxEvent( CHILD, Any(), makeAny( m_aImpl->m_xActiveCell ) );
+ m_aImpl->clearActiveCell();
+ }
+
+ aOldController = aController;
+ aController.clear();
+
+ // reset the modify handler
+ aOldController->SetModifyHdl(Link<LinkParamNone*,void>());
+
+ if (bHasFocus)
+ GrabFocus(); // ensure that we have (and keep) the focus
+
+ aOldController->suspend();
+
+ // update if requested
+ if (bUpdate)
+ PaintImmediately();
+
+ // release the controller (asynchronously)
+ if (nEndEvent)
+ Application::RemoveUserEvent(nEndEvent);
+ nEndEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,EndEditHdl), nullptr, true);
+ }
+
+
+ tools::Rectangle EditBrowseBox::GetCellRect(long nRow, sal_uInt16 nColId, bool bRel) const
+ {
+ tools::Rectangle aRect( GetFieldRectPixel(nRow, nColId, bRel));
+ if ((GetMode() & BrowserMode::CURSOR_WO_FOCUS) == BrowserMode::CURSOR_WO_FOCUS)
+ {
+ aRect.AdjustTop(1 );
+ aRect.AdjustBottom( -1 );
+ }
+ return aRect;
+ }
+
+
+ IMPL_LINK_NOARG(EditBrowseBox, EndEditHdl, void*, void)
+ {
+ nEndEvent = nullptr;
+
+ aOldController = CellControllerRef();
+ }
+
+
+ IMPL_LINK_NOARG(EditBrowseBox, ModifyHdl, LinkParamNone*, void)
+ {
+ if (nCellModifiedEvent)
+ Application::RemoveUserEvent(nCellModifiedEvent);
+ nCellModifiedEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,CellModifiedHdl), nullptr, true);
+ }
+
+
+ IMPL_LINK_NOARG(EditBrowseBox, CellModifiedHdl, void*, void)
+ {
+ nCellModifiedEvent = nullptr;
+ CellModified();
+ }
+
+
+ void EditBrowseBox::ColumnResized( sal_uInt16 )
+ {
+ if (IsEditing())
+ {
+ tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
+ CellControllerRef aControllerRef = Controller();
+ ResizeController(aControllerRef, aRect);
+ Controller()->GetWindow().GrabFocus();
+ }
+ }
+
+
+ sal_uInt16 EditBrowseBox::AppendColumn(const OUString& rName, sal_uInt16 nWidth, sal_uInt16 nPos, sal_uInt16 nId)
+ {
+ if (nId == BROWSER_INVALIDID)
+ {
+ // look for the next free id
+ for (nId = ColCount(); nId > 0 && GetColumnPos(nId) != BROWSER_INVALIDID; nId--)
+ ;
+
+ if (!nId)
+ {
+ // if there is no handle column
+ // increment the id
+ if ( ColCount() == 0 || GetColumnId(0) != HandleColumnId )
+ nId = ColCount() + 1;
+ }
+ }
+
+ DBG_ASSERT(nId, "EditBrowseBox::AppendColumn: invalid id!");
+
+ long w = nWidth;
+ if (!w)
+ w = GetDefaultColumnWidth(rName);
+
+ InsertDataColumn(nId, rName, w, (HeaderBarItemBits::CENTER | HeaderBarItemBits::CLICKABLE), nPos);
+ return nId;
+ }
+
+ void EditBrowseBox::Resize()
+ {
+ BrowseBox::Resize();
+
+ // if the window is smaller than "title line height" + "control area",
+ // do nothing
+ if (GetOutputSizePixel().Height() <
+ (GetControlArea().GetHeight() + GetDataWindow().GetPosPixel().Y()))
+ return;
+
+ // the size of the control area
+ Point aPoint(GetControlArea().TopLeft());
+ sal_uInt16 nX = static_cast<sal_uInt16>(aPoint.X());
+
+ ArrangeControls(nX, static_cast<sal_uInt16>(aPoint.Y()));
+
+ if (!nX)
+ nX = USHRT_MAX;
+
+ bool bChanged = ReserveControlArea(nX);
+
+ //tdf#97731 if the reserved area changed size, give the controls a
+ //chance to adapt to the new size
+ if (bChanged)
+ {
+ nX = static_cast<sal_uInt16>(aPoint.X());
+ ArrangeControls(nX, static_cast<sal_uInt16>(aPoint.Y()));
+ }
+ }
+
+ void EditBrowseBox::ArrangeControls(sal_uInt16&, sal_uInt16)
+ {
+ }
+
+ CellController* EditBrowseBox::GetController(long, sal_uInt16)
+ {
+ return nullptr;
+ }
+
+ void EditBrowseBox::ResizeController(CellControllerRef const & rController, const tools::Rectangle& rRect)
+ {
+ Point aPoint(rRect.TopLeft());
+ Size aSize(rRect.GetSize());
+ Control& rControl = rController->GetWindow();
+ auto nMinHeight = rControl.get_preferred_size().Height();
+ if (nMinHeight > aSize.Height())
+ {
+ auto nOffset = (nMinHeight - aSize.Height()) / 2;
+ aPoint.AdjustY(-nOffset);
+ aSize.setHeight(nMinHeight);
+ }
+ rControl.SetPosSizePixel(aPoint, aSize);
+ }
+
+ void EditBrowseBox::InitController(CellControllerRef&, long, sal_uInt16)
+ {
+ }
+
+
+ void EditBrowseBox::CellModified()
+ {
+ }
+
+
+ bool EditBrowseBox::SaveModified()
+ {
+ return true;
+ }
+
+
+ void EditBrowseBox::DoubleClick(const BrowserMouseEvent& rEvt)
+ {
+ // when double clicking on the column, the optimum size will be calculated
+ sal_uInt16 nColId = rEvt.GetColumnId();
+ if (nColId != HandleColumnId)
+ SetColumnWidth(nColId, GetAutoColumnWidth(nColId));
+ }
+
+
+ sal_uInt32 EditBrowseBox::GetAutoColumnWidth(sal_uInt16 nColId)
+ {
+ sal_uInt32 nCurColWidth = GetColumnWidth(nColId);
+ sal_uInt32 nMinColWidth = CalcZoom(20); // minimum
+ sal_uInt32 nNewColWidth = nMinColWidth;
+ long nMaxRows = std::min(long(GetVisibleRows()), GetRowCount());
+ long nLastVisRow = GetTopRow() + nMaxRows - 1;
+
+ if (GetTopRow() <= nLastVisRow) // calc the column with using the cell contents
+ {
+ for (long i = GetTopRow(); i <= nLastVisRow; ++i)
+ nNewColWidth = std::max(nNewColWidth,GetTotalCellWidth(i,nColId) + 12);
+
+ if (nNewColWidth == nCurColWidth) // size has not changed
+ nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
+ }
+ else
+ nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
+ return nNewColWidth;
+ }
+
+
+ sal_uInt32 EditBrowseBox::GetTotalCellWidth(long, sal_uInt16)
+ {
+ return 0;
+ }
+
+
+ void EditBrowseBox::InvalidateHandleColumn()
+ {
+ tools::Rectangle aHdlFieldRect( GetFieldRectPixel( 0, 0 ));
+ tools::Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() );
+ aInvalidRect.SetRight( aHdlFieldRect.Right() );
+ Invalidate( aInvalidRect );
+ }
+
+
+ void EditBrowseBox::PaintTristate(const tools::Rectangle& rRect, const TriState& eState, bool _bEnabled) const
+ {
+ pCheckBoxPaint->GetBox().SetState(eState);
+ pCheckBoxPaint->SetPosSizePixel(rRect.TopLeft(), rRect.GetSize());
+
+ pCheckBoxPaint->GetBox().Enable(_bEnabled);
+ pCheckBoxPaint->Show();
+ pCheckBoxPaint->SetParentUpdateMode( false );
+ pCheckBoxPaint->PaintImmediately();
+ pCheckBoxPaint->Hide();
+ pCheckBoxPaint->SetParentUpdateMode( true );
+ }
+
+
+ void EditBrowseBox::AsynchGetFocus()
+ {
+ if (nStartEvent)
+ Application::RemoveUserEvent(nStartEvent);
+
+ m_pFocusWhileRequest = Application::GetFocusWindow();
+ nStartEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,StartEditHdl), nullptr, true);
+ }
+
+
+ void EditBrowseBox::SetBrowserFlags(EditBrowseBoxFlags nFlags)
+ {
+ if (m_nBrowserFlags == nFlags)
+ return;
+
+ bool RowPicturesChanges = ((m_nBrowserFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT) !=
+ (nFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT));
+ m_nBrowserFlags = nFlags;
+
+ if (RowPicturesChanges)
+ InvalidateStatusCell(GetCurRow());
+ }
+
+ inline void EditBrowseBox::EnableAndShow() const
+ {
+ Controller()->resume();
+ }
+
+
+ CellController::CellController(Control* pW)
+ :pWindow( pW )
+ ,bSuspended( true )
+ {
+
+ DBG_ASSERT(pWindow, "CellController::CellController: missing the window!");
+ DBG_ASSERT(!pWindow->IsVisible(), "CellController::CellController: window should not be visible!");
+ }
+
+
+ CellController::~CellController()
+ {
+
+ }
+
+
+ void CellController::suspend( )
+ {
+ DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::suspend: inconsistence!" );
+ if ( !isSuspended( ) )
+ {
+ CommitModifications();
+ GetWindow().Hide( );
+ GetWindow().Disable( );
+ bSuspended = true;
+ }
+ }
+
+
+ void CellController::resume( )
+ {
+ DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::resume: inconsistence!" );
+ if ( isSuspended( ) )
+ {
+ GetWindow().Enable( );
+ GetWindow().Show( );
+ bSuspended = false;
+ }
+ }
+
+
+ void CellController::CommitModifications()
+ {
+ // nothing to do in this base class
+ }
+
+
+ bool CellController::WantMouseEvent() const
+ {
+ return false;
+ }
+
+
+ void CellController::SetModified()
+ {
+ }
+
+
+ bool CellController::MoveAllowed(const KeyEvent&) const
+ {
+ return true;
+ }
+
+} // namespace svt
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/editbrowsebox2.cxx b/svtools/source/brwbox/editbrowsebox2.cxx
new file mode 100644
index 000000000..7c84cf5eb
--- /dev/null
+++ b/svtools/source/brwbox/editbrowsebox2.cxx
@@ -0,0 +1,200 @@
+/* -*- 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 .
+ */
+
+#include <svtools/editbrowsebox.hxx>
+#include <com/sun/star/accessibility/XAccessible.hpp>
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#include "editbrowseboximpl.hxx"
+#include <comphelper/types.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <vcl/accessiblefactory.hxx>
+#include <vcl/svapp.hxx>
+#include <osl/diagnose.h>
+#include <tools/debug.hxx>
+
+namespace svt
+{
+ using namespace com::sun::star::accessibility;
+ using namespace com::sun::star::uno;
+ using namespace ::com::sun::star::accessibility::AccessibleEventId;
+
+
+Reference< XAccessible > EditBrowseBox::CreateAccessibleCheckBoxCell(long _nRow, sal_uInt16 _nColumnPos,const TriState& eState)
+{
+ Reference< XAccessible > xAccessible( GetAccessible() );
+ Reference< XAccessibleContext > xAccContext;
+ if ( xAccessible.is() )
+ xAccContext = xAccessible->getAccessibleContext();
+
+ Reference< XAccessible > xReturn;
+ if ( xAccContext.is() )
+ {
+ xReturn = getAccessibleFactory().createAccessibleCheckBoxCell(
+ xAccContext->getAccessibleChild( ::vcl::BBINDEX_TABLE ),
+ *this,
+ nullptr,
+ _nRow,
+ _nColumnPos,
+ eState,
+ true
+ );
+ }
+ return xReturn;
+}
+
+sal_Int32 EditBrowseBox::GetAccessibleControlCount() const
+{
+ return IsEditing() ? 1 : 0;
+}
+
+void EditBrowseBox::implCreateActiveAccessible( )
+{
+ DBG_ASSERT( IsEditing(), "EditBrowseBox::implCreateActiveAccessible: not to be called if we're not editing currently!" );
+ DBG_ASSERT( !m_aImpl->m_xActiveCell.is(), "EditBrowseBox::implCreateActiveAccessible: not to be called if the old one is still alive!" );
+
+ if ( !(!m_aImpl->m_xActiveCell.is() && IsEditing()) )
+ return;
+
+ Reference< XAccessible > xCont = aController->GetWindow().GetAccessible();
+ Reference< XAccessible > xMy = GetAccessible();
+ if ( !(xMy.is() && xCont.is()) )
+ return;
+
+ m_aImpl->m_xActiveCell = getAccessibleFactory().createEditBrowseBoxTableCellAccess(
+ xMy, // parent accessible
+ xCont, // control accessible
+ VCLUnoHelper::GetInterface( &aController->GetWindow() ), // focus window (for notifications)
+ *this, // the browse box
+ GetCurRow(),
+ GetColumnPos( GetCurColumnId() )
+ );
+
+ commitBrowseBoxEvent( CHILD, makeAny( m_aImpl->m_xActiveCell ), Any() );
+}
+
+
+Reference< XAccessible > EditBrowseBox::CreateAccessibleControl( sal_Int32 _nIndex )
+{
+ DBG_ASSERT( 0 == _nIndex, "EditBrowseBox::CreateAccessibleControl: invalid index!" );
+
+ if ( isAccessibleAlive() )
+ {
+ if ( !m_aImpl->m_xActiveCell.is() )
+ implCreateActiveAccessible();
+ }
+
+ return m_aImpl->m_xActiveCell;
+}
+
+void EditBrowseBoxImpl::clearActiveCell()
+{
+ try
+ {
+ ::comphelper::disposeComponent(m_xActiveCell);
+ }
+ catch(const Exception&)
+ {
+ OSL_FAIL( "EditBrowseBoxImpl::clearActiveCell: caught an exception while disposing the AccessibleCell!" );
+ }
+
+ m_xActiveCell = nullptr;
+}
+
+void EditBrowseBox::GrabTableFocus()
+{
+ if ( aController.is() )
+ aController->GetWindow().GrabFocus();
+}
+
+void EditBrowseBox::DetermineFocus( const GetFocusFlags _nGetFocusFlags )
+{
+ bool bFocus = ControlHasFocus();
+ for (vcl::Window* pWindow = Application::GetFocusWindow();
+ pWindow && !bFocus;
+ pWindow = pWindow->GetParent())
+ bFocus = pWindow == this;
+
+ if (bFocus == bHasFocus)
+ return;
+
+ bHasFocus = bFocus;
+
+ if ( !(GetBrowserFlags( ) & EditBrowseBoxFlags::SMART_TAB_TRAVEL) )
+ return;
+
+ if ( !(bHasFocus // we got the focus
+ && ( _nGetFocusFlags & GetFocusFlags::Tab )) // using the TAB key
+ )
+ return;
+
+ long nRows = GetRowCount();
+ sal_uInt16 nCols = ColCount();
+
+ if ( ( nRows > 0 ) && ( nCols > 0 ) )
+ {
+ if ( _nGetFocusFlags & GetFocusFlags::Forward )
+ {
+ if ( GetColumnId( 0 ) != HandleColumnId )
+ {
+ GoToRowColumnId( 0, GetColumnId( 0 ) );
+ }
+ else
+ { // the first column is the handle column -> not focussable
+ if ( nCols > 1 )
+ GoToRowColumnId( 0, GetColumnId( 1 ) );
+ }
+ }
+ else if ( _nGetFocusFlags & GetFocusFlags::Backward )
+ {
+ GoToRowColumnId( nRows - 1, GetColumnId( nCols -1 ) );
+ }
+ }
+}
+
+tools::Rectangle EditBrowseBox::GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 _nIndex)
+{
+ tools::Rectangle aRect;
+ if ( SeekRow(_nRow) )
+ {
+ CellController* pController = GetController(
+ _nRow, GetColumnId( sal::static_int_cast< sal_uInt16 >(_nColumnPos) ) );
+ if ( pController )
+ aRect = pController->GetWindow().GetCharacterBounds(_nIndex);
+ }
+ return aRect;
+}
+
+sal_Int32 EditBrowseBox::GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint)
+{
+ sal_Int32 nRet = -1;
+ if ( SeekRow(_nRow) )
+ {
+ CellController* pController = GetController(
+ _nRow, GetColumnId( sal::static_int_cast< sal_uInt16 >(_nColumnPos) ) );
+ if ( pController )
+ nRet = pController->GetWindow().GetIndexForPoint(_rPoint);
+ }
+ return nRet;
+}
+
+
+} // namespace svt
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svtools/source/brwbox/editbrowseboximpl.hxx b/svtools/source/brwbox/editbrowseboximpl.hxx
new file mode 100644
index 000000000..f71aab9b7
--- /dev/null
+++ b/svtools/source/brwbox/editbrowseboximpl.hxx
@@ -0,0 +1,35 @@
+/* -*- 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 <com/sun/star/accessibility/XAccessible.hpp>
+
+namespace svt
+{
+ // impl class for the class EditBrowseBox
+ class EditBrowseBoxImpl
+ {
+ public:
+ css::uno::Reference< css::accessibility::XAccessible > m_xActiveCell;
+
+ void clearActiveCell();
+ };
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-11 10:50:58 +0000