Multiple plots can be plotted in one window on the first try. Therefore i introduced some way to reorganize the already existing axes in a subtab window.

Author: juliuskarliczek

src/sas/qtgui/MainWindow/DataExplorer.py

@@ -1076,20 +1076,19 @@ def displayDataByName(self, name=None, is_data=True, id=None):
                 # Residuals get their own plot
                 if plot.plot_role in [DataRole.ROLE_RESIDUAL, DataRole.ROLE_STAND_ALONE]:
                     plot.yscale = 'linear'
-                    self.plotData([(item, plot)])
+                    self.plotData([(item, plot)], id)
                 else:
                     new_plots.append((item, plot))
 
         if new_plots:
-            self.plotData(new_plots)
+            self.plotData(new_plots, id)
 
-    def displayData(self, data_list, id=None):
+    def displayData(self, data_list, id):
         """
         Forces display of charts for the given data set
         """
-        # data_list = [QStandardItem, [Axes] Data1D/Data2D]
-        plots_to_show = data_list[2:]
-        tpw_ax = data_list[1]
+        # data_list = [QStandardItem, Data1D/Data2D]
+        plots_to_show = data_list[1:]
         plot_item = data_list[0]
 
         # plots to show
@@ -1110,7 +1109,7 @@ def displayData(self, data_list, id=None):
                 if self.isPlotShown(main_data):
                     self.active_plots[main_data.name].showNormal()
                 else:
-                    self.plotData([(plot_item, tpw_ax, main_data)])
+                    self.plotData([(plot_item, main_data)], id)
 
         append = False
         plot_to_append_to = None
@@ -1135,7 +1134,7 @@ def displayData(self, data_list, id=None):
                 continue
             elif role in stand_alone_types:
                 # Stand-alone plots should always be separate
-                self.plotData([(plot_item, tpw_ax, plot_to_show)])
+                self.plotData([(plot_item, plot_to_show)], id)
             elif append:
                 # Assume all other plots sent together should be on the same chart if a previous plot exists
                 if not plot_to_append_to:
@@ -1146,8 +1145,8 @@ def displayData(self, data_list, id=None):
                 # Plots with main data points on the same chart
                 # Get the main data plot unless data is 2D which is plotted earlier
                 if main_data is not None and not isinstance(main_data, Data2D):
-                    new_plots.append((plot_item, tpw_ax, main_data))
-                new_plots.append((plot_item, tpw_ax, plot_to_show))
+                    new_plots.append((plot_item, main_data))
+                new_plots.append((plot_item, plot_to_show))
 
         if append:
             # Append any plots handled in loop before an existing plot was found
@@ -1157,7 +1156,7 @@ def displayData(self, data_list, id=None):
             new_plots = []
 
         if new_plots:
-            self.plotData(new_plots)
+            self.plotData(new_plots, id)
 
         self.parent.tabbedPlotWidget.show_or_activate()
 
@@ -1195,18 +1194,22 @@ def addDataPlot2D(self, plot_set, item):
         # sv.show()
         # ============================================
 
-    def plotData(self, plots, transform=True):
+    def plotData(self, plots, tab_id, transform=True):
         """
         Takes 1D/2D data and generates a single plot (1D) or multiple plots (2D)
         """
+        tab_index = self.parent.tabbedPlotWidget.tab_fitpage_dict[tab_id]
+        print("plotData")
         # Call show on requested plots
         # All same-type charts in one plot
-        for item, tpw_ax, plot_set in plots:
+        for item, plot_set in plots:
             if isinstance(plot_set, Data1D):
                 if 'new_plot' not in locals():
                     # Create only one PlotterWidget(QWidget) for a number of datasets that are supposed to be shown in
                     # the same Widget
