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;

            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; }

            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);

            ~CViewBaseNonTemplate() override;

            virtual void customMenu(menus::CMenuActions &menuActions);

            void resizeEvent(QResizeEvent *event) override;

            void dragEnterEvent(QDragEnterEvent *event) override;

            void dragMoveEvent(QDragMoveEvent *event) override;

            void dragLeaveEvent(QDragLeaveEvent *event) override;

            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;

            ~CViewBase() override
            {
                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;


            void selectObjects(const ContainerType &selectedObjects) override;

            ContainerType selectedObjects() const override;

            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);
            }


            int removeSelectedRows() override;

            void presizeOrFullResizeToContents() override;

            void clearHighlighting() override;

            void materializeFilter() override;


            void clear() override;

            int rowCount() const override;

            bool isEmpty() const override;

            bool isOrderable() const override;

            void allowDragDrop(bool allowDrag, bool allowDrop, bool allowDropJsonFile = false) override;

            bool isDropAllowed() const override;

            void dropEvent(QDropEvent *event) override;

            bool acceptDrop(const QMimeData *mimeData) const override;

            bool setSorting(const swift::misc::CPropertyIndex &propertyIndex,
                            Qt::SortOrder order = Qt::AscendingOrder) override;

            void sortByPropertyIndex(const swift::misc::CPropertyIndex &propertyIndex,
                                     Qt::SortOrder order = Qt::AscendingOrder) override;

            void setNoSorting() override { m_model->setNoSorting(); }

            swift::misc::CPropertyIndex getSortProperty() const override { return m_model->getSortProperty(); }

            int getSortColumn() const override { return m_model->getSortColumn(); }

            bool hasValidSortColumn() const override { return m_model->hasValidSortColumn(); }

            bool endsWithEmptyColumn() const override { return m_model->endsWithEmptyColumn(); }

            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);


            bool reachedResizeThreshold(int containrerSize = -1) const override;

            void performModeBasedResizeToContent() override;

            int performUpdateContainer(const swift::misc::CVariant &variant, bool sort, bool resize) override;

            void updateSortIndicator() override;

            void mouseOverCallback(const QModelIndex &index, bool mouseOver) override;

            void drawDropIndicator(bool indicator) override;

            void copy() override;

            void cut() override;

            void paste() override;

            void displayJsonPopup() override { this->displayContainerAsJsonPopup(false); }

            void displaySelectedJsonPopup() override { this->displayContainerAsJsonPopup(true); }

            bool filterDialogFinished(int status) override;

            bool filterWidgetChangedFilter(bool enabled) override;

            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);

            void customMenu(menus::CMenuActions &menuActions) override;

            swift::misc::CStatusMessage loadJsonFile(const QString &fileName) override;

            virtual void displayContainerAsJsonPopup(bool selectedOnly);


            void onClicked(const QModelIndex &index) override;

            void onDoubleClicked(const QModelIndex &index) override;

            void onRowSelected(const QModelIndex &index) override;

            swift::misc::CStatusMessage loadJson(const QString &directory = {}) override;

            swift::misc::CStatusMessage saveJson(bool selectedOnly = false, const QString &directory = {}) override;
        };
    } // namespace views
} // namespace swift::gui
#endif // SWIFT_GUI_VIEWBASE_H