viewbase.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_GUI_VIEWBASE_H
#define SWIFT_GUI_VIEWBASE_H
 
#include <memory>
 
#include <QAbstractItemView>
#include <QFlags>
#include <QHeaderView>
#include <QJsonDocument>
#include <QJsonObject>
#include <QMap>
#include <QModelIndexList>
#include <QObject>
#include <QString>
#include <QTableView>
#include <Qt>
#include <QtGlobal>
 
#include "gui/enablefordockwidgetinfoarea.h"
#include "gui/menus/menuaction.h"
#include "gui/models/modelfilter.h"
#include "gui/models/selectionmodel.h"
#include "gui/overlaymessagesframe.h"
#include "gui/settings/guisettings.h"
#include "gui/swiftguiexport.h"
#include "misc/directories.h"
#include "misc/namevariantpairlist.h"
#include "misc/propertyindex.h"
#include "misc/propertyindexvariantmap.h"
#include "misc/statusmessage.h"
#include "misc/variant.h"
 
class QDragEnterEvent;
class QDragLeaveEvent;
class QDragMoveEvent;
class QFont;
class QItemSelectionModel;
class QMimeData;
class QModelIndex;
class QPaintEvent;
class QPoint;
class QShowEvent;
class QTabWidget;
 
namespace swift::misc
{
    class CWorker;
}
namespace swift::gui
{
    class CDockWidgetInfoArea;
    class CLoadIndicator;
 
    namespace menus
    {
        class IMenuDelegate;
        class CFontMenu;
    } // namespace menus
 
    namespace models
    {
        class CColumns;
    }
 
    namespace filters
    {
        class CFilterDialog;
        class CFilterWidget;
    } // namespace filters
 
    namespace components
    {
        class CTextEditDialog;
    }
 