-                    print("created PlotterWidget for:", item)
+                    self.parent.tabbedPlotWidget.widget(tab_index).add_more_axes()
+                    tpw_ax = self.parent.tabbedPlotWidget.widget(tab_index).last_axes()
+
                     new_plot = PlotterWidget(manager=self, parent=self, tpw_ax=tpw_ax)
                     new_plot.item = item
                 print("plotted plot for:", item)
@@ -1219,7 +1222,6 @@ def plotData(self, plots, transform=True):
                 msg = "Incorrect data type passed to Plotting"
                 raise AttributeError(msg)
 
-        print("from DataExplorer.plotData: self.active_plots", self.active_plots)
 
         if 'new_plot' in locals() and \
             hasattr(new_plot, 'data') and \
@@ -1295,6 +1297,7 @@ def appendPlot(self):
     @staticmethod
     def appendOrUpdatePlot(self, data, plot):
         name = data.name
+        print("append or update plot")
         if isinstance(plot, Plotter2DWidget) or name in plot.plot_dict.keys():
             plot.replacePlot(name, data)
         else:

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -2449,10 +2449,8 @@ def onPlot(self):
         self.cmdPlot.setText("Compute/Plot")
         # Force data recalculation so existing charts are updated
         if not self.data_is_loaded:
-            print("showTheoryPlot from FittingWidget")
             self.showTheoryPlot()
         else:
-            print("showPlot from FittingWidget")
             self.showPlot()
         # This is an important processEvent.
         # This allows charts to be properly updated in order
@@ -2512,10 +2510,10 @@ def _requestPlots(self, item_name, item_model):
         # send this information to the TabbedPlotWidget so that it can unpack and show the plots as well
         self.parent.tabbedPlotWidget.add_tab(item_name, item_model, self.tab_id)
 
-        tab_index = self.parent.tabbedPlotWidget.tab_fitpage_dict[self.tab_id]
-        tpw_axes = self.parent.tabbedPlotWidget.widget(tab_index).ax
+        # tab_index = self.parent.tabbedPlotWidget.tab_fitpage_dict[self.tab_id]
+        # self.parent.tabbedPlotWidget.widget(tab_index).add_more_axes
+        # tpw_axes = self.parent.tabbedPlotWidget.widget(tab_index).ax
 
-        print("axes received in FittingWidget:", tpw_axes)
 
         fitpage_name = self.kernel_module.name
         plots = GuiUtils.plotsFromDisplayName(item_name, item_model)
@@ -2526,8 +2524,10 @@ def _requestPlots(self, item_name, item_model):
             item, plot = item_plot
             if plot.plot_role != DataRole.ROLE_DATA and fitpage_name in plot.name:
                 data_shown = True
-                self.communicate.plotRequestedSignal.emit([item, tpw_axes[i], plot], self.tab_id)
+                self.communicate.plotRequestedSignal.emit([item, plot], self.tab_id)
         # return the last data item seen, if nothing was plotted; supposed to be just data)
+        tab_index = self.parent.tabbedPlotWidget.tab_fitpage_dict[self.tab_id]
+        self.parent.tabbedPlotWidget.widget(tab_index).rearrange_plots()
         return None if data_shown else item
 
     def onOptionsUpdate(self):

src/sas/qtgui/Plotting/Plotter.py

