HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1142:425eece3bcf7

Display of the save & cancel button next to a catalogue

trabillard -

r1142:425eece3bcf7

parent child

Context file:

r1142:425eece3bcf7

Collapse all files

gui/resources/icones/discard.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/save.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

gui/include/Catalogue/CatalogueTreeWidgetItem.h +3 0

             #ifndef SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #define SCIQLOP_CATALOGUETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QTreeWidgetItem>
             #include <DBCatalogue.h>
             class CatalogueTreeWidgetItem : public QTreeWidgetItem {
             public:
                 CatalogueTreeWidgetItem(DBCatalogue catalogue, int type = QTreeWidgetItem::Type);
                 QVariant data(int column, int role) const override;
                 void setData(int column, int role, const QVariant &value) override;
+                /// Returns the catalogue represented by the item
                 DBCatalogue catalogue() const;
+                void setHasChanges(bool value);
             private:
                 class CatalogueTreeWidgetItemPrivate;
                 spimpl::unique_impl_ptr<CatalogueTreeWidgetItemPrivate> impl;
             };
             #endif // SCIQLOP_CATALOGUETREEWIDGETITEM_H

gui/resources/sqpguiresources.qrc +2 0

             <RCC>
                 <qresource prefix="/">
             		<file>icones/dataSourceComponent.png</file>
             		<file>icones/dataSourceNode.png</file>
             		<file>icones/dataSourceProduct.png</file>
             		<file>icones/dataSourceRoot.png</file>
             		<file>icones/delete.png</file>
                     <file>icones/down.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
                     <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
                     <file>icones/unplot.png</file>
                     <file>icones/up.png</file>
             		<file>icones/time.png</file>
             		<file>icones/zoom.png</file>
             		<file>icones/rectangle.png</file>
             		<file>icones/drag.png</file>
             		<file>icones/cursor.png</file>
             		<file>icones/pointer.png</file>
             		<file>icones/catalogue.png</file>
             		<file>icones/add.png</file>
             		<file>icones/remove.png</file>
             		<file>icones/chart.png</file>
             		<file>icones/allEvents.png</file>
             		<file>icones/trash.png</file>
             		<file>icones/database.png</file>
+            		<file>icones/save.png</file>
+            		<file>icones/discard.png</file>
                 </qresource>
             </RCC>