    namespace views
    {
        class SWIFT_GUI_EXPORT CViewBaseNonTemplate :
            public COverlayMessagesTableView,
            public CEnableForDockWidgetInfoArea
        {
            Q_OBJECT
 
            Q_PROPERTY(bool isShowingLoadIndicator READ isShowingLoadIndicator NOTIFY loadIndicatorVisibilityChanged)
 
            friend class CViewBaseItemDelegate;
            friend class CViewBaseProxyStyle;
 
        public:
            enum ResizeMode
            {
                ResizingAuto, 
                ResizingOnce, 
                PresizeSubset, 
                ResizingAlways, 
                ResizingOff 
            };
 
            enum RowsResizeMode
            {
                Interactive,
                Content
            };
 
            enum MenuFlag
            {
                MenuNone = 0, 
                MenuClear = 1 << 0, 
                MenuRemoveSelectedRows = 1 << 1, 
                MenuRefresh = 1 << 2, 
                MenuBackend = 1 << 3, 
                MenuDisplayAutomatically = 1 << 4, 
                MenuDisplayAutomaticallyAndRefresh = MenuDisplayAutomatically | MenuRefresh, 
                MenuFilter = 1 << 5, 
                MenuMaterializeFilter = 1 << 6, 
                MenuSave = 1 << 7, 
                MenuLoad = 1 << 8, 
                MenuToggleSelectionMode = 1 << 9, 
                MenuOrderable = 1 << 10, 
                MenuCopy = 1 << 11, 
                MenuPaste = 1 << 12, 
                MenuCut = 1 << 13, 
                MenuFont = 1 << 14, 
                MenuLoadAndSave = MenuLoad | MenuSave,
                MenuDefault = MenuToggleSelectionMode | MenuDisplayAutomaticallyAndRefresh | MenuFont | MenuClear,
                MenuDefaultNoClear = MenuToggleSelectionMode | MenuDisplayAutomaticallyAndRefresh | MenuFont,
                MenuDefaultDbViews = MenuToggleSelectionMode | MenuBackend | MenuFont,
                // special menus, should be in derived classes, but enums cannot be inherited
                // maybe shifted in the future to elsewhere
                MenuHighlightStashed = 1 << 15, 
                MenuCanStashModels = 1 << 16, 
                MenuDisableModelsTemp = 1 << 17, 
                MenuStashing = MenuHighlightStashed | MenuCanStashModels,
            };
            Q_DECLARE_FLAGS(Menu, MenuFlag)
 
            
            static constexpr int ASyncRowsCountThreshold = 50;
 
            static constexpr int ResizeSubsetThreshold = 250;
 
            static constexpr int ResizeRowsToContentThreshold = 20;
 
            virtual void clear() = 0;
 
            virtual bool isEmpty() const = 0;
 
            virtual int rowCount() const = 0;
 
            virtual bool isOrderable() const = 0;
 
            virtual bool setSorting(const swift::misc::CPropertyIndex &propertyIndex,
                                    Qt::SortOrder order = Qt::AscendingOrder) = 0;
 
            virtual void sortByPropertyIndex(const swift::misc::CPropertyIndex &propertyIndex,
                                             Qt::SortOrder order = Qt::AscendingOrder) = 0;
 
            virtual void setNoSorting() = 0;
 
            virtual swift::misc::CPropertyIndex getSortProperty() const = 0;
 
            virtual int getSortColumn() const = 0;
 
            virtual bool hasValidSortColumn() const = 0;
 
            virtual bool endsWithEmptyColumn() const = 0;
 
            virtual Qt::SortOrder getSortOrder() const = 0;
 
            virtual void allowDragDrop(bool allowDrag, bool allowDrop, bool allowDropJsonFile = false) = 0;
 
            virtual bool isDropAllowed() const = 0;
 
            virtual bool acceptDrop(const QMimeData *mimeData) const = 0;
 
            virtual bool setParentDockWidgetInfoArea(swift::gui::CDockWidgetInfoArea *parentDockableWidget) override;
 
            ResizeMode getResizeMode() const { return m_resizeMode; }
 
            void setResizeMode(ResizeMode mode) { m_resizeMode = mode; }
 
            void setAutoResizeFrequency(int updateEveryNthTime) { m_resizeAutoNthTime = updateEveryNthTime; }
 
            bool displayAutomatically() const { return m_displayAutomatically; }
 
            void setDisplayAutomatically(bool automatically) { m_displayAutomatically = automatically; }
 
            const QFont &getHorizontalHeaderFont() const
            {
                Q_ASSERT(this->horizontalHeader());
                return this->horizontalHeader()->font();
            }
 
            int getHorizontalHeaderFontHeight() const;
 
            bool hasSelection() const;
 
            QModelIndexList selectedRows() const;
 
            virtual QModelIndexList unselectedRows() const;
 
            int selectRows(const QSet<int> &rows);
 
            int selectedRowCount() const;
 
            int unselectedRowCount() const;
 
            bool hasSingleSelectedRow() const;
 
            bool hasMultipleSelectedRows() const;
 
            bool allowsMultipleSelectedRows() const;
 
            bool isCurrentlyAllowingMultipleRowSelections() const;
 
            void setFilterDialog(filters::CFilterDialog *filterDialog);
 
            QWidget *getFilterWidget() const { return m_filterWidget; }
 
            void setFilterWidget(filters::CFilterWidget *filterWidget);
 
            menus::IMenuDelegate *setCustomMenu(menus::IMenuDelegate *menu, bool nestPreviousMenu = true);
 
            void enableLoadIndicator(bool enable);
 
            bool isShowingLoadIndicator() const;
 
            void acceptClickSelection(bool accept) { m_acceptClickSelection = accept; }
 
            void acceptDoubleClickSelection(bool accept) { m_acceptDoubleClickSelection = accept; }
 
            void acceptRowSelection(bool accept) { m_acceptRowSelection = accept; }
 
            void menuRemoveItems(Menu menusToRemove);
 
            void menuAddItems(Menu menusToAdd);
 
            void setMenu(Menu menuItems) { m_menus = menuItems; }
 
            Menu getMenu() const { return m_menus; }
 
            virtual void setSelectionModel(QItemSelectionModel *model) override;
 
            QWidget *mainApplicationWindowWidget() const;
 
            swift::misc::CStatusMessage showFileLoadDialog(const QString &directory = {});
 
            swift::misc::CStatusMessage showFileSaveDialog(bool selectedOnly, const QString &directory = {});
 
            void setSaveFileName(const QString &saveName) { m_saveFileName = saveName; }
 
            bool allowCacheFileFormatJson() const { return m_allowCacheFileJson; }
 
            void setAllowCacheFileFormatJson(bool allow) { m_allowCacheFileJson = allow; }
 
            void setForceColumnsToMaxSize(bool force) { this->setWordWrap(!force); }
 
            void setHorizontalHeaderSectionResizeMode(QHeaderView::ResizeMode mode);
 
            void setSettingsDirectoryIndex(swift::misc::CDirectories::ColumnIndex directoryIndex)
            {
                m_dirSettingsIndex = directoryIndex;
            }
 
        signals:
            void requestUpdate();
 
            void requestNewBackendData();
 
            void loadIndicatorVisibilityChanged(bool visible);
 
            void asyncUpdateFinished();
 
            void modelDataChanged(int count, bool withFilter);
 
            void modelDataChangedDigest(int count, bool withFilter);
 
            void modelChanged();
 
            void objectChanged(const swift::misc::CVariant &object, const swift::misc::CPropertyIndex &changedIndex);
 
            void objectClicked(const swift::misc::CVariant &object);
 
            void objectDoubleClicked(const swift::misc::CVariant &object);
 
            void objectSelected(const swift::misc::CVariant &object);
 
            void objectsDeleted(const swift::misc::CVariant &objectContainer);
 
            void jsonLoadCompleted(const swift::misc::CStatusMessage &msg);
 
        public slots:
            virtual void resizeToContents();
 
            virtual void fullResizeToContents();
 
            virtual void presizeOrFullResizeToContents() = 0;
 
            void rowsResizeModeToInteractive();
 
            void rowsResizeModeToContent();
 
            void rowsResizeModeBasedOnThreshold(int elements);
 
            int showLoadIndicator(int containerSizeDependent = -1,
                                  std::chrono::milliseconds timeout = std::chrono::milliseconds { 0 },
                                  bool processEvents = true);
 
            int showLoadIndicatorWithTimeout(std::chrono::milliseconds timeout = std::chrono::milliseconds { 0 },
                                             bool processEvents = true);
 
            void onModelChanged();
 
            void hideLoadIndicator(int loadingId = -1);
 
            void hideLoadIndicatorForced() { this->hideLoadIndicator(); }
 
            virtual int removeSelectedRows() = 0;
 
            virtual void clearHighlighting() = 0;
 
            virtual void materializeFilter() = 0;
 
        protected:
            CViewBaseNonTemplate(QWidget *parent);
 
            virtual ~CViewBaseNonTemplate() override;
 
            virtual void customMenu(menus::CMenuActions &menuActions);
 
            virtual void resizeEvent(QResizeEvent *event) override;
 
            virtual void dragEnterEvent(QDragEnterEvent *event) override;
 
            virtual void dragMoveEvent(QDragMoveEvent *event) override;
 
            virtual void dragLeaveEvent(QDragLeaveEvent *event) override;
 
            virtual void dropEvent(QDropEvent *event) override;
 
            virtual void performModeBasedResizeToContent() = 0;
 
            virtual int performUpdateContainer(const swift::misc::CVariant &variant, bool sort, bool resize) = 0;
 
            virtual bool reachedResizeThreshold(int containerSize = -1) const = 0;
 
            virtual bool isResizeConditionMet(int containerSize = -1) const;
 
            int getPresizeRandomElementsSize(int containerSize = -1) const;
 
            void centerLoadIndicator();
 
            void init();
 
            QString getFileDialogFileName(bool load) const;
 
            menus::CMenuActions initMenuActions(MenuFlag menu);
 
            virtual void updateSortIndicator() = 0;
 
            virtual void mouseOverCallback(const QModelIndex &index, bool mouseOver) = 0;
 
            virtual void drawDropIndicator(bool indicator) = 0;
 
            void saveJsonAction();
 
            void saveSelectedJsonAction();
 
            virtual void displayJsonPopup() = 0;
 
            virtual void displaySelectedJsonPopup() = 0;
 
            void loadJsonAction();
 
            virtual swift::misc::CStatusMessage loadJsonFile(const QString &filePath) = 0;
 
            void displayFilterDialog();
 
            void settingsChanged();
 
            void selectAll() override;
 
            void setMultiSelection();
            void setExtendedSelection();
            void setSingleSelection();
 
            virtual void rememberLastJsonDirectory(const QString &selectedFileOrDir);
 
            virtual QString getRememberedLastJsonDirectory() const;
 
            virtual void copy() = 0;
            virtual void cut() = 0;
            virtual void paste() = 0;
 
            virtual void onClicked(const QModelIndex &index) = 0;
 
            virtual void onDoubleClicked(const QModelIndex &index) = 0;
 
            virtual void onRowSelected(const QModelIndex &index) = 0;
 
            virtual swift::misc::CStatusMessage loadJson(const QString &directory = {}) = 0;
 
            virtual swift::misc::CStatusMessage saveJson(bool selectedOnly = false, const QString &directory = {}) = 0;
 
            void triggerReload();
 
            void triggerReloadFromBackend();
 
            virtual void removeFilter() = 0;
 
            void showVerticalHeader();
 
            virtual bool filterDialogFinished(int status) = 0;
 
            virtual bool filterWidgetChangedFilter(bool enabled) = 0;
 
            components::CTextEditDialog *textEditDialog();
 
            ResizeMode m_resizeMode = PresizeSubset; 
            RowsResizeMode m_rowResizeMode = Interactive; 
            SelectionMode m_originalSelectionMode = this->selectionMode(); 
            int m_resizeCount = 0; 
            int m_skipResizeThreshold = 40; 
            int m_resizeAutoNthTime = 1; 
            std::chrono::milliseconds m_loadIndicatorTimeoutDefault { 30 * 1000 }; 
            bool m_forceStretchLastColumnWhenResized =
                true; 
            bool m_showingLoadIndicator = false; 
            bool m_enabledLoadIndicator = false; 
            bool m_acceptClickSelection = false; 
            bool m_acceptRowSelection = false; 
            bool m_acceptDoubleClickSelection = false; 
            bool m_displayAutomatically = true; 
            bool m_enableDeleteSelectedRows = false; 
            bool m_dropIndicator = false; 
            bool m_forceColumnsToMaxSize = true; 
            bool m_allowCacheFileJson = true; 
            QWidget *m_filterWidget = nullptr; 
            Menu m_menus = MenuDefault; 
            menus::IMenuDelegate *m_menu = nullptr; 
            menus::CFontMenu *m_fontMenu = nullptr; 
            CLoadIndicator *m_loadIndicator = nullptr; 
            components::CTextEditDialog *m_textEditDialog = nullptr; 
            QMap<MenuFlag, menus::CMenuActions> m_menuFlagActions; 
            QString m_saveFileName; 
            swift::misc::CDirectories::ColumnIndex m_dirSettingsIndex = swift::misc::CDirectories::
                IndexDirLastViewJsonOrDefault; 
            swift::misc::CSetting<swift::misc::settings::TDirectorySettings> m_dirSettings {
                this
            }; 
            swift::misc::CSettingReadOnly<settings::TGeneralGui> m_guiSettings {
                this, &CViewBaseNonTemplate::settingsChanged
            }; 
 
        private:
            void removeSelectedRowsChecked();
 
            void toggleAutoDisplay();
 
            void customMenuRequested(const QPoint &pos);
 
            void onLoadIndicatorTimedOut();
 
            void toggleResizeMode(bool checked);
 
            void toggleWordWrap(bool checked);
 
            void setFilterWidgetImpl(QWidget *filterWidget);
        };
        Q_DECLARE_OPERATORS_FOR_FLAGS(swift::gui::views::CViewBaseNonTemplate::Menu)
 
        
        template <class T>
        class CViewBase : public CViewBaseNonTemplate, public models::ISelectionModel<typename T::ContainerType>
        {
            // I cannot use Q_OBJECT here, because: Template classes are not supported by Q_OBJECT
            // and I cannot declare slots as SLOT because I have no Q_OBJECT macro
 
