GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r930:72e367e25206

Merge branch 'feature/MacScrollbars' into develop

Thibaud Rabillard -

r930:72e367e25206

parent child

Context file:

r930:72e367e25206

Collapse all files

gui/include/Visualization/MacScrollBarStyle.h created 644 +18 0

@@ -0,0 +1,18
	1	#ifndef SCIQLOP_MACSCROLLBARSTYLE_H
	2	#define SCIQLOP_MACSCROLLBARSTYLE_H
	3
	4	#include <QProxyStyle>
	5
	6	/**
	7	* @brief Special style to always display the scrollbars on MAC.
	8	*/
	9	class MacScrollBarStyle : public QProxyStyle {
	10
	11	public:
	12	int styleHint(StyleHint hint, const QStyleOption option, const QWidget widget,
	13	QStyleHintReturn *returnData) const;
	14
	15	void selfInstallOn(QWidget *widget, bool installOnSubWidgets);
	16	};
	17
	18	#endif // SCIQLOP_MACSCROLLBARSTYLE_H

gui/src/Visualization/MacScrollBarStyle.cpp created 644 +40 0

@@ -0,0 +1,40
	1	#include "Visualization/MacScrollBarStyle.h"
	2
	3	#include <QWidget>
	4
	5	int MacScrollBarStyle::styleHint(QStyle::StyleHint hint, const QStyleOption *option,
	6	const QWidget widget, QStyleHintReturn returnData) const
	7	{
	8	switch (hint) {
	9	case SH_ScrollBar_Transient:
	10	return false; // Makes the scrollbar always visible
	11	case SH_ScrollView_FrameOnlyAroundContents:
	12	return true; // Avoid that the scrollbar is drawn on top of the widget
	13	default:
	14	break;
	15	}
	16
	17	return QProxyStyle::styleHint(hint, option, widget, returnData);
	18	}
	19
	20	void MacScrollBarStyle::selfInstallOn(QWidget *widget, bool installOnSubWidgets)
	21	{
	22	// Note: a style can be installed on a particular widget but it is not automatically applied its
	23	// children widgets.
	24
	25	QList<QWidget *> widgetsToStyle{widget};
	26	while (!widgetsToStyle.isEmpty()) {
	27
	28	auto widget = widgetsToStyle.takeFirst();
	29	widget->setStyle(this);
	30
	31	if (installOnSubWidgets) {
	32	for (auto child : widget->children()) {
	33	auto childWidget = qobject_cast<QWidget *>(child);
	34	if (childWidget) {
	35	widgetsToStyle << childWidget;
	36	}
	37	}
	38	}
	39	}
	40	}

gui/meson.build +2 -1

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropHelper.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
-              'src/Visualization/PlottablesRenderingUtils.cpp'
+              'src/Visualization/PlottablesRenderingUtils.cpp',
+              'src/Visualization/MacScrollBarStyle.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/Visualization/VisualizationTabWidget.cpp +10 0

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
+            #include "Visualization/MacScrollBarStyle.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
+            #ifdef Q_OS_MAC
+                std::unique_ptr<MacScrollBarStyle> m_MacScrollBarStyle = std::make_unique<MacScrollBarStyle>();
+            #endif
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
+            #ifdef Q_OS_MAC
+                impl->m_MacScrollBarStyle->selfInstallOn(ui->scrollArea, true);
+            #endif
                 ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 5);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
                 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 if (!variables.isEmpty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     tabWidget->createZone(variables, index);
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
                         helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }

General Comments 1

trabillard

|

Auto status change to "Under Review"

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