aTreeWidget.h

Go to the documentation of this file.

/*
 *  File:       aTreeWidget.h
 *  Package:    akWidgets
 *
 *  Created on: March 10, 2020
 *  Author: Alexander Kuester
 *  Copyright (c) 2022 Alexander Kuester
 *  This file is part of the uiCore component.
 *  This file is subject to the terms and conditions defined in
 *  file 'LICENSE', which is part of this source code package.
 */
 
#pragma once
 
 // AK header
#include <akCore/globalDataTypes.h>
#include <akCore/akCore.h>
#include <akWidgets/aWidget.h>
 
// Qt header
#include <qobject.h>                        // Base class
#include <qlayout.h>                        // layout for the VBoxLayout
#include <qicon.h>                          // QIcon
#include <qcolor.h>                         // QColor
#include <qstring.h>                        // QString
#include <qtreewidget.h>                    // base class
 
// C++ header
#include <map>
#include <vector>
#include <list>
 
// Forward declaration
class QTreeWidgetItem;
class QKeyEvent;
class QWidget;
class QMouseEvent;
 
namespace ak {
 
    // Forward declaration
    class aUidManager;
    class aObjectManager;
    class aSignalLinker;
    class aTreeWidget;
    class aTreeWidgetBase;
    class aTreeWidgetItem;
    class aLineEditWidget;
 
    class UICORE_API_EXPORT aTreeWidget : public QObject, public aWidget {
        Q_OBJECT
    public:
        aTreeWidget();
 
        virtual ~aTreeWidget();
 
        virtual QWidget * widget(void) override;
 
        // ###########################################################################################################################################
 
        // Data manipulation
 
        ID add(
            ID                          _parentId = -1,
            const QString &             _text = "",
            textAlignment               _textAlignment = alignLeft,
            QIcon                       _icon = QIcon()
        );
 
        ID add(
            const QString &             _cmd,
            char                        _delimiter = '|',
            textAlignment               _textAlignment = alignLeft,
            const QIcon  &              _icon = QIcon()
        );
 
        void clear(bool _emitEvent = true);
 
        void setItemEnabled(
            ID                          _itemId,
            bool                        _enabled = true
        );
 
        void setIsReadOnly(
            bool                        _readOnly = true
        );
 
        void setItemSelected(
            ID                          _itemId,
            bool                        _selected = true
        );
 
        void setItemVisible(
            ID                          _itemId,
            bool                        _visible
        );
 
        void setItemText(
            ID                          _itemId,
            const QString &             _text
        );
 
        void setSingleItemSelected(
            ID                          _itemId,
            bool                        _selected
        );
 
        void toggleItemSelection(
            ID                          _itemId
        );
 
        void deselectAllItems(
            bool                        _emitEvent
        );
 
        void setEnabled(
            bool                        _enabled = true
        );
 
        void setVisible(
            bool                        _visible = true
        );
 
        void setItemIcon(
            ID                          _itemId,
            const QIcon &               _icon
        );
 
        void setSortingEnabled(
            bool                        _enabled
        );
        
        // ###########################################################################################################################################
 
        // Filter
 
        void setFilterVisible(
            bool                        _visible
        );
 
        void applyCurrentFilter(void);
 
        void setFilterCaseSensitive(
            bool                        _caseSensitive,
            bool                        _refresh = true
        );
 
        void setFilterRefreshOnChange(
            bool                        _refreshOnChange
        );
 
        void setMultiSelectionEnabled(
            bool                        _multiSelection
        );
 
        void setAutoSelectAndDeselectChildrenEnabled(
            bool                        _enabled
        );
 
        void expandAllItems(void);
 
        void expandItem(
            ak::ID          _itemID,
            bool        _expanded
        );
 
        bool isItemExpanded(
            ak::ID          _itemID
        );
 
        void collapseAllItems(void);
 
        void deleteItem(
            ID                          _itemID,
            bool                        _supressSelectionChangedEvent = false
        );
 
        void deleteItems(
            const std::vector<ID> &     _itemIDs,
            bool                        _supressSelectionChangedEvent = false
        );
 
        void setItemsAreEditable(
            bool                        _editable = true,
            bool                        _applyToAll = true
        );
 
        void setItemIsEditable(
            ID                          _itemID,
            bool                        _editable
        );
 
        void setItemIsEditable(
            const std::vector<ID> &     _itemIDs,
            bool                        _editable
        );
 
        void setItemSelectChildren(
            ID                          _itemID,
            bool                        _selectChildren
        );
 
        void setChildItemsVisibleWhenApplyingFilter(bool _visible) { m_displayChildsOnFilter = _visible; }
 
        // ###########################################################################################################################################
 
        // Information gathering
 
        std::vector<ID> selectedItems(void);
 
        std::vector<QString> getItemPath(
            ID                          _itemId
        );
 
        QString getItemPathString(
            ID                          _itemId,
            char                        _delimiter = '|'
        );
 
        ID getItemID(
            const QString &             _itemPath,
            char                        _delimiter = '|'
        );
 