        public:
            using ModelClass = T;
 
            using ContainerType = typename T::ContainerType;
 
            using ObjectType = typename T::ObjectType;
 
            virtual ~CViewBase()
            {
                if (m_model) { m_model->markDestroyed(); }
            }
 
            ModelClass *derivedModel() { return m_model; }
 
            const ModelClass *derivedModel() const { return m_model; }
 
            const models::CColumns &getColumns() const { return this->derivedModel()->getColumns(); }
 
            int updateContainer(const ContainerType &container, bool sort = true, bool resize = true);
 
            swift::misc::CWorker *updateContainerAsync(const ContainerType &container, bool sort = true,
                                                       bool resize = true);
 
            void updateContainerMaybeAsync(const ContainerType &container, bool sort = true, bool resize = true);
 
            void insert(const ObjectType &value, bool resize = true);
 
            void insert(const ContainerType &container, bool resize = true);
 
            void push_back(const ObjectType &value, bool resize = true);
 
            void push_back(const ContainerType &container, bool resize = true);
 
            const ObjectType &at(const QModelIndex &index) const;
 
            const ContainerType &container() const;
 
            QList<int> rowsOf(const ContainerType &container) const;
 
            int rowOf(const ObjectType &obj) const;
 
            const ContainerType &containerOrFilteredContainer(bool *filtered = nullptr) const;
 
 
            virtual void selectObjects(const ContainerType &selectedObjects) override;
 