@@ -240,7 +240,6 @@ def plot(self, data=None, color=None, marker=None, hide_error=False, transform=T
                 ax.axhline(y=-1, color='gray', linestyle='--')
             # Update the list of data sets (plots) in chart
             self.plot_dict[data.name] = data
-            print("from Plotter: self.plot_dict:", self.plot_dict)
 
             self.plot_lines[data.name] = line
 

src/sas/qtgui/Plotting/PlotterBase.py

@@ -36,7 +36,7 @@ def __init__(self, parent=None, manager=None, quickplot=False, tpw_ax=None):
         self.quickplot = quickplot
 
         # Set auto layout so x/y axis captions don't get cut off
-        rcParams.update({'figure.autolayout': True})
+        # rcParams.update({'figure.autolayout': True})
 
         #plt.style.use('ggplot')
         #plt.style.use('seaborn-darkgrid')

src/sas/qtgui/Plotting/SubTabs.py

@@ -2,7 +2,7 @@
 from PySide6 import QtCore
 
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
-from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
 
 from sas.qtgui.Utilities import GuiUtils
 
@@ -36,8 +36,6 @@ def __init__(self, parent: TabbedPlotWidget, plots: list):
     def set_parent_tab_index(self):
         self.parent_tab_index = self.parent.indexOf(self)
         self.tab_id = self.parent.inv_tab_fitpage_dict[self.parent_tab_index]
-        print(self.parent_tab_index)
-        print(self.tab_id)
 
     def add_subtab(self, plots):
         """
@@ -62,34 +60,48 @@ def add_subtab(self, plots):
         # The idea behind creating the figure here already is to feed it to the creation of the canvas right away,
         # because otherwise it can be quite tricky to navigate through all the layers in between to add the figure
         # or manipulate all the axes for example
-        self.figure = Figure(figsize=(5, 5))
-
-        # filling the slots for the plots temporary to try out the functionalities of the dock container and the
-        # clickable canvas
-        print("subplot_count len(plots)", len(plots))
-        subplot_count = len(plots)
-        if subplot_count <= 1:
-            self.ax = self.figure.subplots(subplot_count)
-            # putting the axes object in a list so that the access can be generic for both cases with multiple
-            # subplots and without
-            self.ax = [self.ax]
-        else:
-            # for multiple subplots: decide on the ratios for the bigger, central plot and the smaller, side plots
-            # region for the big central plot in gridspec
-            gridspec = self.figure.add_gridspec(ncols=2, width_ratios=[3, 1])
-            # region for the small side plots in sub_gridspec
-            sub_gridspec = gridspec[1].subgridspec(ncols=1, nrows=subplot_count-1)
-
-            self.ax = [self.figure.add_subplot(gridspec[0])]
-            # add small plots to axes list, so it can be accessed that way
-            for idx in range(subplot_count - 1):
-                self.ax.append(self.figure.add_subplot(sub_gridspec[idx]))
-
-        print("axes created in SubTabs:", self.ax[0])
+        self.figure = plt.figure()
 
         self.addTab(DockContainer(self.figure), str(self.counter))
         self.counter += 1
 
+    def add_more_axes(self):
+        """
+        Simply adds a new subplot to the figure.
+        """
+        self.figure.add_subplot()
+
+    def last_axes(self):
+        """
+        Get the last axes that was created by add_more_axes
+        """
+        return self.figure.get_axes()[-1]
+
+    def rearrange_plots(self):
+        """
+        This method is called after plotting the results for this tab. It arranges the plots in two columns with the
+        big plot on the left side and all the other plots on the right side.
+        """
+        print("rearrange_plots")
+        axes = self.figure.get_axes()
+        if len(axes) > 2:
+            pass # nothing to do, just one plot needs to be shown in the middle
+        elif len(axes) == 2:
+            # two column gridspec needs to be applied
+            self.gs = self.figure.add_gridspec(nrows=1, ncols=2)
+
+            # this for loop cannot be replaced by for ax in axes, because the ax is modified in the list :)
+            for i in range(len(axes)):
+                axes[i].set_position(self.gs[i].get_position(self.figure))
+        else:
+            # subgridspec needs to be applied
+            self.gs = self.figure.add_gridspec(nrows=1, ncols=2)
+            self.sub_gs = self.gs[1].subgridspec(ncols=1, nrows=len(axes)-1)
+
+            axes[0].set_position(self.gs[0].get_position(self.figure))
+            for i in range(len(axes)-1):
+                axes[i+1].set_position(self.gs[i].get_position(self.figure))
+
 
 class DockContainer(QtWidgets.QMainWindow):
     """