        QString getItemText(
            ID                          _itemId
        );
 
        aTreeWidgetItem * item(ID _itemID);
 
        aTreeWidgetItem* itemFromPath(const QString& _itemPath, char _delimiter = '|');
 
        bool enabled() const;
 
        int itemCount(void) const;
 
        bool isSortingEnabled(void) const;
 
        bool isReadOnly(void) const { return m_isReadOnly; }
 
        bool getAutoSelectAndDeselectChildrenEnabled(void) { return m_selectAndDeselectChildren; }
        bool getMultiSelectionEnabled(void);
 
        aTreeWidgetBase * treeWidget(void) { return m_tree; }
        aLineEditWidget * filterWidget(void) { return m_filter; }
 
        // ###########################################################################################################################################
 
        // Events
 
        /*void raiseItemEvent(
            ID                          _itemId,
            eventType                   _eventType,
            int                         _info2 = 0
        );
        */
 
        void selectionChangedEvent(
            bool                        _emitEvent = true
        );
 
        aTreeWidgetItem * itemAt(const QPoint& _pos);
 
    Q_SIGNALS:
        void keyPressed(QKeyEvent *);
        void keyReleased(QKeyEvent *);
        void cleared(void);
        void focusLost(void);
        void selectionChanged(void);
        void itemActivated(QTreeWidgetItem *, int);
        void itemChanged(QTreeWidgetItem *, int);
        void itemClicked(QTreeWidgetItem *, int);
        void itemCollapsed(QTreeWidgetItem *);
        void itemDoubleClicked(QTreeWidgetItem *, int);
        void itemFocused(QTreeWidgetItem *);
        void itemExpanded(QTreeWidgetItem *);
        void itemTextChanged(QTreeWidgetItem *, int);
        void itemLocationChanged(QTreeWidgetItem *, int);
        void itemsMoved(const QList<ID>& _itemIds, const QList<ID>& _oldParentIds, const QList<ID>& _newParentIds);
        void customContextMenuRequested(const QPoint& _pos);
 
    public Q_SLOTS:
 
        void slotTreeKeyPressed(QKeyEvent * _event);
        void slotTreeKeyReleased(QKeyEvent * _event);
        void slotTreeItemActivated(QTreeWidgetItem * _item, int _column);
        void slotTreeItemChanged(QTreeWidgetItem * _item, int _column);
        void slotTreeItemClicked(QTreeWidgetItem * _item, int _column);
        void slotTreeItemCollapsed(QTreeWidgetItem * _item);
        void slotTreeItemDoubleClicked(QTreeWidgetItem * _item, int _column);
        void slotTreeItemExpanded(QTreeWidgetItem * _item);
        void slotTreeSelectionChanged();
        void slotTreeMouseMove(QMouseEvent *);
        void slotTreeLeave(QEvent *);
        void slotCustomContextMenuRequested(const QPoint& _pos);
 
        void slotFilterTextChanged(void);
 
        void slotFilterKeyPressed(QKeyEvent * _event);
 
    private:
 
        friend class aTreeWidgetBase;
 
        aTreeWidgetItem * createItem(
            const QString &                 _text = "",
            textAlignment                   _textAlignment = alignLeft,
            QIcon                           _icon = QIcon()
        );
 
        void refreshAfterItemsMoved(const QList<aTreeWidgetItem *>& _items, const QList<ID>& _itemIds,
            const QList<ID>& _oldParentIds, const QList<ID>& _newParentIds);
 
        void memFree(void);
 
        void clearItem(
            aTreeWidgetItem *               _itm
        );
 
        aTreeWidgetBase *                           m_tree;                 
        aLineEditWidget *                           m_filter;                   
        QWidget *                                   m_widget;
        QVBoxLayout *                               m_layout;                   
        bool                                        m_filterCaseSensitive;      
        bool                                        m_filterRefreshOnChange;    
        bool                                        m_ignoreEvents;
        bool                                        m_isReadOnly;
        bool                                        m_displayChildsOnFilter;
 
        ID                                          m_focusedItem;
 
        QString                                     m_headerText;               
 
        ID                                          m_currentId;                
 
        std::map<ID, aTreeWidgetItem *>             m_items;
 
        bool                                        m_selectAndDeselectChildren;
        bool                                        m_itemsAreEditable;     
    };
 
    // #########################################################################################################################################
 
    // #########################################################################################################################################
 
    // #########################################################################################################################################
 
    class UICORE_API_EXPORT aTreeWidgetBase : public QTreeWidget, public aWidget {
        Q_OBJECT
    public:
        aTreeWidgetBase(aTreeWidget * _ownerTree);
 
        virtual ~aTreeWidgetBase();
 
        // #######################################################################################################
        // Event handling
 
        virtual void keyPressEvent(QKeyEvent * _event) override;
 
        virtual void keyReleaseEvent(QKeyEvent * _event) override;
 
        virtual void mouseMoveEvent(QMouseEvent *event) override;
 
        virtual void leaveEvent(QEvent *event) override;
 
        virtual void dropEvent(QDropEvent * _event) override;
        