            virtual ContainerType selectedObjects() const override;
 
            virtual ContainerType unselectedObjects() const override;
 
            ObjectType firstSelectedOrDefaultObject() const;
 
            int updateSelected(const swift::misc::CVariant &variant, const swift::misc::CPropertyIndex &index);
 
            int updateSelected(const swift::misc::CPropertyIndexVariantMap &vm);
 
            ObjectType selectedObject() const;
 
            template <class K0, class V0, class... KeysValues>
            int removeIf(K0 k0, V0 v0, KeysValues... keysValues)
            {
                if (this->rowCount() < 1) { return 0; }
                ContainerType cp(container());
                int r = cp.removeIf(k0, v0, keysValues...);
                if (r < 1) { return 0; }
                this->updateContainerMaybeAsync(cp);
                return r;
            }
 
            template <class K1, class V1>
            void replaceOrAdd(K1 key1, V1 value1, const ObjectType &replacement)
            {
                ContainerType cp(container());
                cp.replaceOrAdd(key1, value1, replacement);
                this->updateContainerMaybeAsync(cp);
            }
 
 
            virtual int removeSelectedRows() override;
 
            virtual void presizeOrFullResizeToContents() override;
 
            virtual void clearHighlighting() override;
 
            virtual void materializeFilter() override;
 
 
            virtual void clear() override;
 
            virtual int rowCount() const override;
 
            virtual bool isEmpty() const override;
 
            virtual bool isOrderable() const override;
 
            virtual void allowDragDrop(bool allowDrag, bool allowDrop, bool allowDropJsonFile = false) override;
 
            virtual bool isDropAllowed() const override;
 
            virtual void dropEvent(QDropEvent *event) override;
 
            virtual bool acceptDrop(const QMimeData *mimeData) const override;
 
            virtual bool setSorting(const swift::misc::CPropertyIndex &propertyIndex,
                                    Qt::SortOrder order = Qt::AscendingOrder) override;
 
            virtual void sortByPropertyIndex(const swift::misc::CPropertyIndex &propertyIndex,
                                             Qt::SortOrder order = Qt::AscendingOrder) override;
 
            virtual void setNoSorting() override { m_model->setNoSorting(); }
 
            virtual swift::misc::CPropertyIndex getSortProperty() const override { return m_model->getSortProperty(); }
 
            virtual int getSortColumn() const override { return m_model->getSortColumn(); }
 
            virtual bool hasValidSortColumn() const override { return m_model->hasValidSortColumn(); }
 
            virtual bool endsWithEmptyColumn() const override { return m_model->endsWithEmptyColumn(); }
 
            virtual Qt::SortOrder getSortOrder() const override { return m_model->getSortOrder(); }
 
