strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/include/vcl/treelistbox.hxx
Noel Grandin 72a67f1158 loplugin:unusedmethods 
Change-Id: I5fa2bbeff17a9933ff55afb0c3544d025d096a63
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/100085
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2020-08-04 17:44:21 +02:00

737 lines
31 KiB
C++
Raw Blame History

/* -*- 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 .
*/
#ifndef INCLUDED_VCL_TREELISTBOX_HXX
#define INCLUDED_VCL_TREELISTBOX_HXX
#include <vcl/dllapi.h>
#include <deque>
#include <memory>
#include <vector>
#include <vcl/ctrl.hxx>
#include <vcl/mnemonicengine.hxx>
#include <vcl/quickselectionengine.hxx>
#include <vcl/image.hxx>
#include <tools/gen.hxx>
#include <tools/contnr.hxx>
#include <vcl/treelist.hxx>
#include <vcl/transfer.hxx>
#include <vcl/menu.hxx>
#include <o3tl/typed_flags_set.hxx>
class SvTreeListBox;
class SvTreeListEntry;
struct SvViewDataItem;
class SvViewDataEntry;
class SvInplaceEdit2;
class SvLBoxString;
class SvImpLBox;
class SvLBoxButtonData;
class Timer;
class Edit;
namespace utl {
class AccessibleStateSetHelper;
}
enum class SvButtonState { Unchecked, Checked, Tristate };
// *********************************************************************
// *************************** Tabulators ******************************
// *********************************************************************
enum class SvLBoxTabFlags
{
NONE = 0x0000,
DYNAMIC = 0x0001, // Item's output column changes according to the Child Depth
ADJUST_RIGHT = 0x0002, // Item's right margin at the tabulator
ADJUST_LEFT = 0x0004, // Left margin
ADJUST_CENTER = 0x0008, // Center the item at the tabulator
SHOW_SELECTION = 0x0010, // Visualize selection state
// Item needs to be able to return the surrounding polygon (D'n'D cursor)
EDITABLE = 0x0020, // Item editable at the tabulator
FORCE = 0x0040, // Switch off the default calculation of the first tabulator
// (on which Abo Tabpage/Extras/Option/Customize, etc. rely on)
// The first tab's position corresponds precisely to the Flags set
// and column widths
};
namespace o3tl
{
template<> struct typed_flags<SvLBoxTabFlags> : is_typed_flags<SvLBoxTabFlags, 0x007f> {};
}
#define SV_TAB_BORDER 8
#define SV_ENTRYHEIGHTOFFS_PIXEL 2
enum class SvTreeFlags
{
CHKBTN = 0x01,
USESEL = 0x02,
MANINS = 0x04,
RECALCTABS = 0x08,
FIXEDHEIGHT = 0x10,
};
namespace o3tl
{
template<> struct typed_flags<SvTreeFlags> : is_typed_flags<SvTreeFlags, 0x1f> {};
}
enum class SvLBoxItemType {String, Button, ContextBmp};
class SvLBoxTab
{
long nPos;
public:
SvLBoxTab();
SvLBoxTab( long nPos, SvLBoxTabFlags nFlags );
SvLBoxTab( const SvLBoxTab& );
~SvLBoxTab();
SvLBoxTabFlags nFlags;
bool IsDynamic() const { return bool(nFlags & SvLBoxTabFlags::DYNAMIC); }
void SetPos( long nNewPos) { nPos = nNewPos; }
long GetPos() const { return nPos; }
long CalcOffset( long nItemLength, long nTabWidth );
bool IsEditable() const { return bool(nFlags & SvLBoxTabFlags::EDITABLE); }
};
class VCL_DLLPUBLIC SvLBoxItem
{
protected:
bool mbDisabled;
public:
SvLBoxItem();
virtual ~SvLBoxItem();
virtual SvLBoxItemType GetType() const = 0;
virtual int CalcWidth(const SvTreeListBox* pView) const;
int GetWidth(const SvTreeListBox* pView, const SvTreeListEntry* pEntry) const;
int GetWidth(const SvTreeListBox* pView, const SvViewDataEntry* pData, sal_uInt16 nItemPos);
int GetHeight(const SvTreeListBox* pView, const SvTreeListEntry* pEntry) const;
static int GetHeight(const SvViewDataEntry* pData, sal_uInt16 nItemPos);
void Enable(bool bEnabled) { mbDisabled = !bEnabled; }
virtual void Paint(const Point& rPos, SvTreeListBox& rOutDev, vcl::RenderContext& rRenderContext, const SvViewDataEntry* pView, const SvTreeListEntry& rEntry) = 0;
virtual void InitViewData(SvTreeListBox* pView, SvTreeListEntry* pEntry,
// If != 0: this Pointer must be used!
// If == 0: it needs to be retrieved via the View
SvViewDataItem* pViewData = nullptr) = 0;
// View-dependent data is not cloned
virtual std::unique_ptr<SvLBoxItem> Clone(SvLBoxItem const * pSource) const = 0;
};
enum class DragDropMode
{
NONE = 0x0000,
CTRL_MOVE = 0x0001,
APP_COPY = 0x0004,
// Entries may be dropped via the uppermost Entry
// The DropTarget is 0 in that case
ENABLE_TOP = 0x0010,
ALL = 0x0015,
};
namespace o3tl
{
template<> struct typed_flags<DragDropMode> : is_typed_flags<DragDropMode, 0x0015> {};
}
enum class SvTreeListBoxFlags
{
NONE = 0x0000,
IN_EDT = 0x0001,
EDT_ENABLED = 0x0002,
TARGEMPH_VIS = 0x0004,
EDTEND_CALLED = 0x0008,
};
namespace o3tl
{
template<> struct typed_flags<SvTreeListBoxFlags> : is_typed_flags<SvTreeListBoxFlags, 0x000f> {};
}
struct SvTreeListBoxImpl;
typedef std::pair<vcl::RenderContext&, const SvTreeListEntry&> svtree_measure_args;
typedef std::tuple<vcl::RenderContext&, const tools::Rectangle&, const SvTreeListEntry&> svtree_render_args;
class VCL_DLLPUBLIC SvTreeListBox
:public Control
,public SvListView
,public DropTargetHelper
,public DragSourceHelper
,public vcl::IMnemonicEntryList
,public vcl::ISearchableStringList
{
friend class SvImpLBox;
friend class SvLBoxString;
friend class IconViewImpl;
friend class TreeControlPeer;
friend class SalInstanceIconView;
friend class SalInstanceTreeView;
friend class SalInstanceEntryTreeView;
std::unique_ptr<SvTreeListBoxImpl> mpImpl;
Link<SvTreeListBox*,void> aScrolledHdl;
Link<SvTreeListBox*,void> aExpandedHdl;
Link<SvTreeListBox*,bool> aExpandingHdl;
Link<SvTreeListBox*,void> aSelectHdl;
Link<SvTreeListBox*,void> aDeselectHdl;
Link<const CommandEvent&, bool> aPopupMenuHdl;
Link<const HelpEvent&, bool> aTooltipHdl;
Link<svtree_render_args, void> aCustomRenderHdl;
Link<svtree_measure_args, Size> aCustomMeasureHdl;
Image aPrevInsertedExpBmp;
Image aPrevInsertedColBmp;
Image aCurInsertedExpBmp;
Image aCurInsertedColBmp;
short nContextBmpWidthMax;
short nEntryHeightOffs;
short nIndent;
short nFocusWidth;
sal_uInt16 nFirstSelTab;
sal_uInt16 nLastSelTab;
long mnCheckboxItemWidth;
bool mbContextBmpExpanded;
bool mbAlternatingRowColors;
bool mbUpdateAlternatingRows;
bool mbQuickSearch; // Enables type-ahead search in the check list box.
bool mbActivateOnSingleClick; // Make single click "activate" a row like a double-click normally does
bool mbHoverSelection; // Make mouse over a row "select" a row like a single-click normally does
SvTreeListEntry* pHdlEntry;
DragDropMode nDragDropMode;
DragDropMode nOldDragMode;
SelectionMode eSelMode;
sal_Int32 nMinWidthInChars;
sal_Int8 mnDragAction;
SvTreeListEntry* pEdEntry;
SvLBoxItem* pEdItem;
rtl::Reference<TransferDataContainer> m_xTransferHelper;
protected:
std::unique_ptr<SvImpLBox> pImpl;
short nColumns;
short nEntryHeight;
short nEntryWidth;
bool mbCenterAndClipText;
Link<SvTreeListBox*,bool> aDoubleClickHdl;
SvTreeListEntry* pTargetEntry;
SvLBoxButtonData* pCheckButtonData;
std::vector<std::unique_ptr<SvLBoxTab>> aTabs;
SvTreeFlags nTreeFlags;
SvTreeListBoxFlags nImpFlags;
// Move/CopySelection: Position of the current Entry in SelectionList
sal_uInt16 nCurEntrySelPos;
private:
DECL_DLLPRIVATE_LINK( CheckButtonClick, SvLBoxButtonData *, void );
DECL_DLLPRIVATE_LINK( TextEditEndedHdl_Impl, SvInplaceEdit2&, void );
// Handler that is called by TreeList to clone an Entry
DECL_DLLPRIVATE_LINK( CloneHdl_Impl, SvTreeListEntry*, SvTreeListEntry* );
// Handler and methods for Drag - finished handler.
// The Handle retrieved by GetDragFinishedHdl can be set on the
// TransferDataContainer. This link is a callback for the DragFinished
// call. The AddBox method is called from the GetDragFinishedHdl() and the
// remove is called in the link callback and in the dtor. So it can't be
// called for a deleted object.
VCL_DLLPRIVATE static void AddBoxToDDList_Impl( const SvTreeListBox& rB );
VCL_DLLPRIVATE static void RemoveBoxFromDDList_Impl( const SvTreeListBox& rB );
DECL_DLLPRIVATE_LINK( DragFinishHdl_Impl, sal_Int8, void );
// after a checkbox entry is inserted, use this to get its width to support
// autowidth for the 1st checkbox column
VCL_DLLPRIVATE void CheckBoxInserted(SvTreeListEntry* pEntry);
VCL_DLLPRIVATE void DrawCustomEntry(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect, const SvTreeListEntry& rEntry);
VCL_DLLPRIVATE Size MeasureCustomEntry(vcl::RenderContext& rRenderContext, const SvTreeListEntry& rEntry);
void UnsetDropTarget();
protected:
bool CheckDragAndDropMode( SvTreeListBox const * pSource, sal_Int8 );
void ImplShowTargetEmphasis( SvTreeListEntry* pEntry, bool bShow);
void EnableSelectionAsDropTarget( bool bEnable = true );
// Standard impl returns 0; derived classes which support D'n'D must override
using Window::GetDropTarget;
virtual SvTreeListEntry* GetDropTarget( const Point& );
// Invalidate children on enable/disable
virtual void StateChanged( StateChangedType eType ) override;
virtual sal_uLong Insert( SvTreeListEntry* pEnt,SvTreeListEntry* pPar,sal_uLong nPos=TREELIST_APPEND);
virtual sal_uLong Insert( SvTreeListEntry* pEntry,sal_uLong nRootPos = TREELIST_APPEND );
// In-place editing
std::unique_ptr<SvInplaceEdit2> pEdCtrl;
void EditText( const OUString&, const tools::Rectangle&,const Selection&);
void CancelTextEditing();
// InitViewData is called right after CreateViewData
// The Entry is has not yet been added to the View in InitViewData!
virtual void InitViewData( SvViewDataEntry*, SvTreeListEntry* pEntry ) override;
// Calls InitViewData for all Items
void RecalcViewData();
// Handler and methods for Drag - finished handler. This link can be set
// to the TransferDataContainer. The AddBox/RemoveBox methods must be
// called before the StartDrag call.
// The Remove will be called from the handler, which then calls DragFinish.
// The Remove is also called in the DTOR of the SvTreeListBox -
// so it can't be called for a deleted object.
Link<sal_Int8,void> GetDragFinishedHdl() const;
// For asynchronous D'n'D
sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, SvTreeListBox* pSourceView );
void OnCurrentEntryChanged();
// IMnemonicEntryList
virtual const void* FirstSearchEntry( OUString& _rEntryText ) const override;
virtual const void* NextSearchEntry( const void* _pCurrentSearchEntry, OUString& _rEntryText ) const override;
virtual void SelectSearchEntry( const void* _pEntry ) override;
virtual void ExecuteSearchEntry( const void* _pEntry ) const override;
// ISearchableStringList
virtual vcl::StringEntryIdentifier CurrentEntry( OUString& _out_entryText ) const override;
virtual vcl::StringEntryIdentifier NextEntry( vcl::StringEntryIdentifier _currentEntry, OUString& _out_entryText ) const override;
virtual void SelectEntry( vcl::StringEntryIdentifier _entry ) override;
public:
SvTreeListBox( vcl::Window* pParent, WinBits nWinStyle=0 );
virtual ~SvTreeListBox() override;
virtual void dispose() override;
SvTreeList* GetModel() const
{
return pModel.get();
}
sal_uLong GetEntryCount() const
{
return pModel ? pModel->GetEntryCount() : 0;
}
SvTreeListEntry* First() const
{
return pModel ? pModel->First() : nullptr;
}
SvTreeListEntry* Next( SvTreeListEntry* pEntry ) const
{
return pModel->Next(pEntry);
}
SvTreeListEntry* Prev( SvTreeListEntry* pEntry ) const
{
return pModel->Prev(pEntry);
}
SvTreeListEntry* Last() const
{
return pModel ? pModel->Last() : nullptr;
}
SvTreeListEntry* FirstChild( SvTreeListEntry* pParent ) const;
bool CopySelection( SvTreeListBox* pSource, SvTreeListEntry* pTarget );
bool MoveSelectionCopyFallbackPossible( SvTreeListBox* pSource, SvTreeListEntry* pTarget, bool bAllowCopyFallback );
void RemoveSelection();
/**
* Removes the entry along with all of its descendants
*/
void RemoveEntry(SvTreeListEntry const * pEntry);
DragDropMode GetDragDropMode() const { return nDragDropMode; }
SelectionMode GetSelectionMode() const { return eSelMode; }
// pParent == 0 -> Root level
SvTreeListEntry* GetEntry( SvTreeListEntry* pParent, sal_uLong nPos ) const;
SvTreeListEntry* GetEntry( sal_uLong nRootPos ) const;
SvTreeListEntry* GetEntryFromPath( const ::std::deque< sal_Int32 >& _rPath ) const;
void FillEntryPath( SvTreeListEntry* pEntry, ::std::deque< sal_Int32 >& _rPath ) const;
using Window::GetParent;
SvTreeListEntry* GetParent( SvTreeListEntry* pEntry ) const;
SvTreeListEntry* GetRootLevelParent(SvTreeListEntry* pEntry ) const;
using Window::GetChildCount;
sal_uLong GetChildCount( SvTreeListEntry const * pParent ) const;
sal_uLong GetLevelChildCount( SvTreeListEntry* pParent ) const;
SvViewDataEntry* GetViewDataEntry( SvTreeListEntry const * pEntry ) const;
SvViewDataItem* GetViewDataItem(SvTreeListEntry const *, SvLBoxItem const *);
const SvViewDataItem* GetViewDataItem(const SvTreeListEntry*, const SvLBoxItem*) const;
bool IsInplaceEditingEnabled() const { return bool(nImpFlags & SvTreeListBoxFlags::EDT_ENABLED); }
bool IsEditingActive() const { return bool(nImpFlags & SvTreeListBoxFlags::IN_EDT); }
void EndEditing( bool bCancel = false );
void Clear();
/** Enables or disables mnemonic characters in the entry texts.
If mnemonics are enabled, then entries are selected and made current when
there mnemonic character is pressed. If there are multiple entries with the
same mnemonic, the selection cycles between them.
Entries with a collapsed ancestor are not included in the calculation of
mnemonics. That is, if you press the accelerator key of an invisible
entry, then this entry is *not* selected.
Be aware that enabling mnemonics gets more expensive as you add to the list.
*/
void EnableEntryMnemonics();
bool IsEntryMnemonicsEnabled() const;
bool TextCenterAndClipEnabled() const { return mbCenterAndClipText; }
/** Handles the given key event.
At the moment this merely checks for accelerator keys, if entry mnemonics
are enabled.
This method may come in handy if you want to use keyboard acceleration
while the control does not have the focus.
If the key event describes the pressing of a shortcut for an entry,
then SelectSearchEntry resp. ExecuteSearchEntry are called.
@see IMnemonicEntryList
@see MnemonicEngine
@return
<TRUE/> if the event has been consumed, <FALSE/> otherwise.
*/
bool HandleKeyInput( const KeyEvent& rKEvt );
void SetSelectHdl( const Link<SvTreeListBox*,void>& rNewHdl ) {aSelectHdl=rNewHdl; }
void SetDeselectHdl( const Link<SvTreeListBox*,void>& rNewHdl ) {aDeselectHdl=rNewHdl; }
void SetDoubleClickHdl(const Link<SvTreeListBox*,bool>& rNewHdl) {aDoubleClickHdl=rNewHdl;}
void SetExpandingHdl(const Link<SvTreeListBox*,bool>& rNewHdl){aExpandingHdl=rNewHdl;}
void SetExpandedHdl(const Link<SvTreeListBox*,void>& rNewHdl){aExpandedHdl=rNewHdl;}
void SetPopupMenuHdl(const Link<const CommandEvent&, bool>& rLink) { aPopupMenuHdl = rLink; }
void SetTooltipHdl(const Link<const HelpEvent&, bool>& rLink) { aTooltipHdl = rLink; }
void SetCustomRenderHdl(const Link<svtree_render_args, void>& rLink) { aCustomRenderHdl = rLink; }
void SetCustomMeasureHdl(const Link<svtree_measure_args, Size>& rLink) { aCustomMeasureHdl = rLink; }
void ExpandedHdl();
bool ExpandingHdl();
virtual void SelectHdl();
virtual void DeselectHdl();
virtual bool DoubleClickHdl();
SvTreeListEntry* GetHdlEntry() const { return pHdlEntry; }
// Is called for an Entry that gets expanded with the Flag
// ENTRYFLAG_CHILDREN_ON_DEMAND set.
virtual void RequestingChildren( SvTreeListEntry* pParent );
// Drag & Drop
// New D'n'D API
virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override;
virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override;
virtual void StartDrag( sal_Int8 nAction, const Point& rPosPixel ) override;
virtual DragDropMode NotifyStartDrag( TransferDataContainer& rData,
SvTreeListEntry* );
virtual void DragFinished( sal_Int8 nDropAction );
SvTreeListEntry* CloneEntry( SvTreeListEntry* pSource );
// Return value: TRISTATE_TRUE == Ok, TRISTATE_FALSE == Cancel, TRISTATE_INDET == Ok and Make visible moved entry
TriState NotifyMoving(
SvTreeListEntry* pTarget, // D'n'D DropPosition in GetModel()
SvTreeListEntry* pEntry, // Entry to be moved from GetSourceListBox()->GetModel()
SvTreeListEntry*& rpNewParent, // New TargetParent
sal_uLong& rNewChildPos); // The TargetParent's position in Childlist
// Return value: TRISTATE_TRUE == Ok, TRISTATE_FALSE == Cancel, TRISTATE_INDET == Ok and Make visible moved entry
TriState NotifyCopying(
SvTreeListEntry* pTarget, // D'n'D DropPosition in GetModel()
SvTreeListEntry* pEntry, // Entry to be copied from GetSourceListBox()->GetModel()
SvTreeListEntry*& rpNewParent, // New TargetParent
sal_uLong& rNewChildPos); // The TargetParent's position in Childlist
// ACCESSIBILITY ==========================================================
/** Creates and returns the accessible object of the Box. */
virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override;
/** Fills the StateSet of one entry. */
void FillAccessibleEntryStateSet( SvTreeListEntry* pEntry, ::utl::AccessibleStateSetHelper& rStateSet ) const;
/** Calculate and return the bounding rectangle of an entry.
@param pEntry
The entry.
@return The bounding rectangle of an entry. */
tools::Rectangle GetBoundingRect(const SvTreeListEntry* pEntry);
SvTreeFlags GetTreeFlags() const {return nTreeFlags;}
static OUString SearchEntryTextWithHeadTitle(SvTreeListEntry* pEntry);
void set_min_width_in_chars(sal_Int32 nChars);
virtual bool set_property(const OString &rKey, const OUString &rValue) override;
protected:
VCL_DLLPRIVATE void SetEntryHeight( SvTreeListEntry const * pEntry );
void AdjustEntryHeight( const Image& rBmp );
VCL_DLLPRIVATE void AdjustEntryHeight();
VCL_DLLPRIVATE void ImpEntryInserted( SvTreeListEntry* pEntry );
VCL_DLLPRIVATE void PaintEntry1( SvTreeListEntry&, long nLine, vcl::RenderContext& rRenderContext );
VCL_DLLPRIVATE void InitTreeView();
VCL_DLLPRIVATE SvLBoxItem* GetItem_Impl( SvTreeListEntry*, long nX, SvLBoxTab** ppTab );
VCL_DLLPRIVATE void ImplInitStyle();
void SetupDragOrigin();
void EditItemText( SvTreeListEntry* pEntry, SvLBoxString* pItem,
const Selection& );
void EditedText(const OUString&);
// Recalculate all tabs depending on TreeListStyle and Bitmap sizes
// Is called automatically when inserting/changing Bitmaps, changing the Model etc.
virtual void SetTabs();
void AddTab( long nPos, SvLBoxTabFlags nFlags );
sal_uInt16 TabCount() const { return aTabs.size(); }
SvLBoxTab* GetFirstDynamicTab() const;
SvLBoxTab* GetFirstDynamicTab( sal_uInt16& rTabPos ) const;
SvLBoxTab* GetFirstTab( SvLBoxTabFlags nFlagMask, sal_uInt16& rTabPos );
void GetLastTab( SvLBoxTabFlags nFlagMask, sal_uInt16& rTabPos );
SvLBoxTab* GetTab( SvTreeListEntry const *, SvLBoxItem const * ) const;
void ClearTabList();
virtual void InitEntry(SvTreeListEntry*, const OUString&, const Image&, const Image&);
virtual void NotifyEndScroll();
virtual void NotifyScrolled();
void SetScrolledHdl( const Link<SvTreeListBox*,void>& rLink ) { aScrolledHdl = rLink; }
long GetXOffset() const { return GetMapMode().GetOrigin().X(); }
virtual void Command( const CommandEvent& rCEvt ) override;
virtual void RequestHelp( const HelpEvent& rHEvt ) override;
virtual void PreparePaint(vcl::RenderContext& rRenderContext, SvTreeListEntry& rEntry);
virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
void InitSettings();
virtual void ApplySettings(vcl::RenderContext& rRenderContext) override;
void CallImplEventListeners(VclEventId nEvent, void* pData);
void ImplEditEntry( SvTreeListEntry* pEntry );
void AdjustEntryHeightAndRecalc();
// true if rPos is over the SvTreeListBox body, i.e. not over a
// scrollbar
VCL_DLLPRIVATE bool PosOverBody(const Point& rPos) const;
public:
void SetNoAutoCurEntry( bool b );
void EnableCheckButton( SvLBoxButtonData* );
void SetCheckButtonData( SvLBoxButtonData* );
void SetNodeBitmaps( const Image& rCollapsedNodeBmp, const Image& rExpandedNodeBmp );
/** Returns the default image which clients should use for expanded nodes, to have a consistent user
interface experience in the whole product.
*/
static const Image& GetDefaultExpandedNodeImage( );
/** Returns the default image which clients should use for expanded nodes, to have a consistent user
interface experience in the whole product.
*/
static const Image& GetDefaultCollapsedNodeImage( );
/** Sets default bitmaps for collapsed and expanded nodes.
*/
void SetNodeDefaultImages( )
{
SetNodeBitmaps(
GetDefaultCollapsedNodeImage( ),
GetDefaultExpandedNodeImage( )
);
}
virtual SvTreeListEntry* InsertEntry( const OUString& rText, SvTreeListEntry* pParent = nullptr,
bool bChildrenOnDemand = false,
sal_uLong nPos=TREELIST_APPEND, void* pUserData = nullptr);
virtual SvTreeListEntry* InsertEntry( const OUString& rText,
const Image& rExpandedEntryBmp,
const Image& rCollapsedEntryBmp,
SvTreeListEntry* pParent = nullptr,
bool bChildrenOnDemand = false,
sal_uLong nPos = TREELIST_APPEND, void* pUserData = nullptr );
const Image& GetDefaultExpandedEntryBmp( ) const;
const Image& GetDefaultCollapsedEntryBmp( ) const;
void SetDefaultExpandedEntryBmp( const Image& rBmp );
void SetDefaultCollapsedEntryBmp( const Image& rBmp );
void SetCheckButtonState( SvTreeListEntry*, SvButtonState );
SvButtonState GetCheckButtonState( SvTreeListEntry* ) const;
void SetEntryText(SvTreeListEntry*, const OUString& );
void SetExpandedEntryBmp( SvTreeListEntry* _pEntry, const Image& _rImage );
void SetCollapsedEntryBmp( SvTreeListEntry* _pEntry, const Image& _rImage );
virtual OUString GetEntryText( SvTreeListEntry* pEntry ) const;
static const Image& GetExpandedEntryBmp(const SvTreeListEntry* _pEntry );
static const Image& GetCollapsedEntryBmp(const SvTreeListEntry* _pEntry );
virtual void CheckButtonHdl();
void SetSublistOpenWithLeftRight(); // open/close sublist with cursor left/right
void EnableInplaceEditing( bool bEnable );
// Edits the Entry's first StringItem, 0 == Cursor
void EditEntry( SvTreeListEntry* pEntry );
virtual bool EditingEntry( SvTreeListEntry* pEntry, Selection& );
virtual bool EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText );
virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override;
virtual void MouseButtonDown( const MouseEvent& rMEvt ) override;
virtual void MouseButtonUp( const MouseEvent& rMEvt ) override;
virtual void MouseMove( const MouseEvent& rMEvt ) override;
virtual void KeyInput( const KeyEvent& rKEvt ) override;
virtual void Resize() override;
virtual void GetFocus() override;
virtual void LoseFocus() override;
void SetUpdateMode( bool );
virtual void ModelHasCleared() override;
virtual void ModelHasInserted( SvTreeListEntry* pEntry ) override;
virtual void ModelHasInsertedTree( SvTreeListEntry* pEntry ) override;
virtual void ModelIsMoving(SvTreeListEntry* pSource ) override;
virtual void ModelHasMoved(SvTreeListEntry* pSource ) override;
virtual void ModelIsRemoving( SvTreeListEntry* pEntry ) override;
virtual void ModelHasRemoved( SvTreeListEntry* pEntry ) override;
void ModelHasEntryInvalidated( SvTreeListEntry* pEntry ) override;
void ScrollOutputArea( short nDeltaEntries );
short GetColumnsCount() const { return nColumns; }
short GetEntryHeight() const { return nEntryHeight; }
void SetEntryHeight( short nHeight );
short GetEntryWidth() const { return nEntryWidth; }
void SetEntryWidth( short nWidth );
Size GetOutputSizePixel() const;
short GetIndent() const { return nIndent; }
void SetSpaceBetweenEntries( short nSpace );
Point GetEntryPosition(const SvTreeListEntry*) const;
void MakeVisible( SvTreeListEntry* pEntry );
void MakeVisible( SvTreeListEntry* pEntry, bool bMoveToTop );
void SetCollapsedNodeBmp( const Image& );
void SetExpandedNodeBmp( const Image& );
Image const & GetExpandedNodeBmp( ) const;
void SetFont( const vcl::Font& rFont );
using Window::SetCursor;
void SetCursor( SvTreeListEntry* pEntry, bool bForceNoSelect = false );
SvTreeListEntry* GetEntry( const Point& rPos, bool bHit = false ) const;
virtual tools::Rectangle GetFocusRect(const SvTreeListEntry*, long nLine );
// Respects indentation
sal_IntPtr GetTabPos(const SvTreeListEntry*, SvLBoxTab*);
void InvalidateEntry( SvTreeListEntry* );
SvLBoxItem* GetItem( SvTreeListEntry*, long nX, SvLBoxTab** ppTab);
SvLBoxItem* GetItem( SvTreeListEntry*, long nX );
void SetDragDropMode( DragDropMode );
void SetSelectionMode( SelectionMode );
bool Expand( SvTreeListEntry* pParent );
bool Collapse( SvTreeListEntry* pParent );
virtual bool Select( SvTreeListEntry* pEntry, bool bSelect=true );
sal_uLong SelectChildren( SvTreeListEntry* pParent, bool bSelect );
void SelectAll( bool bSelect );
void SetCurEntry( SvTreeListEntry* _pEntry );
SvTreeListEntry* GetCurEntry() const;
using Window::Invalidate;
virtual void Invalidate( InvalidateFlags nFlags = InvalidateFlags::NONE) override;
virtual void Invalidate( const tools::Rectangle&, InvalidateFlags nFlags = InvalidateFlags::NONE ) override;
void SetHighlightRange(sal_uInt16 nFirstTab=0, sal_uInt16 nLastTab=0xffff);
sal_Int32 DefaultCompare(const SvLBoxString* pLeftText, const SvLBoxString* pRightText);
DECL_LINK( DefaultCompare, const SvSortData&, sal_Int32 );
virtual void ModelNotification( SvListAction nActionId, SvTreeListEntry* pEntry1,
SvTreeListEntry* pEntry2, sal_uLong nPos ) override;
void EndSelection();
SvTreeListEntry* GetFirstEntryInView() const;
SvTreeListEntry* GetNextEntryInView(SvTreeListEntry*) const;
void ScrollToAbsPos( long nPos );
void ShowFocusRect( const SvTreeListEntry* pEntry );
virtual VclPtr<PopupMenu> CreateContextMenu();
void EnableContextMenuHandling();
long getPreferredDimensions(std::vector<long> &rWidths) const;
virtual Size GetOptimalSize() const override;
void SetAlternatingRowColors( const bool bEnable );
// Enables type-ahead search in the check list box.
void SetQuickSearch(bool bEnable) { mbQuickSearch = bEnable; }
// Make single click "activate" a row like a double-click normally does
void SetActivateOnSingleClick(bool bEnable) { mbActivateOnSingleClick = bEnable; }
// Make mouse over a row "select" a row like a single-click normally does
void SetHoverSelection(bool bEnable) { mbHoverSelection = bEnable; }
bool GetHoverSelection() const { return mbHoverSelection; }
void SetForceMakeVisible(bool bEnable);
virtual FactoryFunction GetUITestFactory() const override;
void SetDragHelper(rtl::Reference<TransferDataContainer>& rHelper, sal_uInt8 eDNDConstants);
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink