HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1397:348e733132e4

Fixed Drag&Drop issue on some platforms and made more consistent plugin install path with Meson...

jeandet -

r1397:348e733132e4

parent child

Context file:

r1397:348e733132e4

app/meson.build +3 -2

             endif
             app_libs = []
+            cpp_args = []
             if 'static' == get_option('default_library')
               app_libs = [ sciqlop_amdaplugin, sciqlop_mockplugin]
+              cpp_args += ['-DQT_STATICPLUGIN']
             endif
             sciqlop_app = executable('sciqlop',
                                    rc,
                                    include_directories : [ app_inc],
                                    link_with: app_libs,
+                                   cpp_args: cpp_args,
                                    dependencies : [sciqlop_gui, sciqlop_core],
                                    install : true
                                    )

build_cfg/linux/appImage.sh 0 -1

             ninja
             DESTDIR=AppDir ninja install
             mv AppDir/usr/lib64 AppDir/usr/lib
-            mv AppDir/usr/lib/*plugin.so AppDir/usr/bin/
             wget https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage
             chmod +x  linuxdeployqt-continuous-x86_64.AppImage && ./linuxdeployqt-continuous-x86_64.AppImage --appimage-extract
             LD_LIBRARY_PATH=AppDir/usr/lib64/ ./squashfs-root/AppRun AppDir/usr/share/applications/*.desktop -appimage

gui/src/Visualization/VisualizationDragDropContainer.cpp +132 -74

             auto DRAGGED_MINIATURE_WIDTH = 200; // in pixels
-            struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate {
+            struct VisualizationDragDropContainer::VisualizationDragDropContainerPrivate
+            {
                 QVBoxLayout* m_Layout;
                 QHash<QString, VisualizationDragDropContainer::DropBehavior> m_AcceptedMimeTypes;
                 bool acceptMimeData(const QMimeData* data) const
                 {
                     auto accepted = false;
-                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd(); ++it)
-                         ++it) {
                         const auto& type = it.key();
                         const auto& behavior = it.value();
-                        if (data->hasFormat(type)) {
+                        if (data->hasFormat(type))
-                            if (behavior != DropBehavior::Forbidden) {
+                            if (behavior != DropBehavior::Forbidden)
+                            {
                                 accepted = true;
                             }
-                            else {
+                            else
+                            {
                                 accepted = false;
                                 break;
                             }
                         }
                     }
-                    if (accepted) {
+                    if (accepted)
+                    {
                         accepted = m_AcceptMimeDataFun(data);
                     }
                 bool allowMergeForMimeData(const QMimeData* data) const
                 {
                     auto result = false;
-                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd(); ++it)
-                         ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Merged
                                    || it.value()
-                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
+                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged))
+                        {
                             result = true;
                         }
                         else if (data->hasFormat(it.key())
-                                 && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted) {
+                            && it.value() == VisualizationDragDropContainer::DropBehavior::Inserted)
+                        {
                             // Merge is forbidden if the mime data contain an acceptable type which cannot be
                             // merged
                             result = false;
                 bool allowInsertForMimeData(const QMimeData* data) const
                 {
-                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd();
+                    for (auto it = m_AcceptedMimeTypes.constBegin(); it != m_AcceptedMimeTypes.constEnd(); ++it)
-                         ++it) {
                         if (data->hasFormat(it.key())
                             && (it.value() == VisualizationDragDropContainer::DropBehavior::Inserted
                                    || it.value()
-                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged)) {
+                                       == VisualizationDragDropContainer::DropBehavior::InsertedAndMerged))
+                        {
                             return true;
                         }
                     }
                 {
                     VisualizationDragWidget* dragWidget = nullptr;
-                    for (auto child : parent->children()) {
+                    for (auto child : parent->children())
+                    {
                         auto widget = qobject_cast<VisualizationDragWidget*>(child);
-                        if (widget && widget->isVisible()) {
+                        if (widget && widget->isVisible())
-                            if (widget->frameGeometry().contains(pos)) {
+                            if (widget->frameGeometry().contains(pos))
+                            {
                                 dragWidget = widget;
                                 break;
                             }
                 int countDragWidget(const QWidget* parent, bool onlyVisible = false) const
                 {
                     auto nbGraph = 0;
-                    for (auto child : parent->children()) {
+                    for (auto child : parent->children())
-                        if (qobject_cast<VisualizationDragWidget *>(child)) {
-                            if (!onlyVisible || qobject_cast<VisualizationDragWidget *>(child)->isVisible()) {
+                        if (qobject_cast<VisualizationDragWidget*>(child))
+                        {
+                            if (!onlyVisible || qobject_cast<VisualizationDragWidget*>(child)->isVisible())
+                            {
                                 nbGraph += 1;
                             }
                         }
             };
             VisualizationDragDropContainer::VisualizationDragDropContainer(QWidget* parent)
-                    : QFrame{parent},
+                    : QFrame { parent }
-                      impl{spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this)}
+                    , impl { spimpl::make_unique_impl<VisualizationDragDropContainerPrivate>(this) }
             {
                 setAcceptDrops(true);
             }
                     &VisualizationDragDropContainer::startDrag);
             }
-            void VisualizationDragDropContainer::insertDragWidget(int index,
+            void VisualizationDragDropContainer::insertDragWidget(
-                                                                  VisualizationDragWidget *dragWidget)
+                int index, VisualizationDragWidget* dragWidget)
             {
                 impl->m_Layout->insertWidget(index, dragWidget);
                 disconnect(dragWidget, &VisualizationDragWidget::dragDetected, nullptr, nullptr);
                 impl->m_AcceptDragWidgetFun = fun;
             }
-            void VisualizationDragDropContainer::setPlaceHolderType(DragDropGuiController::PlaceHolderType type,
+            void VisualizationDragDropContainer::setPlaceHolderType(
-                                                                    const QString &placeHolderText)
+                DragDropGuiController::PlaceHolderType type, const QString& placeHolderText)
             {
                 impl->m_PlaceHolderType = type;
                 impl->m_PlaceHolderText = placeHolderText;
             }
-            void VisualizationDragDropContainer::startDrag(VisualizationDragWidget *dragWidget,
+            void VisualizationDragDropContainer::startDrag(
-                                                           const QPoint &dragPosition)
+                VisualizationDragWidget* dragWidget, const QPoint& dragPosition)
             {
                 auto& helper = sqpApp->dragDropGuiController();
                 helper.resetDragAndDrop();
                 drag->setMimeData(mimeData);
                 auto pixmap = dragWidget->customDragPixmap(dragPosition);
-                if (pixmap.isNull()) {
+                if (pixmap.isNull())
+                {
                     pixmap = QPixmap { dragWidget->size() };
                     dragWidget->render(&pixmap);
                 }
                 mimeData->setImageData(image);
                 mimeData->setUrls({ helper.imageTemporaryUrl(image) });
-                if (impl->m_Layout->indexOf(dragWidget) >= 0) {
+                if (impl->m_Layout->indexOf(dragWidget) >= 0)
+                {
-                    if (impl->acceptMimeData(mimeData) && impl->allowInsertForMimeData(mimeData)) {
+                    if (impl->acceptMimeData(mimeData) && impl->allowInsertForMimeData(mimeData))
+                    {
                         helper.setCurrentDragWidget(dragWidget);
-                        if (impl->cursorIsInContainer(this)) {
+                        if (impl->cursorIsInContainer(this))
+                        {
                             auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
                             helper.insertPlaceHolder(impl->m_Layout, dragWidgetIndex, impl->m_PlaceHolderType,
                                 impl->m_PlaceHolderText);
                             dragWidget->setVisible(false);
                         }
-                        else {
+                        else
+                        {
                             // The drag starts directly outside the drop zone
                             // do not add the placeHolder
                         }
                     helper.doCloseWidgets();
                 }
-                else {
+                else
+                {
                     qCWarning(LOG_VisualizationDragDropContainer())
                         << tr("VisualizationDragDropContainer::startDrag, drag aborted, the specified "
                               "VisualizationDragWidget is not found in this container.");
             void VisualizationDragDropContainer::dragEnterEvent(QDragEnterEvent* event)
             {
-                if (impl->acceptMimeData(event->mimeData())) {
+                if (impl->acceptMimeData(event->mimeData()))
+                {
                     event->acceptProposedAction();
                     auto& helper = sqpApp->dragDropGuiController();
-                    if (!impl->hasPlaceHolder()) {
+                    if (!impl->hasPlaceHolder())
+                    {
                         auto dragWidget = helper.getCurrentDragWidget();
-                        if (dragWidget) {
+                        if (dragWidget)
+                        {
                             // If the drag&drop is internal to the visualization, entering the container hide
                             // the dragWidget which was made visible by the dragLeaveEvent
                             auto parentWidget
                                 = qobject_cast<VisualizationDragDropContainer*>(dragWidget->parentWidget());
-                            if (parentWidget) {
+                            if (parentWidget)
+                            {
                                 dragWidget->setVisible(false);
                             }
                         }
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
-                        if (!impl->findPlaceHolderPosition(event->pos(), event->mimeData(), canInsert, canMerge,
+                        if (!impl->findPlaceHolderPosition(
-                                                           this)) {
+                                event->pos(), event->mimeData(), canInsert, canMerge, this))
+                        {
                             event->ignore();
                         }
                     }
-                    else {
+                    else
+                    {
                         // do nothing
                     }
                 }
-                else {
+                else
+                {
                     event->ignore();
                 }
                 auto& helper = sqpApp->dragDropGuiController();
-                if (!impl->cursorIsInContainer(this)) {
+                if (!impl->cursorIsInContainer(this))
+                {
                     helper.removePlaceHolder();
                     helper.setHightlightedDragWidget(nullptr);
                     impl->m_MinContainerHeight = 0;
                     auto dragWidget = helper.getCurrentDragWidget();
-                    if (dragWidget) {
+                    if (dragWidget)
+                    {
                         // dragWidget has a value only if the drag is started from the visualization
                         // In that case, shows the drag widget at its original place
                         // So the drag widget doesn't stay hidden if the drop occurs outside the visualization
                         // drop zone (It is not possible to catch a drop event outside of the application)
-                        if (dragWidget) {
+                        if (dragWidget)
+                        {
                             dragWidget->setVisible(true);
                         }
                     }
                 }
-                else {
+                else
+                {
                     // Leave event probably received for a child widget.
                     // Do nothing.
                     // Note: The DragLeave event, doesn't have any mean to determine who sent it.
             void VisualizationDragDropContainer::dragMoveEvent(QDragMoveEvent* event)
             {
-                if (impl->acceptMimeData(event->mimeData())) {
+                if (impl->acceptMimeData(event->mimeData()))
+                {
+                    event->acceptProposedAction();
                     auto canMerge = impl->allowMergeForMimeData(event->mimeData());
                     auto canInsert = impl->allowInsertForMimeData(event->mimeData());
                     impl->findPlaceHolderPosition(event->pos(), event->mimeData(), canInsert, canMerge, this);
                 }
-                else {
+                else
+                {
                     event->ignore();
                 }
             {
                 auto& helper = sqpApp->dragDropGuiController();
-                if (impl->acceptMimeData(event->mimeData())) {
+                if (impl->acceptMimeData(event->mimeData()))
+                {
                     auto dragWidget = helper.getCurrentDragWidget();
-                    if (impl->hasPlaceHolder()) {
+                    if (impl->hasPlaceHolder())
+                    {
                         // drop where the placeHolder is located
                         auto canInsert = impl->allowInsertForMimeData(event->mimeData());
-                        if (canInsert) {
+                        if (canInsert)
+                        {
                             auto droppedIndex = impl->m_Layout->indexOf(&helper.placeHolder());
-                            if (dragWidget) {
+                            if (dragWidget)
+                            {
                                 auto dragWidgetIndex = impl->m_Layout->indexOf(dragWidget);
-                                if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex) {
+                                if (dragWidgetIndex >= 0 && dragWidgetIndex < droppedIndex)
+                                {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                             emit dropOccuredInContainer(droppedIndex, event->mimeData());
                         }
-                        else {
+                        else
+                        {
                             qCWarning(LOG_VisualizationDragDropContainer()) << tr(
                                 "VisualizationDragDropContainer::dropEvent, dropping on the placeHolder, but "
                                 "the insertion is forbidden.");
                             Q_ASSERT(false);
                         }
                     }
-                    else if (helper.getHightlightedDragWidget()) {
+                    else if (helper.getHightlightedDragWidget())
+                    {
                         // drop on the highlighted widget
                         auto canMerge = impl->allowMergeForMimeData(event->mimeData());
-                        if (canMerge) {
+                        if (canMerge)
+                        {
                             event->acceptProposedAction();
                             emit dropOccuredOnWidget(helper.getHightlightedDragWidget(), event->mimeData());
                         }
-                        else {
+                        else
+                        {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::dropEvent, dropping on a widget, but "
                                       "the merge is forbidden.");
                         }
                     }
                 }
-                else {
+                else
+                {
                     event->ignore();
                 }
                 auto absPos = container->mapToGlobal(pos);
                 auto isOnPlaceHolder = helper.placeHolder().isAncestorOf(sqpApp->widgetAt(absPos));
-                if (countDragWidget(container, true) == 0) {
+                if (countDragWidget(container, true) == 0)
+                {
                     // Drop on an empty container, just add the placeHolder at the top
                     helper.insertPlaceHolder(m_Layout, 0, m_PlaceHolderType, m_PlaceHolderText);
                 }
-                else if (!isOnPlaceHolder) {
+                else if (!isOnPlaceHolder)
+                {
                     auto nbDragWidget = countDragWidget(container);
-                    if (nbDragWidget > 0) {
+                    if (nbDragWidget > 0)
+                    {
-                        if (m_MinContainerHeight == 0) {
+                        if (m_MinContainerHeight == 0)
+                        {
                             m_MinContainerHeight = container->size().height();
                         }
                         auto acceptMerge = m_AcceptDragWidgetFun(dragWidgetHovered, mimeData);
-                        if (canInsert && (isOnTop || isOnBottom || !canMerge || !acceptMerge)) {
+                        if (canInsert && (isOnTop || isOnBottom || !canMerge || !acceptMerge))
-                            if (posY > (dropIndex + 1) * graphHeight - graphHeight / 2.0) {
+                            if (posY > (dropIndex + 1) * graphHeight - graphHeight / 2.0)
+                            {
                                 dropIndex += 1;
                             }
-                            if (helper.getCurrentDragWidget()) {
+                            if (helper.getCurrentDragWidget())
+                            {
                                 auto dragWidgetIndex = m_Layout->indexOf(helper.getCurrentDragWidget());
-                                if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex) {
+                                if (dragWidgetIndex >= 0 && dragWidgetIndex <= dropIndex)
+                                {
                                     // Correction of the index if the drop occurs in the same container
                                     // and if the drag is started from the visualization (in that case, the
                                     // dragWidget is hidden)
                                 }
                             }
-                            if (dropIndex != placeHolderIndex) {
+                            if (dropIndex != placeHolderIndex)
-                                helper.insertPlaceHolder(m_Layout, dropIndex, m_PlaceHolderType,
-                                                         m_PlaceHolderText);
+                                helper.insertPlaceHolder(
+                                    m_Layout, dropIndex, m_PlaceHolderType, m_PlaceHolderText);
                             }
                             helper.setHightlightedDragWidget(nullptr);
                         }
-                        else if (canMerge && dragWidgetHovered) {
+                        else if (canMerge && dragWidgetHovered)
+                        {
                             // drop on the middle -> merge
-                            if (hasPlaceHolder()) {
+                            if (hasPlaceHolder())
+                            {
                                 helper.removePlaceHolder();
                             }
                             helper.setHightlightedDragWidget(dragWidgetHovered);
                         }
-                        else {
+                        else
+                        {
                             qCWarning(LOG_VisualizationDragDropContainer())
                                 << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no valid drop "
                                       "action.");
                         }
                     }
-                    else {
+                    else
+                    {
                         qCInfo(LOG_VisualizationDragDropContainer())
                             << tr("VisualizationDragDropContainer::findPlaceHolderPosition, no widget "
                                   "found in the "
                                   "container");
                     }
                 }
-                else {
+                else
+                {
                     // the mouse is hover the placeHolder
                     // Do nothing
                 }

meson.build 0 0

NO CONTENT: modified file

plugins/amda/meson.build +10 -2

                                                          qresources : amdaplugin_resources_files,
                                                          ui_files : amdaplugin_ui_files)
+            cpp_args = ['-DAMDA_LIB','-DQT_PLUGIN']
+            message('======================='+get_option('default_library')+'==========================')
+            if(get_option('default_library') == 'static')
+                message('building amda plugin as static lib')
+                cpp_args += ['-DQT_STATICPLUGIN']
+            endif
             sciqlop_amdaplugin = library('amdaplugin',
                                    amdaplugin_sources,
                                    amdaplugin_prep_files,
-                                   cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
+                                   cpp_args : cpp_args,
                                    include_directories : [amdaplugin_inc],
                                    dependencies : [sciqlop_core, sciqlop_gui],
-                                   install : true
+                                   install : true,
+                                   install_dir : join_paths(get_option('libdir'), 'SciQLop')
                                    )

plugins/mockplugin/meson.build +8 -2

             mockplugin_moc_files = gen.process(mockplugin_moc_headers)
+            cpp_args = ['-DMOCKPLUGIN_LIB','-DQT_PLUGIN']
+            if(get_option('default_library')=='static')
+                cpp_args += ['-DQT_STATICPLUGIN']
+            endif
             sciqlop_mockplugin = library('mockplugin',
                                    mockplugin_sources,
                                    mockplugin_moc_files,
-                                   cpp_args : '-DMOCKPLUGIN_LIB',
+                                   cpp_args : cpp_args,
                                    include_directories : [mockplugin_inc],
                                    dependencies : [sciqlop_core, sciqlop_gui],
-                                   install : true
+                                   install : true,
+                                   install_dir : join_paths(get_option('libdir'), 'SciQLop')
                                    )

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