            void sort();
 
            void resort();
 
            int columnCount() const;
 
            QJsonObject toJson(bool selectedOnly = false) const;
 
            QString toJsonString(QJsonDocument::JsonFormat format = QJsonDocument::Indented,
                                 bool selectedOnly = false) const;
 
            virtual void setObjectName(const QString &name);
 
            void takeFilterOwnership(std::unique_ptr<models::IModelFilter<ContainerType>> &filter);
 
            bool hasFilter() const;
 
            void addContainerTypesAsDropTypes(bool objectType = true, bool containerType = true);
 
            void initAsOrderable();
 
            void setDropActions(Qt::DropActions dropActions)
            {
                Q_ASSERT(m_model);
                m_model->setDropActions(dropActions);
            }
 
            void setTabWidgetViewText(QTabWidget *tw, int index);
 
            void setPercentageColumnWidths();
 
        protected:
            ModelClass *m_model = nullptr; 
 
            CViewBase(QWidget *parent, ModelClass *model = nullptr);
 
            void setSortIndicator();
 
            void standardInit(ModelClass *model = nullptr);
 
 
            virtual bool reachedResizeThreshold(int containrerSize = -1) const override;
 
            virtual void performModeBasedResizeToContent() override;
 
            virtual int performUpdateContainer(const swift::misc::CVariant &variant, bool sort, bool resize) override;
 
            virtual void updateSortIndicator() override;
 
            virtual void mouseOverCallback(const QModelIndex &index, bool mouseOver) override;
 
            virtual void drawDropIndicator(bool indicator) override;
 
            virtual void copy() override;
 
            virtual void cut() override;
 
            virtual void paste() override;
 
            virtual void displayJsonPopup() override { this->displayContainerAsJsonPopup(false); }
 
            virtual void displaySelectedJsonPopup() override { this->displayContainerAsJsonPopup(true); }
 
            virtual bool filterDialogFinished(int status) override;
 
            virtual bool filterWidgetChangedFilter(bool enabled) override;
 
            virtual void removeFilter() override;
 
            virtual swift::misc::CStatusMessage modifyLoadedJsonData(ContainerType &data) const;
 
            virtual swift::misc::CStatusMessage validateLoadedJsonData(const ContainerType &data) const;
 
            virtual void jsonLoadedAndModelUpdated(const ContainerType &data);
 
            virtual void customMenu(menus::CMenuActions &menuActions) override;
 
            virtual swift::misc::CStatusMessage loadJsonFile(const QString &fileName) override;
 
            virtual void displayContainerAsJsonPopup(bool selectedOnly);
 
 
            virtual void onClicked(const QModelIndex &index) override;
 
            virtual void onDoubleClicked(const QModelIndex &index) override;
 
            virtual void onRowSelected(const QModelIndex &index) override;
 
            virtual swift::misc::CStatusMessage loadJson(const QString &directory = {}) override;
 
            virtual swift::misc::CStatusMessage saveJson(bool selectedOnly = false,
                                                         const QString &directory = {}) override;
        };
    } // namespace views
} // namespace swift::gui
#endif // SWIFT_GUI_VIEWBASE_H