        virtual void dragEnterEvent(QDragEnterEvent * _event) override;
 
        virtual void dragLeaveEvent(QDragLeaveEvent * _event) override;
 
        // #######################################################################################################
 
        virtual QWidget * widget(void) override;
 
        // ####################################################################################################################################
 
        void AddTopLevelItem(
            aTreeWidgetItem *           _item
        );
 
        void itemWasMovedToTopLevel(aTreeWidgetItem * _item);
 
        aTreeWidgetItem * topLevelItem(
            const QString &             _text
        );
 
        aTreeWidgetItem * topLevelItem(
            ID                          _id
        );
 
        std::vector<QString> topLevelItemsText(void);
 
        void Clear(void);
 
        void removeTopLevelItem(
            ID                          _id
        );
        
        // ####################################################################################################################################
 
        static ID getItemId(
            QTreeWidgetItem *               _item
        );
 
        QList<aTreeWidgetItem *> selectedItemsRef(void) const;
        void extendedItemSelectionInformation(const QList<aTreeWidgetItem *>& _selectedItems, QList<ID>& _selectedItemIds, QList<ID>& _itemParentIds) const;
 
    Q_SIGNALS:
        void keyPressed(QKeyEvent *);
        void keyReleased(QKeyEvent *);
        void mouseMove(QMouseEvent *);
        void leave(QEvent *);
 
    private:
        aTreeWidget *                       m_ownerTree;
        std::map<ID, aTreeWidgetItem *>     m_topLevelItems;
        
        aTreeWidgetBase(aTreeWidgetBase &) = delete;
        aTreeWidgetBase& operator = (aTreeWidgetBase &) = delete;
    };
 
    // #########################################################################################################################################
 
    // #########################################################################################################################################
 
    // #########################################################################################################################################
 
    class UICORE_API_EXPORT aTreeWidgetItem : public QTreeWidgetItem, public aObject {
    public:
 
        aTreeWidgetItem(
            ID                              _newId,
            aTreeWidgetItem *               _parent = nullptr,
            int                             _type = 0
        );
 
        aTreeWidgetItem(
            aTreeWidgetBase *               _view,
            ID                              _newId,
            aTreeWidgetItem *               _parent = nullptr,
            int                             _type = 0
        );
 
        virtual ~aTreeWidgetItem();
 
        // ##############################################################################################
 
        // Setter
 
        void AddChild(
            aTreeWidgetItem *               _child
        );
 
        void setParentItem(
            aTreeWidgetItem *               _parent
        );
 
        void setChildsEnabled(
            bool                            _enabled
        );
 
        void setChildsSelected(
            bool                            _selected
        );
 
        void setChildsVisible(
            bool                            _visible
        );
 
        void ensureTopLevelSelectionVisible();
 
        void expandAllParents(
            bool                            _expandThis
        );
 
        void collapse(void);
 
        void setEditable(bool _editable = true);
 
        void setLocked(bool _locked = true);
 
        void setVisible(
            bool                            _isVisible,
            bool                            _expandParents = true
        );
        
        // ##############################################################################################
 
        // Getter
 
        aTreeWidgetItem * findChild(
            ID                          _id
        );
 
        aTreeWidgetItem * findChild(
            const QString &                 _text
        );
 
        ID getItemID(
            const QStringList &             _itemPath,
            int                             _currentIndex
        );
 
        void eraseChild(
            ID                          _id
        );
 
        bool hasChilds(void);
 
        aTreeWidgetItem * popFirstChild(void);
 
        const std::list<aTreeWidgetItem *> & childs(void);
 
        const std::list<aTreeWidgetItem *> & allChilds(void);
 
        const std::list<ID> & allChildsIDs(void);
 
        int childCount(void) const;
 
        ID id(void) const;
 
        ID parentId(void) const;
 
        void setStoredText(const QString & _text) { m_text = _text; }
 
        QString storedText(void) const { return m_text; }
 
        std::list<QString> getItemPath();
 
        QString getItemPathString(
            char                            _delimiter = '|'
        );
 
        bool isVisible(void) const { return m_isVisible; }
 
        aTreeWidgetItem * parentItem(void) const { return m_parent; }
 
        void setSelectChilds(bool flag) { m_selectChilds = flag; }
        bool getSelectChilds(void) { return m_selectChilds; }
 
    private:
 
        void refreshEditableState(void);
 
        aTreeWidgetItem *               m_parent;
        std::list<aTreeWidgetItem *>    m_childs;           
        std::list<aTreeWidgetItem *>    m_allChilds;
        std::list<ID>                   m_allChildsIDs;
        ID                              m_id;
        QString                         m_text;
        bool                            m_isEditable;
        bool                            m_isLockedForEdit;
        bool                            m_isVisible;
        bool                            m_selectChilds;
 
        aTreeWidgetItem() = delete;
        aTreeWidgetItem(aTreeWidgetItem &) = delete;
        aTreeWidgetItem & operator = (aTreeWidgetItem &) = delete;
    };
} // namespace ak