gui/src/Catalogue/CatalogueSideBarWidget.cpp +5 -1

             #include "Catalogue/CatalogueSideBarWidget.h"
             #include "ui_CatalogueSideBarWidget.h"
             #include <SqpApplication.h>
             #include <Catalogue/CatalogueController.h>
             #include <Catalogue/CatalogueTreeWidgetItem.h>
             #include <CatalogueDao.h>
             #include <ComparaisonPredicate.h>
             #include <DBCatalogue.h>
             #include <QMenu>
             constexpr auto ALL_EVENT_ITEM_TYPE = QTreeWidgetItem::UserType;
             constexpr auto TRASH_ITEM_TYPE = QTreeWidgetItem::UserType + 1;
             constexpr auto CATALOGUE_ITEM_TYPE = QTreeWidgetItem::UserType + 2;
             constexpr auto DATABASE_ITEM_TYPE = QTreeWidgetItem::UserType + 3;
             struct CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate {
                 QHash<QTreeWidgetItem *, DBCatalogue> m_CatalogueMap;
                 void configureTreeWidget(QTreeWidget *treeWidget);
                 QTreeWidgetItem *addDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 QTreeWidgetItem *getDatabaseItem(const QString &name, QTreeWidget *treeWidget);
                 void addCatalogueItem(const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem);
             };
             CatalogueSideBarWidget::CatalogueSideBarWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueSideBarWidget),
                       impl{spimpl::make_unique_impl<CatalogueSideBarWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 impl->configureTreeWidget(ui->treeWidget);
+                ui->treeWidget->setColumnCount(2);
+                ui->treeWidget->header()->setStretchLastSection(false);
+                ui->treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
+                ui->treeWidget->header()->setSectionResizeMode(0, QHeaderView::Stretch);
                 auto emitSelection = [this]() {
                     auto selectedItems = ui->treeWidget->selectedItems();
                     if (selectedItems.isEmpty()) {
                         emit this->selectionCleared();
                     }
                     else {
                         QVector<DBCatalogue> catalogues;
                         QStringList databases;
                         int selectionType = selectedItems.first()->type();
                         for (auto item : ui->treeWidget->selectedItems()) {
                             if (item->type() == selectionType) {
                                 switch (selectionType) {
                                     case CATALOGUE_ITEM_TYPE:
                                         catalogues.append(
                                             static_cast<CatalogueTreeWidgetItem *>(item)->catalogue());
                                         break;
                                     case DATABASE_ITEM_TYPE:
                                         selectionType = DATABASE_ITEM_TYPE;
                                         databases.append(item->text(0));
                                     case ALL_EVENT_ITEM_TYPE: // fallthrough
                                     case TRASH_ITEM_TYPE:     // fallthrough
                                     default:
                                         break;
                                 }
                             }
                             else {
                                 // Incoherent multi selection
                                 selectionType = -1;
                                 break;
                             }
                         }
                         switch (selectionType) {
                             case CATALOGUE_ITEM_TYPE:
                                 emit this->catalogueSelected(catalogues);
                                 break;
                             case DATABASE_ITEM_TYPE:
                                 emit this->databaseSelected(databases);
                                 break;
                             case ALL_EVENT_ITEM_TYPE:
                                 emit this->allEventsSelected();
                                 break;
                             case TRASH_ITEM_TYPE:
                                 emit this->trashSelected();
                                 break;
                             default:
                                 emit this->selectionCleared();
                                 break;
                         }
                     }
                 };
                 connect(ui->treeWidget, &QTreeWidget::itemClicked, emitSelection);
                 connect(ui->treeWidget, &QTreeWidget::currentItemChanged, emitSelection);
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                         &CatalogueSideBarWidget::onContextMenuRequested);
             }
             CatalogueSideBarWidget::~CatalogueSideBarWidget()
             {
                 delete ui;
             }
             void CatalogueSideBarWidget::onContextMenuRequested(const QPoint &pos)
             {
                 QMenu menu{this};
                 auto currentItem = ui->treeWidget->currentItem();
                 switch (currentItem->type()) {
                     case CATALOGUE_ITEM_TYPE:
                         menu.addAction("Rename",
                                        [this, currentItem]() { ui->treeWidget->editItem(currentItem); });
                         break;
                     case DATABASE_ITEM_TYPE:
                         break;
                     case ALL_EVENT_ITEM_TYPE:
                         break;
                     case TRASH_ITEM_TYPE:
                         menu.addAction("Empty Trash", []() {
                             // TODO
                         });
                         break;
                     default:
                         break;
                 }
                 if (!menu.isEmpty()) {
                     menu.exec(ui->treeWidget->mapToGlobal(pos));
                 }
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::configureTreeWidget(
                 QTreeWidget *treeWidget)
             {
                 auto allEventsItem = new QTreeWidgetItem{{"All Events"}, ALL_EVENT_ITEM_TYPE};
                 allEventsItem->setIcon(0, QIcon(":/icones/allEvents.png"));
                 treeWidget->addTopLevelItem(allEventsItem);
                 auto trashItem = new QTreeWidgetItem{{"Trash"}, TRASH_ITEM_TYPE};
                 trashItem->setIcon(0, QIcon(":/icones/trash.png"));
                 treeWidget->addTopLevelItem(trashItem);
                 auto separator = new QFrame{treeWidget};
                 separator->setFrameShape(QFrame::HLine);
                 auto separatorItem = new QTreeWidgetItem{};
                 separatorItem->setFlags(Qt::NoItemFlags);
                 treeWidget->addTopLevelItem(separatorItem);
                 treeWidget->setItemWidget(separatorItem, 0, separator);
                 auto &dao = sqpApp->catalogueController().getDao();
                 auto allPredicate = std::make_shared<ComparaisonPredicate>(QString{"uniqId"}, "-1",
                                                                            ComparaisonOperation::DIFFERENT);
                 auto db = addDatabaseItem("Default", treeWidget);
                 auto catalogues = dao.getCatalogues(allPredicate);
                 for (auto catalogue : catalogues) {
                     addCatalogueItem(catalogue, db);
                 }
                 treeWidget->expandAll();
             }
             QTreeWidgetItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addDatabaseItem(const QString &name,
                                                                                    QTreeWidget *treeWidget)
             {
                 auto databaseItem = new QTreeWidgetItem{{name}, DATABASE_ITEM_TYPE};
                 databaseItem->setIcon(0, QIcon{":/icones/database.png"});
                 treeWidget->addTopLevelItem(databaseItem);
                 return databaseItem;
             }
             QTreeWidgetItem *
             CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::getDatabaseItem(const QString &name,
                                                                                    QTreeWidget *treeWidget)
             {
                 for (auto i = 0; i < treeWidget->topLevelItemCount(); ++i) {
                     auto item = treeWidget->topLevelItem(i);
                     if (item->type() == DATABASE_ITEM_TYPE && item->text(0) == name) {
                         return item;
                     }
                 }
                 return nullptr;
             }
             void CatalogueSideBarWidget::CatalogueSideBarWidgetPrivate::addCatalogueItem(
                 const DBCatalogue &catalogue, QTreeWidgetItem *parentDatabaseItem)
             {
                 auto catalogueItem = new CatalogueTreeWidgetItem{catalogue, CATALOGUE_ITEM_TYPE};
                 catalogueItem->setIcon(0, QIcon{":/icones/catalogue.png"});
                 parentDatabaseItem->addChild(catalogueItem);
             }

gui/src/Catalogue/CatalogueTreeWidgetItem.cpp +52 -8

             #include "Catalogue/CatalogueTreeWidgetItem.h"
+            #include <memory>
+            #include <QBoxLayout>
+            #include <QToolButton>
+            const auto VALIDATION_BUTTON_ICON_SIZE = 12;
             struct CatalogueTreeWidgetItem::CatalogueTreeWidgetItemPrivate {
                 DBCatalogue m_Catalogue;
                 CatalogueTreeWidgetItemPrivate(DBCatalogue catalogue) : m_Catalogue(catalogue) {}
             };
             CatalogueTreeWidgetItem::CatalogueTreeWidgetItem(DBCatalogue catalogue, int type)
                     : QTreeWidgetItem(type),
                       impl{spimpl::make_unique_impl<CatalogueTreeWidgetItemPrivate>(catalogue)}
             {
                 setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable);
             }
             QVariant CatalogueTreeWidgetItem::data(int column, int role) const
             {
-                switch (role) {
+                if (column == 0) {
-                    case Qt::EditRole: // fallthrough
+                    switch (role) {
-                    case Qt::DisplayRole:
+                        case Qt::EditRole: // fallthrough
-                        return impl->m_Catalogue.getName();
+                        case Qt::DisplayRole:
-                    default:
+                            return impl->m_Catalogue.getName();
-                        break;
+                        default:
+                            break;
+                    }
                 }
                 return QTreeWidgetItem::data(column, role);
             }
             void CatalogueTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 if (role == Qt::EditRole && column == 0) {
                     auto newName = value.toString();
-                    setText(0, newName);
+                    if (newName != impl->m_Catalogue.getName()) {
-                    impl->m_Catalogue.setName(newName);
+                        setText(0, newName);
+                        impl->m_Catalogue.setName(newName);
+                        setHasChanges(true);
+                    }
                 }
                 else {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             DBCatalogue CatalogueTreeWidgetItem::catalogue() const
             {
                 return impl->m_Catalogue;
             }
+            void CatalogueTreeWidgetItem::setHasChanges(bool value)
+            {
+                if (value) {
+                    auto widet = new QWidget{treeWidget()};
+                    auto layout = new QHBoxLayout{widet};
+                    layout->setContentsMargins(0, 0, 0, 0);
+                    layout->setSpacing(0);
+                    auto btnValid = new QToolButton{widet};
+                    btnValid->setIcon(QIcon{":/icones/save"});
+                    btnValid->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
+                    btnValid->setAutoRaise(true);
+                    QObject::connect(btnValid, &QToolButton::clicked, [this]() { setHasChanges(false); });
+                    layout->addWidget(btnValid);
+                    auto btnDiscard = new QToolButton{widet};
+                    btnDiscard->setIcon(QIcon{":/icones/discard"});
+                    btnDiscard->setIconSize(QSize{VALIDATION_BUTTON_ICON_SIZE, VALIDATION_BUTTON_ICON_SIZE});
+                    btnDiscard->setAutoRaise(true);
+                    QObject::connect(btnDiscard, &QToolButton::clicked, [this]() { setHasChanges(false); });
+                    layout->addWidget(btnDiscard);
+                    treeWidget()->setItemWidget(this, 1, {widet});
+                    treeWidget()->resizeColumnToContents(1);
+                }
+                else {
+                    // Note: the widget is destroyed
+                    treeWidget()->setItemWidget(this, 1, nullptr);
+                }
+            }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages