Changeset 3bdbfcc in sasview

Timestamp:

Feb 2, 2017 6:29:07 AM (7 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

965fbd8

Parents:

5d89f43

git-author:

Piotr Rozyczko <rozyczko@…> (01/23/17 07:21:03)

git-committer:

Piotr Rozyczko <rozyczko@…> (02/02/17 06:29:07)

Message:

Reimplementation of the slicer functionality

Location:

src/sas

Files:

• qtgui/BoxSum.py (added)
• qtgui/ColorMap.py (modified) (2 diffs)
• qtgui/DataExplorer.py (modified) (2 diffs)
• qtgui/GUITests.py (modified) (2 diffs)
• qtgui/GuiUtils.py (modified) (4 diffs)
• qtgui/Plotter.py (modified) (1 diff)
• qtgui/Plotter2D.py (modified) (10 diffs)
• qtgui/PlotterBase.py (modified) (1 diff)
• qtgui/SlicerModel.py (added)
• qtgui/SlicerParameters.py (added)
• qtgui/UI/BoxSumUI.ui (added)
• qtgui/UI/SlicerParametersUI.ui (added)
• qtgui/UnitTesting/BoxSumTest.py (added)
• qtgui/UnitTesting/Plotter2DTest.py (modified) (3 diffs)
• qtgui/UnitTesting/SlicerModelTest.py (added)
• qtgui/run_tests.bat (modified) (1 diff)
• qtgui/run_tests.sh (modified) (1 diff)
• sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py (modified) (27 diffs)
• sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py (modified) (25 diffs)
• sasgui/guiframe/local_perspectives/plotting/boxSlicer.py (modified) (28 diffs)
• sasgui/guiframe/local_perspectives/plotting/boxSum.py (modified) (37 diffs)

src/sas/qtgui/ColorMap.py

@@ -111 +111 @@
         self.canvas.draw()
 
-    def onApply(self):
-        """
-        Respond to the Apply button click.
-        Send a signal to the plotter with vmin/vmax/cmap for chart update
-        """
-        self.apply_signal.emit(self.norm(), self.cmap())
-
     def initDetectorData(self):
         """
@@ -214 +207 @@
                                             norm=self._norm,
                                             orientation='horizontal')
-        self.cb.set_label('Color map range')
+        self.cb.set_label('Detector Colors')
 
     def onColorMapReversed(self, isChecked):

src/sas/qtgui/DataExplorer.py

@@ -399 +399 @@
         new_plot = Plotter(self)
 
-        def addDataPlot2D(plot_set):
+        def addDataPlot2D(plot_set, item):
             plot2D = Plotter2D(self)
+            plot2D.item = item
             plot2D.plot(plot_set)
             self.plotAdd(plot2D)
 
-        for plot_set in plots:
+        for item, plot_set in plots:
             if isinstance(plot_set, Data1D):
                 new_plot.plot(plot_set)
             elif isinstance(plot_set, Data2D):
-                addDataPlot2D(plot_set)
+                addDataPlot2D(plot_set, item)
             else:
                 msg = "Incorrect data type passed to Plotting"
@@ -450 +451 @@
 
         # Add new data to the old plot, if data type is the same.
-        for plot_set in new_plots:
+        for _, plot_set in new_plots:
             if type(plot_set) is type(old_plot._data):
                 old_plot.data = plot_set

src/sas/qtgui/GUITests.py

@@ -24 +24 @@
 from UnitTesting import PlotUtilitiesTest
 from UnitTesting import ColorMapTest
+from UnitTesting import BoxSumTest
+from UnitTesting import SlicerModelTest
 
 def suite():
@@ -50 +52 @@
         unittest.makeSuite(PlotUtilitiesTest.PlotUtilitiesTest, 'test'),
         unittest.makeSuite(ColorMapTest.ColorMapTest, 'test'),
+        unittest.makeSuite(BoxSumTest.BoxSumTest, 'test'),
+        unittest.makeSuite(SlicerModelTest.SlicerModelTest, 'test'),
     )
     return unittest.TestSuite(suites)

src/sas/qtgui/GuiUtils.py

@@ -242 +242 @@
     assert isinstance(item, QtGui.QStandardItem)
     assert isinstance(update_data, QtCore.QVariant)
+    py_update_data = update_data.toPyObject()
+
+    # Check if data with the same ID is already present
+    for index in range(item.rowCount()):
+        plot_item = item.child(index)
+        if plot_item.isCheckable():
+            plot_data = plot_item.child(0).data().toPyObject()
+            if plot_data.id == py_update_data.id:
+                item.removeRow(index)
+                break
 
     checkbox_item = QtGui.QStandardItem(True)
@@ -249 +259 @@
 
     # Add "Info" item
-    py_update_data = update_data.toPyObject()
     if isinstance(py_update_data, (Data1D or Data2D)):
         # If Data1/2D added - extract Info from it
@@ -298 +307 @@
         if item.isCheckable() and item.checkState() == QtCore.Qt.Checked:
             # TODO: assure item type is correct (either data1/2D or Plotter)
-            plot_data.append(item.child(0).data().toPyObject())
+            plot_data.append((item, item.child(0).data().toPyObject()))
         # Going 1 level deeper only
         for index_2 in range(item.rowCount()):
@@ -304 +313 @@
             if item_2 and item_2.isCheckable() and item_2.checkState() == QtCore.Qt.Checked:
                 # TODO: assure item type is correct (either data1/2D or Plotter)
-                plot_data.append(item_2.child(0).data().toPyObject())
+                plot_data.append((item_2, item_2.child(0).data().toPyObject()))
 
     return plot_data

src/sas/qtgui/Plotter.py

@@ -516 +516 @@
         self.plot(data=self.fit_result, marker='-', hide_error=True)
 
+    def onMplMouseDown(self, event):
+        """
+        Left button down and ready to drag
+        """
+        # Check that the LEFT button was pressed
+        if event.button == 1:
+            self.leftdown = True
+            ax = event.inaxes
+            for text in self.textList:
+                if text.contains(event)[0]: # If user has clicked on text
+                    self.selectedText = text
+                    return
+
+            if ax != None:
+                self.xInit, self.yInit = event.xdata, event.ydata
+                try:
+                    self.x_click = float(event.xdata)  # / size_x
+                    self.y_click = float(event.ydata)  # / size_y
+                except:
+                    self.position = None
+
+    def onMplMouseUp(self, event):
+        """
+        Set the data coordinates of the click
+        """
+        self.x_click = event.xdata
+        self.y_click = event.ydata
+
+        # Check that the LEFT button was released
+        if event.button == 1:
+            self.leftdown = False
+            #self.leftup = True
+            self.selectedText = None
+
+        #release the legend
+        if self.gotLegend == 1:
+            self.gotLegend = 0
+
+    def onMplMouseMotion(self, event):
+        """
+        Check if the left button is press and the mouse in moving.
+        Compute delta for x and y coordinates and then perform the drag
+        """
+        if self.gotLegend == 1 and self.leftdown:
+            self.onLegendMotion(event)
+            return
+
+        if self.leftdown and self.selectedText is not None:
+            # User has clicked on text and is dragging
+            ax = event.inaxes
+            if ax != None:
+                # Only move text if mouse is within axes
+                self.selectedText.set_position((event.xdata, event.ydata))
+                self.canvas.draw_idle()
+            else:
+                # User has dragged outside of axes
+                self.selectedText = None
+            return
+
+    def onMplPick(self, event):
+        """
+        On pick legend
+        """
+        legend = self.legend
+        if event.artist == legend:
+            # Get the box of the legend.
+            bbox = self.legend.get_window_extent()
+            # Get mouse coordinates at time of pick.
+            self.mouse_x = event.mouseevent.x
+            self.mouse_y = event.mouseevent.y
+            # Get legend coordinates at time of pick.
+            self.legend_x = bbox.xmin
+            self.legend_y = bbox.ymin
+            # Indicate we picked up the legend.
+            self.gotLegend = 1
+
+            #self.legend.legendPatch.set_alpha(0.5)
+
+    def onLegendMotion(self, event):
+        """
+        On legend in motion
+        """
+        ax = event.inaxes
+        if ax == None:
+            return
+        # Event occurred inside a plotting area
+        lo_x, hi_x = ax.get_xlim()
+        lo_y, hi_y = ax.get_ylim()
+        # How much the mouse moved.
+        x = mouse_diff_x = self.mouse_x - event.x
+        y = mouse_diff_y = self.mouse_y - event.y
+        # Put back inside
+        if x < lo_x:
+            x = lo_x
+        if x > hi_x:
+            x = hi_x
+        if y < lo_y:
+            y = lo_y
+        if y > hi_y:
+            y = hi_y
+        # Move the legend from its previous location by that same amount
+        loc_in_canvas = self.legend_x - mouse_diff_x, \
+                        self.legend_y - mouse_diff_y
+        # Transform into legend coordinate system
+        trans_axes = self.legend.parent.transAxes.inverted()
+        loc_in_norm_axes = trans_axes.transform_point(loc_in_canvas)
+        self.legend_pos_loc = tuple(loc_in_norm_axes)
+        self.legend._loc = self.legend_pos_loc
+        # self.canvas.draw()
+        self.canvas.draw_idle()
+
+    def onMplWheel(self, event):
+        """
+        Process mouse wheel as zoom events
+        """
+        ax = event.inaxes
+        step = event.step
+
+        if ax != None:
+            # Event occurred inside a plotting area
+            lo, hi = ax.get_xlim()
+            lo, hi = PlotUtilities.rescale(lo, hi, step,
+                              pt=event.xdata, scale=ax.get_xscale())
+            if not self.xscale == 'log' or lo > 0:
+                self._scale_xlo = lo
+                self._scale_xhi = hi
+                ax.set_xlim((lo, hi))
+
+            lo, hi = ax.get_ylim()
+            lo, hi = PlotUtilities.rescale(lo, hi, step, pt=event.ydata,
+                              scale=ax.get_yscale())
+            if not self.yscale == 'log' or lo > 0:
+                self._scale_ylo = lo
+                self._scale_yhi = hi
+                ax.set_ylim((lo, hi))
+        else:
+            # Check if zoom happens in the axes
+            xdata, ydata = None, None
+            x, y = event.x, event.y
+
+            for ax in self.axes:
+                insidex, _ = ax.xaxis.contains(event)
+                if insidex:
+                    xdata, _ = ax.transAxes.inverted().transform_point((x, y))
+                insidey, _ = ax.yaxis.contains(event)
+                if insidey:
+                    _, ydata = ax.transAxes.inverted().transform_point((x, y))
+            if xdata is not None:
+                lo, hi = ax.get_xlim()
+                lo, hi = PlotUtilities.rescale(lo, hi, step,
+                                  bal=xdata, scale=ax.get_xscale())
+                if not self.xscale == 'log' or lo > 0:
+                    self._scale_xlo = lo
+                    self._scale_xhi = hi
+                    ax.set_xlim((lo, hi))
+            if ydata is not None:
+                lo, hi = ax.get_ylim()
+                lo, hi = PlotUtilities.rescale(lo, hi, step, bal=ydata,
+                                  scale=ax.get_yscale())
+                if not self.yscale == 'log' or lo > 0:
+                    self._scale_ylo = lo
+                    self._scale_yhi = hi
+                    ax.set_ylim((lo, hi))
+        self.canvas.draw_idle()
+
 
 class Plotter(QtGui.QDialog, PlotterWidget):

src/sas/qtgui/Plotter2D.py

@@ -11 +11 @@
 
 import sas.qtgui.PlotUtilities as PlotUtilities
+import sas.qtgui.GuiUtils as GuiUtils
 from sas.qtgui.PlotterBase import PlotterBase
 from sas.qtgui.ColorMap import ColorMap
+from sas.sasgui.guiframe.dataFitting import Data1D
 from sas.sasgui.guiframe.dataFitting import Data2D
+from sas.sascalc.dataloader.manipulations import CircularAverage
+from sas.sasgui.guiframe.local_perspectives.plotting.binder import BindArtist
+from sas.qtgui.BoxSum import BoxSum
+from sas.qtgui.GuiUtils import formatNumber
+from sas.qtgui.SlicerParameters import SlicerParameters
+from sas.sasgui.guiframe.local_perspectives.plotting.boxSlicer import BoxInteractorX
+from sas.sasgui.guiframe.local_perspectives.plotting.AnnulusSlicer import AnnulusInteractor
+from sas.sasgui.guiframe.local_perspectives.plotting.SectorSlicer import SectorInteractor
+from sas.sasgui.guiframe.local_perspectives.plotting.boxSum import BoxSumCalculator
+from sas.sasgui.guiframe.local_perspectives.plotting.boxSlicer import BoxInteractorY
 
 # Minimum value of Z for which we will present data.
-MIN_Z=-32
+MIN_Z = -32
 
 class Plotter2DWidget(PlotterBase):
@@ -29 +41 @@
         # Default scale
         self.scale = 'log_{10}'
+        # to set the order of lines drawn first.
+        self.slicer_z = 5
+        # Reference to the current slicer
+        self.slicer = None
+        # Create Artist and bind it
+        self.connect = BindArtist(self.figure)
         self.vmin = None
         self.vmax = None
@@ -53 +71 @@
         self.title(title=data.title)
 
-    def plot(self, data=None, marker=None, linestyle=None):
+    @property
+    def item(self):
+        ''' getter for this plot's QStandardItem '''
+        return self._item
+
+    @item.setter
+    def item(self, item=None):
+        ''' setter for this plot's QStandardItem '''
+        self._item = item
+
+    def plot(self, data=None):
         """
         Plot 2D self._data
@@ -61 +89 @@
             self.data = data
 
-        assert(self._data)
+        assert self._data
 
         # Toggle the scale
@@ -128 +156 @@
         self.actionBoxAveragingY = self.contextMenu.addAction("&Box Averaging in Qy")
         self.actionBoxAveragingY.triggered.connect(self.onBoxAveragingY)
-        self.contextMenu.addSeparator()
-        self.actionEditGraphLabel = self.contextMenu.addAction("&Edit Graph Label")
-        self.actionEditGraphLabel.triggered.connect(self.onEditgraphLabel)
+        # Additional items for slicer interaction
+        if self.slicer:
+            self.actionClearSlicer = self.contextMenu.addAction("&Clear Slicer")
+            self.actionClearSlicer.triggered.connect(self.onClearSlicer)
+            self.actionEditSlicer = self.contextMenu.addAction("&Edit Slicer Parameters")
+            self.actionEditSlicer.triggered.connect(self.onEditSlicer)
         self.contextMenu.addSeparator()
         self.actionColorMap = self.contextMenu.addAction("&2D Color Map")
@@ -166 +197 @@
         self.plot()
 
+    def onClearSlicer(self):
+        """
+        Remove all sclicers from the chart
+        """
+        if self.slicer:
+            self.slicer.clear()
+            self.canvas.draw()
+            self.slicer = None
+
+    def onEditSlicer(self):
+        """
+        Present a small dialog for manipulating the current slicer
+        """
+        assert self.slicer
+
+        self.param_model = self.slicer.model()
+         # Pass the model to the Slicer Parameters widget
+        self.slicer_widget = SlicerParameters(self, model=self.param_model)
+        self.slicer_widget.show()
+
     def onCircularAverage(self):
         """
-        """
-        pass
+        Perform circular averaging on Data2D
+        """
+        # Find the best number of bins
+        npt = numpy.sqrt(len(self.data.data[numpy.isfinite(self.data.data)]))
+        npt = numpy.floor(npt)
+        # compute the maximum radius of data2D
+        self.qmax = max(numpy.fabs(self.data.xmax),
+                        numpy.fabs(self.data.xmin))
+        self.ymax = max(numpy.fabs(self.data.ymax),
+                        numpy.fabs(self.data.ymin))
+        self.radius = numpy.sqrt(numpy.power(self.qmax, 2) + numpy.power(self.ymax, 2))
+        #Compute beam width
+        bin_width = (self.qmax + self.qmax) / npt
+        # Create data1D circular average of data2D
+        circle = CircularAverage(r_min=0, r_max=self.radius, bin_width=bin_width)
+        circ = circle(self.data)
+        dxl = circ.dxl if hasattr(circ, "dxl") else None
+        dxw = circ.dxw if hasattr(circ, "dxw") else None
+
+        new_plot = Data1D(x=circ.x, y=circ.y, dy=circ.dy, dx=circ.dx)
+        new_plot.dxl = dxl
+        new_plot.dxw = dxw
+        new_plot.name = new_plot.title = "Circ avg " + self.data.name
+        new_plot.source = self.data.source
+        new_plot.interactive = True
+        new_plot.detector = self.data.detector
+
+        # Define axes if not done yet.
+        new_plot.xaxis("\\rm{Q}", "A^{-1}")
+        if hasattr(self.data, "scale") and \
+                    self.data.scale == 'linear':
+            new_plot.ytransform = 'y'
+            new_plot.yaxis("\\rm{Residuals} ", "normalized")
+        else:
+            new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}")
+
+        new_plot.group_id = "2daverage" + self.data.name
+        new_plot.id = "Circ avg " + self.data.name
+        new_plot.is_data = True
+        variant_plot = QtCore.QVariant(new_plot)
+        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id)
+        # TODO: force immediate display (?)
+
+    def setSlicer(self, slicer):
+        """
+        Clear the previous slicer and create a new one.
+        slicer: slicer class to create
+        """
+        # Clear current slicer
+        if self.slicer is not None:
+            self.slicer.clear()
+        # Create a new slicer
+        self.slicer_z += 1
+        self.slicer = slicer(self, self.ax, item=self._item, zorder=self.slicer_z)
+        self.ax.set_ylim(self.data.ymin, self.data.ymax)
+        self.ax.set_xlim(self.data.xmin, self.data.xmax)
+        # Draw slicer
+        self.figure.canvas.draw()
+        self.slicer.update()
 
     def onSectorView(self):
         """
-        """
-        pass
+        Perform sector averaging on Q and draw sector slicer
+        """
+        self.setSlicer(slicer=SectorInteractor)
 
     def onAnnulusView(self):
         """
-        """
-        pass
+        Perform sector averaging on Phi and draw annulus slicer
+        """
+        self.setSlicer(slicer=AnnulusInteractor)
 
     def onBoxSum(self):
         """
-        """
-        pass
+        Perform 2D Data averaging Qx and Qy.
+        Display box slicer details.
+        """
+        self.onClearSlicer()
+        self.slicer_z += 1
+        self.slicer = BoxSumCalculator(self, self.ax, zorder=self.slicer_z)
+
+        self.ax.set_ylim(self.data.ymin, self.data.ymax)
+        self.ax.set_xlim(self.data.xmin, self.data.xmax)
+        self.figure.canvas.draw()
+        self.slicer.update()
+
+        # Get the BoxSumCalculator model.
+        self.box_sum_model = self.slicer.model()
+        # Pass the BoxSumCalculator model to the BoxSum widget
+        self.boxwidget = BoxSum(self, model=self.box_sum_model)
+        # Add the plot to the workspace
+        self.manager.parent.workspace().addWindow(self.boxwidget)
+        self.boxwidget.show()
 
     def onBoxAveragingX(self):
         """
-        """
-        pass
+        Perform 2D data averaging on Qx
+        Create a new slicer.
+        """
+        self.setSlicer(slicer=BoxInteractorX)
 
     def onBoxAveragingY(self):
         """
-        """
-        pass
-
-    def onEditgraphLabel(self):
-        """
-        """
-        pass
+        Perform 2D data averaging on Qy
+        Create a new slicer .
+        """
+        self.setSlicer(slicer=BoxInteractorY)
 
     def onColorMap(self):
@@ -225 +351 @@
 
     def showPlot(self, data, qx_data, qy_data, xmin, xmax, ymin, ymax,
-                 zmin, zmax, color=0, symbol=0, markersize=0,
-                 label='data2D', cmap=DEFAULT_CMAP):
+                 zmin, zmax, label='data2D', cmap=DEFAULT_CMAP):
         """
         Render and show the current data
@@ -310 +435 @@
             self.figure.subplots_adjust(left=0.1, right=.8, bottom=.1)
 
-            X = self._data.x_bins[0:-1]
-            Y = self._data.y_bins[0:-1]
-            X, Y = numpy.meshgrid(X, Y)
+            data_x, data_y = numpy.meshgrid(self._data.x_bins[0:-1],
+                                            self._data.y_bins[0:-1])
 
             ax = Axes3D(self.figure)
@@ -319 +443 @@
             # TODO: Define "large" for a dataset
             SET_TOO_LARGE = 500
-            if len(X) > SET_TOO_LARGE:
+            if len(data_x) > SET_TOO_LARGE:
                 ax.disable_mouse_rotation()
 
             self.figure.canvas.resizing = False
-            im = ax.plot_surface(X, Y, output, rstride=1, cstride=1, cmap=cmap,
+            im = ax.plot_surface(data_x, data_y, output, rstride=1,
+                                 cstride=1, cmap=cmap,
                                  linewidth=0, antialiased=False)
             self.ax.set_axis_off()
@@ -332 +457 @@
             self.figure.canvas.draw()
 
+    def update(self):
+        self.figure.canvas.draw()
+
+    def draw(self):
+        self.figure.canvas.draw()
+
+
 class Plotter2D(QtGui.QDialog, Plotter2DWidget):
+    """
+    Plotter widget implementation
+    """
     def __init__(self, parent=None, quickplot=False, dimension=2):
-
         QtGui.QDialog.__init__(self)
         Plotter2DWidget.__init__(self, manager=parent, quickplot=quickplot, dimension=dimension)

src/sas/qtgui/PlotterBase.py

@@ -220 +220 @@
         self.contextMenu.exec_(self.canvas.mapToGlobal(event_pos))
 
+    def onMplMouseUp(self, event):
+        """
+        Mouse button up callback
+        """
+        pass
+
     def onMplMouseDown(self, event):
         """
-        Left button down and ready to drag
-        """
-        # Check that the LEFT button was pressed
-        if event.button == 1:
-            self.leftdown = True
-            ax = event.inaxes
-            for text in self.textList:
-                if text.contains(event)[0]: # If user has clicked on text
-                    self.selectedText = text
-                    return
-
-            if ax != None:
-                self.xInit, self.yInit = event.xdata, event.ydata
-                try:
-                    self.x_click = float(event.xdata)  # / size_x
-                    self.y_click = float(event.ydata)  # / size_y
-                except:
-                    self.position = None
-
-    def onMplMouseUp(self, event):
-        """
-        Set the data coordinates of the click
-        """
-        self.x_click = event.xdata
-        self.y_click = event.ydata
-
-        # Check that the LEFT button was released
-        if event.button == 1:
-            self.leftdown = False
-            #self.leftup = True
-            self.selectedText = None
-
-        #release the legend
-        if self.gotLegend == 1:
-            self.gotLegend = 0
+        Mouse button down callback
+        """
+        pass
 
     def onMplMouseMotion(self, event):
         """
-        Check if the left button is press and the mouse in moving.
-        Compute delta for x and y coordinates and then perform the drag
-        """
-        if self.gotLegend == 1 and self.leftdown:
-            self.onLegendMotion(event)
-            return
-
-        if self.leftdown and self.selectedText is not None:
-            # User has clicked on text and is dragging
-            ax = event.inaxes
-            if ax != None:
-                # Only move text if mouse is within axes
-                self.selectedText.set_position((event.xdata, event.ydata))
-                self.canvas.draw_idle()
-            else:
-                # User has dragged outside of axes
-                self.selectedText = None
-            return
+        Mouse motion callback
+        """
+        pass
 
     def onMplPick(self, event):
         """
-        On pick legend
-        """
-        legend = self.legend
-        if event.artist == legend:
-            # Get the box of the legend.
-            bbox = self.legend.get_window_extent()
-            # Get mouse coordinates at time of pick.
-            self.mouse_x = event.mouseevent.x
-            self.mouse_y = event.mouseevent.y
-            # Get legend coordinates at time of pick.
-            self.legend_x = bbox.xmin
-            self.legend_y = bbox.ymin
-            # Indicate we picked up the legend.
-            self.gotLegend = 1
-
-            #self.legend.legendPatch.set_alpha(0.5)
-
-    def onLegendMotion(self, event):
-        """
-        On legend in motion
-        """
-        ax = event.inaxes
-        if ax == None:
-            return
-        # Event occurred inside a plotting area
-        lo_x, hi_x = ax.get_xlim()
-        lo_y, hi_y = ax.get_ylim()
-        # How much the mouse moved.
-        x = mouse_diff_x = self.mouse_x - event.x
-        y = mouse_diff_y = self.mouse_y - event.y
-        # Put back inside
-        if x < lo_x:
-            x = lo_x
-        if x > hi_x:
-            x = hi_x
-        if y < lo_y:
-            y = lo_y
-        if y > hi_y:
-            y = hi_y
-        # Move the legend from its previous location by that same amount
-        loc_in_canvas = self.legend_x - mouse_diff_x, \
-                        self.legend_y - mouse_diff_y
-        # Transform into legend coordinate system
-        trans_axes = self.legend.parent.transAxes.inverted()
-        loc_in_norm_axes = trans_axes.transform_point(loc_in_canvas)
-        self.legend_pos_loc = tuple(loc_in_norm_axes)
-        self.legend._loc = self.legend_pos_loc
-        # self.canvas.draw()
-        self.canvas.draw_idle()
+        Mouse pick callback
+        """
+        pass
 
     def onMplWheel(self, event):
         """
-        Process mouse wheel as zoom events
-        """
-        ax = event.inaxes
-        step = event.step
-
-        if ax != None:
-            # Event occurred inside a plotting area
-            lo, hi = ax.get_xlim()
-            lo, hi = PlotUtilities.rescale(lo, hi, step,
-                              pt=event.xdata, scale=ax.get_xscale())
-            if not self.xscale == 'log' or lo > 0:
-                self._scale_xlo = lo
-                self._scale_xhi = hi
-                ax.set_xlim((lo, hi))
-
-            lo, hi = ax.get_ylim()
-            lo, hi = PlotUtilities.rescale(lo, hi, step, pt=event.ydata,
-                              scale=ax.get_yscale())
-            if not self.yscale == 'log' or lo > 0:
-                self._scale_ylo = lo
-                self._scale_yhi = hi
-                ax.set_ylim((lo, hi))
-        else:
-            # Check if zoom happens in the axes
-            xdata, ydata = None, None
-            x, y = event.x, event.y
-
-            for ax in self.axes:
-                insidex, _ = ax.xaxis.contains(event)
-                if insidex:
-                    xdata, _ = ax.transAxes.inverted().transform_point((x, y))
-                insidey, _ = ax.yaxis.contains(event)
-                if insidey:
-                    _, ydata = ax.transAxes.inverted().transform_point((x, y))
-            if xdata is not None:
-                lo, hi = ax.get_xlim()
-                lo, hi = PlotUtilities.rescale(lo, hi, step,
-                                  bal=xdata, scale=ax.get_xscale())
-                if not self.xscale == 'log' or lo > 0:
-                    self._scale_xlo = lo
-                    self._scale_xhi = hi
-                    ax.set_xlim((lo, hi))
-            if ydata is not None:
-                lo, hi = ax.get_ylim()
-                lo, hi = PlotUtilities.rescale(lo, hi, step, bal=ydata,
-                                  scale=ax.get_yscale())
-                if not self.yscale == 'log' or lo > 0:
-                    self._scale_ylo = lo
-                    self._scale_yhi = hi
-                    ax.set_ylim((lo, hi))
-        self.canvas.draw_idle()
+        Mouse wheel scroll callback
+        """
+        pass
 
     def clean(self):

src/sas/qtgui/UnitTesting/Plotter2DTest.py

@@ -1 +1 @@
 import sys
 import unittest
+import numpy
 
 from PyQt4 import QtGui
@@ -24 +25 @@
     def setUp(self):
         '''create'''
-        self.plotter = Plotter2D.Plotter2D(None, quickplot=True)
+        class dummy_manager(object):
+            def communicator(self):
+                return Communicate()
+            def perspective(self):
+                return MyPerspective()
+            def workspace(self):
+                return None
+
+        self.plotter = Plotter2D.Plotter2D(parent=dummy_manager(), quickplot=True)
 
         self.data = Data2D(image=[0.1]*4,
@@ -103 +112 @@
 
         self.assertTrue(FigureCanvas.draw_idle.called)
+
+    def testOnBoxSum(self):
+        """ Test the box sum display and functionality """
+
+        # hacky way to make things work in manipulations._sum
+        self.data.detector = [1]
+        self.data.err_data = numpy.array([0.0, 0.0, 0.1, 0.0])
+        self.plotter.data = self.data
+        self.plotter.show()
+
+        # Mock the main window
+        self.plotter.manager.parent = MagicMock()
+
+        # Call the main tested method
+        self.plotter.onBoxSum()
+
+        # Test various properties
+        self.assertIsInstance(self.plotter.slicer.model(), QtGui.QStandardItemModel)
+        self.assertTrue(self.plotter.boxwidget.isVisible())
+        self.assertIsInstance(self.plotter.boxwidget.model, QtGui.QStandardItemModel)
 
     def testContextMenuQuickPlot(self):

src/sas/qtgui/run_tests.bat

@@ -23 +23 @@
 python -m UnitTesting.PlotUtilitiesTest
 python -m UnitTesting.ColorMapTest
+python -m UnitTesting.BoxSumTest
+python -m UnitTesting.SlicerModelTest

src/sas/qtgui/run_tests.sh

@@ -22 +22 @@
 python -m UnitTesting.PlotUtilitiesTest
 python -m UnitTesting.ColorMapTest
+python -m UnitTesting.BoxSumTest
+python -m UnitTesting.SlicerModelTest

src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py

@@ -1 @@
-# TODO: the line slicer should listen to all 2DREFRESH events, get the data and slice it
-#      before pushing a new 1D data update.
-
-#
-# TODO: NEED MAJOR REFACTOR
-#
-
-import math
-import wx
-# from copy import deepcopy
-# Debug printout
-from sas.sasgui.guiframe.events import NewPlotEvent
-from sas.sasgui.guiframe.events import StatusEvent
-from sas.sasgui.guiframe.events import SlicerParameterEvent
-from sas.sasgui.guiframe.events import EVT_SLICER_PARS
+import numpy
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
 from BaseInteractor import _BaseInteractor
 from sas.sasgui.guiframe.dataFitting import Data1D
-
-class AnnulusInteractor(_BaseInteractor):
+import sas.qtgui.GuiUtils as GuiUtils
+from sas.qtgui.GuiUtils import formatNumber
+from sas.qtgui.SlicerModel import SlicerModel
+
+class AnnulusInteractor(_BaseInteractor, SlicerModel):
     """
     Select an annulus through a 2D plot.
@@ -24 +16 @@
     this class is defined by 2 Ringinterators.
     """
-    def __init__(self, base, axes, color='black', zorder=3):
+    def __init__(self, base, axes, item=None, color='black', zorder=3):
 
         _BaseInteractor.__init__(self, base, axes, color=color)
+        SlicerModel.__init__(self)
+
         self.markers = []
         self.axes = axes
         self.base = base
-        self.qmax = min(math.fabs(self.base.data2D.xmax),
-                        math.fabs(self.base.data2D.xmin))  # must be positive
+        self._item = item
+        self.qmax = min(numpy.fabs(self.base.data.xmax),
+                        numpy.fabs(self.base.data.xmin))  # must be positive
         self.connect = self.base.connect
 
-        # # Number of points on the plot
+        # Number of points on the plot
         self.nbins = 36
         # Cursor position of Rings (Left(-1) or Right(1))
-        self.xmaxd = self.base.data2D.xmax
-        self.xmind = self.base.data2D.xmin
+        self.xmaxd = self.base.data.xmax
+        self.xmind = self.base.data.xmin
 
         if (self.xmaxd + self.xmind) > 0:
@@ -45 +40 @@
             self.sign = -1
         # Inner circle
-        self.inner_circle = RingInteractor(self, self.base.subplot,
+        self.inner_circle = RingInteractor(self, self.axes,
                                            zorder=zorder,
                                            r=self.qmax / 2.0, sign=self.sign)
         self.inner_circle.qmax = self.qmax
-        self.outer_circle = RingInteractor(self, self.base.subplot,
+        self.outer_circle = RingInteractor(self, self.axes,
                                            zorder=zorder + 1, r=self.qmax / 1.8,
                                            sign=self.sign)
@@ -56 +51 @@
         self._post_data()
 
-        # Bind to slice parameter events
-        self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
-
-    def _onEVT_SLICER_PARS(self, event):
-        """
-        receive an event containing parameters values to reset the slicer
-
-        :param event: event of type SlicerParameterEvent with params as
-            attribute
-
-        """
-        wx.PostEvent(self.base,
-                     StatusEvent(status="AnnulusSlicer._onEVT_SLICER_PARS"))
-        event.Skip()
-        if event.type == self.__class__.__name__:
-            self.set_params(event.params)
-            self.base.update()
+        self.setModelFromParams()
 
     def set_layer(self, n):
@@ -92 +71 @@
         self.inner_circle.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -108 +86 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.inner_circle.save(ev)
         self.outer_circle.save(ev)
@@ -120 +97 @@
         """
         # Data to average
-        data = self.base.data2D
-        # If we have no data, just return
-        if data == None:
+        data = self.base.data
+        if data is None:
             return
 
         from sas.sascalc.dataloader.manipulations import Ring
-        rmin = min(math.fabs(self.inner_circle.get_radius()),
-                   math.fabs(self.outer_circle.get_radius()))
-        rmax = max(math.fabs(self.inner_circle.get_radius()),
-                   math.fabs(self.outer_circle.get_radius()))
-        # if the user does not specify the numbers of points to plot
+        rmin = min(numpy.fabs(self.inner_circle.get_radius()),
+                   numpy.fabs(self.outer_circle.get_radius()))
+        rmax = max(numpy.fabs(self.inner_circle.get_radius()),
+                   numpy.fabs(self.outer_circle.get_radius()))
+        # If the user does not specify the numbers of points to plot
         # the default number will be nbins= 36
-        if nbins == None:
+        if nbins is None:
             self.nbins = 36
         else:
             self.nbins = nbins
-        # # create the data1D Q average of data2D
+        # Create the data1D Q average of data2D
         sect = Ring(r_min=rmin, r_max=rmax, nbins=self.nbins)
-        sector = sect(self.base.data2D)
+        sector = sect(self.base.data)
 
         if hasattr(sector, "dxl"):
@@ -148 +124 @@
         else:
             dxw = None
-        new_plot = Data1D(x=(sector.x - math.pi) * 180 / math.pi,
+        new_plot = Data1D(x=(sector.x - numpy.pi) * 180 / numpy.pi,
                           y=sector.y, dy=sector.dy)
         new_plot.dxl = dxl
         new_plot.dxw = dxw
-        new_plot.name = "AnnulusPhi" + "(" + self.base.data2D.name + ")"
-
-        new_plot.source = self.base.data2D.source
-        # new_plot.info=self.base.data2D.info
+        new_plot.name = "AnnulusPhi" + "(" + self.base.data.name + ")"
+        new_plot.title = "AnnulusPhi" + "(" + self.base.data.name + ")"
+
+        new_plot.source = self.base.data.source
         new_plot.interactive = True
-        new_plot.detector = self.base.data2D.detector
+        new_plot.detector = self.base.data.detector
         # If the data file does not tell us what the axes are, just assume...
         new_plot.xaxis("\\rm{\phi}", 'degrees')
         new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}")
         if hasattr(data, "scale") and data.scale == 'linear' and \
-                self.base.data2D.name.count("Residuals") > 0:
+                self.base.data.name.count("Residuals") > 0:
             new_plot.ytransform = 'y'
             new_plot.yaxis("\\rm{Residuals} ", "/")
 
-        new_plot.group_id = "AnnulusPhi" + self.base.data2D.name
-        new_plot.id = "AnnulusPhi" + self.base.data2D.name
+        new_plot.group_id = "AnnulusPhi" + self.base.data.name
+        new_plot.id = "AnnulusPhi" + self.base.data.name
         new_plot.is_data = True
         new_plot.xtransform = "x"
         new_plot.ytransform = "y"
-        self.base.parent.update_theory(data_id=data.id, theory=new_plot)
-        wx.PostEvent(self.base.parent, NewPlotEvent(plot=new_plot, title="AnnulusPhi"))
+        variant_plot = QtCore.QVariant(new_plot)
+        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id)
+
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
+
 
     def moveend(self, ev):
         """
         Called when any dragging motion ends.
-        Post an event (type =SlicerParameterEvent)
-        to plotter 2D with a copy  slicer parameters
-        Call  _post_data method
-        """
-        self.base.thaw_axes()
-        # Post parameters to plotter 2D
-        event = SlicerParameterEvent()
-        event.type = self.__class__.__name__
-        event.params = self.get_params()
-        wx.PostEvent(self.base, event)
+        Redraw the plot with new parameters.
+        """
+        self._post_data(self.nbins)
 
     def restore(self):
@@ -204 +178 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
-
         :return params: the dictionary created
-
         """
         params = {}
-        params["inner_radius"] = math.fabs(self.inner_circle._inner_mouse_x)
-        params["outer_radius"] = math.fabs(self.outer_circle._inner_mouse_x)
+        params["inner_radius"] = numpy.fabs(self.inner_circle._inner_mouse_x)
+        params["outer_radius"] = numpy.fabs(self.outer_circle._inner_mouse_x)
         params["nbins"] = self.nbins
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -224 +196 @@
         :param params: a dictionary containing name of slicer parameters and
             values the user assigned to the slicer.
-
-        """
-        inner = math.fabs(params["inner_radius"])
-        outer = math.fabs(params["outer_radius"])
+        """
+        inner = numpy.fabs(params["inner_radius"])
+        outer = numpy.fabs(params["outer_radius"])
         self.nbins = int(params["nbins"])
-        # # Update the picture
+        # Update the picture
         self.inner_circle.set_cursor(inner, self.inner_circle._inner_mouse_y)
         self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y)
-        # # Post the data given the nbins entered by the user
+        # Post the data given the nbins entered by the user
         self._post_data(self.nbins)
-
-    def freeze_axes(self):
-        """
-        """
-        self.base.freeze_axes()
-
-    def thaw_axes(self):
-        """
-        """
-        self.base.thaw_axes()
 
     def draw(self):
@@ -278 +239 @@
         self.sign = sign
         # # Create a marker
-        try:
-            # Inner circle marker
-            x_value = [self.sign * math.fabs(self._inner_mouse_x)]
-            self.inner_marker = self.axes.plot(x_value, [0], linestyle='',
-                                               marker='s', markersize=10,
-                                               color=self.color, alpha=0.6,
-                                               pickradius=5, label="pick",
-                                               zorder=zorder,
-                                               visible=True)[0]
-        except:
-            x_value = [self.sign * math.fabs(self._inner_mouse_x)]
-            self.inner_marker = self.axes.plot(x_value, [0], linestyle='',
-                                               marker='s', markersize=10,
-                                               color=self.color, alpha=0.6,
-                                               label="pick",
-                                               visible=True)[0]
-            message = "\nTHIS PROTOTYPE NEEDS THE LATEST"
-            message += " VERSION OF MATPLOTLIB\n"
-            message += "Get the SVN version that is at "
-            message += " least as recent as June 1, 2007"
-
-            owner = self.base.base.parent
-            wx.PostEvent(owner, StatusEvent(status="AnnulusSlicer: %s" % message))
-
+        # Inner circle marker
+        x_value = [self.sign * numpy.fabs(self._inner_mouse_x)]
+        self.inner_marker = self.axes.plot(x_value, [0], linestyle='',
+                                           marker='s', markersize=10,
+                                           color=self.color, alpha=0.6,
+                                           pickradius=5, label="pick",
+                                           zorder=zorder,
+                                           visible=True)[0]
         # Draw a circle
         [self.inner_circle] = self.axes.plot([], [], linestyle='-', marker='', color=self.color)
-        # the number of points that make the ring line
+        # The number of points that make the ring line
         self.npts = 40
 
@@ -325 +270 @@
         """
         self.clear_markers()
-        try:
-            self.inner_marker.remove()
-            self.inner_circle.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.inner_marker.remove()
+        self.inner_circle.remove()
 
     def get_radius(self):
@@ -347 +287 @@
         y = []
         for i in range(self.npts):
-            phi = 2.0 * math.pi / (self.npts - 1) * i
-
-            xval = 1.0 * self._inner_mouse_x * math.cos(phi)
-            yval = 1.0 * self._inner_mouse_x * math.sin(phi)
+            phi = 2.0 * numpy.pi / (self.npts - 1) * i
+
+            xval = 1.0 * self._inner_mouse_x * numpy.cos(phi)
+            yval = 1.0 * self._inner_mouse_x * numpy.sin(phi)
 
             x.append(xval)
             y.append(yval)
 
-        self.inner_marker.set(xdata=[self.sign * math.fabs(self._inner_mouse_x)],
+        self.inner_marker.set(xdata=[self.sign * numpy.fabs(self._inner_mouse_x)],
                               ydata=[0])
         self.inner_circle.set_data(x, y)
@@ -366 +306 @@
         self._inner_save_x = self._inner_mouse_x
         self._inner_save_y = self._inner_mouse_y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -396 +335 @@
         self.update()
 
-
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
-
         :return params: the dictionary created
-
         """
         params = {}
-        params["radius"] = math.fabs(self._inner_mouse_x)
+        params["radius"] = numpy.fabs(self._inner_mouse_x)
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -435 +371 @@
         self.base = base
         self.is_inside = side
-        self.qmax = min(math.fabs(self.base.data.xmax),
-                        math.fabs(self.base.data.xmin))  # must be positive
+        self.qmax = min(numpy.fabs(self.base.data.xmax),
+                        numpy.fabs(self.base.data.xmin))  # must be positive
         self.connect = self.base.connect
 
@@ -448 +384 @@
             self.sign = -1
         # Inner circle
-        self.outer_circle = RingInteractor(self, self.base.subplot, 'blue',
+        self.outer_circle = RingInteractor(self, self.axes, 'blue',
                                            zorder=zorder + 1, r=self.qmax / 1.8,
                                            sign=self.sign)
@@ -455 +391 @@
         self._post_data()
 
-        # Bind to slice parameter events
-        # self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
-
-    def _onEVT_SLICER_PARS(self, event):
-        """
-        receive an event containing parameters values to reset the slicer
-
-        :param event: event of type SlicerParameterEvent with params as
-            attribute
-        """
-        wx.PostEvent(self.base,
-                     StatusEvent(status="AnnulusSlicer._onEVT_SLICER_PARS"))
-        event.Skip()
-        if event.type == self.__class__.__name__:
-            self.set_params(event.params)
-            self.base.update()
-
     def set_layer(self, n):
         """
         Allow adding plot to the same panel
-
         :param n: the number of layer
-
         """
         self.layernum = n
@@ -489 +406 @@
         self.outer_circle.clear()
         self.base.connect.clearall()
-        # self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -498 +414 @@
         # Update locations
         self.outer_circle.update()
-        # if self.is_inside != None:
+        self._post_data()
         out = self._post_data()
         return out
@@ -507 +423 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.outer_circle.save(ev)
 
@@ -521 +436 @@
 
         # If we have no data, just return
-        if data == None:
+        if data is None:
             return
         mask = data.mask
@@ -527 +442 @@
 
         rmin = 0
-        rmax = math.fabs(self.outer_circle.get_radius())
-
-        # # create the data1D Q average of data2D
+        rmax = numpy.fabs(self.outer_circle.get_radius())
+
+        # Create the data1D Q average of data2D
         mask = Ringcut(r_min=rmin, r_max=rmax)
 
@@ -536 +451 @@
         else:
             out = (mask(data))
-        # self.base.data.mask=out
         return out
 
@@ -566 +480 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -574 +488 @@
         """
         params = {}
-        params["outer_radius"] = math.fabs(self.outer_circle._inner_mouse_x)
+        params["outer_radius"] = numpy.fabs(self.outer_circle._inner_mouse_x)
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -585 +499 @@
             values the user assigned to the slicer.
         """
-        outer = math.fabs(params["outer_radius"])
-        # # Update the picture
+        outer = numpy.fabs(params["outer_radius"])
+        # Update the picture
         self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y)
-        # # Post the data given the nbins entered by the user
+        # Post the data given the nbins entered by the user
         self._post_data()
-
-    def freeze_axes(self):
-        self.base.freeze_axes()
-
-    def thaw_axes(self):
-        self.base.thaw_axes()
 
     def draw(self):

src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

@@ -3 +3 @@
 """
 import math
-import wx
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
 from BaseInteractor import _BaseInteractor
-from sas.sasgui.guiframe.events import NewPlotEvent
-from sas.sasgui.guiframe.events import StatusEvent
-from sas.sasgui.guiframe.events import SlicerParameterEvent
-from sas.sasgui.guiframe.events import EVT_SLICER_PARS
 from sas.sasgui.guiframe.dataFitting import Data1D
-
-
-class SectorInteractor(_BaseInteractor):
+import sas.qtgui.GuiUtils as GuiUtils
+from sas.qtgui.SlicerModel import SlicerModel
+
+
+class SectorInteractor(_BaseInteractor, SlicerModel):
     """
     Draw a sector slicer.Allow to performQ averaging on data 2D
     """
-    def __init__(self, base, axes, color='black', zorder=3):
+    def __init__(self, base, axes, item=None, color='black', zorder=3):
 
         _BaseInteractor.__init__(self, base, axes, color=color)
-        ## Class initialization
+        SlicerModel.__init__(self)
+        # Class initialization
         self.markers = []
         self.axes = axes
-        ## connect the plot to event
+        self._item = item
+        # Connect the plot to event
         self.connect = self.base.connect
 
-        ## compute qmax limit to reset the graph
-        x = math.pow(max(self.base.data2D.xmax,
-                         math.fabs(self.base.data2D.xmin)), 2)
-        y = math.pow(max(self.base.data2D.ymax,
-                         math.fabs(self.base.data2D.ymin)), 2)
+        # Compute qmax limit to reset the graph
+        x = math.pow(max(self.base.data.xmax,
+                         math.fabs(self.base.data.xmin)), 2)
+        y = math.pow(max(self.base.data.ymax,
+                         math.fabs(self.base.data.ymin)), 2)
         self.qmax = math.sqrt(x + y)
-        ## Number of points on the plot
+        # Number of points on the plot
         self.nbins = 20
-        ## Angle of the middle line
+        # Angle of the middle line
         self.theta2 = math.pi / 3
-        ## Absolute value of the Angle between the middle line and any side line
+        # Absolute value of the Angle between the middle line and any side line
         self.phi = math.pi / 12
-        ## Middle line
-        self.main_line = LineInteractor(self, self.base.subplot, color='blue',
+        # Middle line
+        self.main_line = LineInteractor(self, self.axes, color='blue',
                                         zorder=zorder, r=self.qmax,
                                         theta=self.theta2)
         self.main_line.qmax = self.qmax
-        ## Right Side line
-        self.right_line = SideInteractor(self, self.base.subplot, color='black',
+        # Right Side line
+        self.right_line = SideInteractor(self, self.axes, color='black',
                                          zorder=zorder, r=self.qmax,
                                          phi=-1 * self.phi, theta2=self.theta2)
         self.right_line.qmax = self.qmax
-        ## Left Side line
-        self.left_line = SideInteractor(self, self.base.subplot, color='black',
+        # Left Side line
+        self.left_line = SideInteractor(self, self.axes, color='black',
                                         zorder=zorder, r=self.qmax,
                                         phi=self.phi, theta2=self.theta2)
         self.left_line.qmax = self.qmax
-        ## draw the sector
+        # draw the sector
         self.update()
         self._post_data()
-        ## Bind to slice parameter events
-        self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
-
-    def _onEVT_SLICER_PARS(self, event):
-        """
-        receive an event containing parameters values to reset the slicer
-
-        :param event: event of type SlicerParameterEvent with params as
-        attribute
-
-        """
-        wx.PostEvent(self.base.parent,
-                     StatusEvent(status="SectorSlicer._onEVT_SLICER_PARS"))
-        event.Skip()
-        if event.type == self.__class__.__name__:
-            self.set_params(event.params)
-            self.base.update()
+        self.setModelFromParams()
 
     def set_layer(self, n):
         """
          Allow adding plot to the same panel
-
         :param n: the number of layer
-
         """
         self.layernum = n
@@ -92 +76 @@
         self.right_line.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -100 +83 @@
         """
         # Update locations
-        ## Check if the middle line was dragged and
-        #update the picture accordingly
+        # Check if the middle line was dragged and
+        # update the picture accordingly
         if self.main_line.has_move:
             self.main_line.update()
@@ -108 +91 @@
             self.left_line.update(delta=self.left_line.phi / 2,
                                   mline=self.main_line.theta)
-        ## Check if the left side has moved and update the slicer accordingly
+        # Check if the left side has moved and update the slicer accordingly
         if self.left_line.has_move:
             self.main_line.update()
@@ -116 +99 @@
                                    mline=self.main_line, side=True,
                                    left=False, right=True)
-        ## Check if the right side line has moved and
-        #update the slicer accordingly
+        # Check if the right side line has moved and update the slicer accordingly
         if self.right_line.has_move:
             self.main_line.update()
@@ -130 +112 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.main_line.save(ev)
         self.right_line.save(ev)
@@ -141 +122 @@
         :param nbins: the number of point to plot for the average 1D data
         """
-        ## get the data2D to average
-        data = self.base.data2D
+        # Get the data2D to average
+        data = self.base.data
         # If we have no data, just return
         if data == None:
             return
-        ## Averaging
+        # Averaging
         from sas.sascalc.dataloader.manipulations import SectorQ
         radius = self.qmax
@@ -157 +138 @@
                        phi_max=phimax + math.pi, nbins=nbins)
 
-        sector = sect(self.base.data2D)
-        ##Create 1D data resulting from average
+        sector = sect(self.base.data)
+        # Create 1D data resulting from average
 
         if hasattr(sector, "dxl"):
@@ -171 +152 @@
         new_plot.dxl = dxl
         new_plot.dxw = dxw
-        new_plot.name = "SectorQ" + "(" + self.base.data2D.name + ")"
-        new_plot.source = self.base.data2D.source
-        #new_plot.info=self.base.data2D.info
+        new_plot.name = "SectorQ" + "(" + self.base.data.name + ")"
+        new_plot.title = "SectorQ" + "(" + self.base.data.name + ")"
+        new_plot.source = self.base.data.source
         new_plot.interactive = True
-        new_plot.detector = self.base.data2D.detector
-        ## If the data file does not tell us what the axes are, just assume...
+        new_plot.detector = self.base.data.detector
+        # If the data file does not tell us what the axes are, just assume them.
         new_plot.xaxis("\\rm{Q}", "A^{-1}")
         new_plot.yaxis("\\rm{Intensity}", "cm^{-1}")
         if hasattr(data, "scale") and data.scale == 'linear' and \
-                self.base.data2D.name.count("Residuals") > 0:
+                self.base.data.name.count("Residuals") > 0:
             new_plot.ytransform = 'y'
             new_plot.yaxis("\\rm{Residuals} ", "/")
 
-        new_plot.group_id = "2daverage" + self.base.data2D.name
-        new_plot.id = "SectorQ" + self.base.data2D.name
+        new_plot.group_id = "2daverage" + self.base.data.name
+        new_plot.id = "SectorQ" + self.base.data.name
         new_plot.is_data = True
-        self.base.parent.update_theory(data_id=data.id, theory=new_plot)
-        wx.PostEvent(self.base.parent,
-                     NewPlotEvent(plot=new_plot, title="SectorQ" + self.base.data2D.name))
+        variant_plot = QtCore.QVariant(new_plot)
+        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id)
+
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
 
     def moveend(self, ev):
@@ -195 +179 @@
         Called a dragging motion ends.Get slicer event
         """
-        self.base.thaw_axes()
-        ## Post parameters
-        event = SlicerParameterEvent()
-        event.type = self.__class__.__name__
-        event.params = self.get_params()
-        ## Send slicer paramers to plotter2D
-        wx.PostEvent(self.base, event)
+        # Post parameters
+        self._post_data(self.nbins)
 
     def restore(self):
@@ -222 +201 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
-
         :return params: the dictionary created
-
         """
         params = {}
-        ## Always make sure that the left and the right line are at phi
-        ## angle of the middle line
+        # Always make sure that the left and the right line are at phi
+        # angle of the middle line
         if math.fabs(self.left_line.phi) != math.fabs(self.right_line.phi):
             msg = "Phi left and phi right are different"
@@ -241 +218 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -253 +230 @@
         self.nbins = int(params["nbins"])
         self.main_line.theta = main
-        ## Reset the slicer parameters
+        # Reset the slicer parameters
         self.main_line.update()
         self.right_line.update(phi=phi, delta=None, mline=self.main_line,
@@ -259 +236 @@
         self.left_line.update(phi=phi, delta=None,
                               mline=self.main_line, side=True)
-        ## post the new corresponding data
+        # Post the new corresponding data
         self._post_data(nbins=self.nbins)
-
-    def freeze_axes(self):
-        """
-        """
-        self.base.freeze_axes()
-
-    def thaw_axes(self):
-        """
-        """
-        self.base.thaw_axes()
 
     def draw(self):
@@ -291 +258 @@
         """
         _BaseInteractor.__init__(self, base, axes, color=color)
-        ## Initialize the class
+        # Initialize the class
         self.markers = []
         self.axes = axes
-        ## compute the value of the angle between the current line and
-        ## the x-axis
+        # compute the value of the angle between the current line and
+        # the x-axis
         self.save_theta = theta2 + phi
         self.theta = theta2 + phi
-        ## the value of the middle line angle with respect to the x-axis
+        # the value of the middle line angle with respect to the x-axis
         self.theta2 = theta2
-        ## Radius to find polar coordinates this line's endpoints
+        # Radius to find polar coordinates this line's endpoints
         self.radius = r
-        ## phi is the phase between the current line and the middle line
+        # phi is the phase between the current line and the middle line
         self.phi = phi
-        ## End points polar coordinates
+        # End points polar coordinates
         x1 = self.radius * math.cos(self.theta)
         y1 = self.radius * math.sin(self.theta)
         x2 = -1 * self.radius * math.cos(self.theta)
         y2 = -1 * self.radius * math.sin(self.theta)
-        ## defining a new marker
+        # Defining a new marker
         self.inner_marker = self.axes.plot([x1 / 2.5], [y1 / 2.5], linestyle='',
                                            marker='s', markersize=10,
@@ -316 +283 @@
                                            zorder=zorder, visible=True)[0]
 
-        ## Defining the current line
+        # Defining the current line
         self.line = self.axes.plot([x1, x2], [y1, y2],
                                    linestyle='-', marker='',
                                    color=self.color, visible=True)[0]
-        ## Flag to differentiate the left line from the right line motion
+        # Flag to differentiate the left line from the right line motion
         self.left_moving = False
-        ## Flag to define a motion
+        # Flag to define a motion
         self.has_move = False
-        ## connecting markers and draw the picture
+        # connecting markers and draw the picture
         self.connect_markers([self.inner_marker, self.line])
 
@@ -330 +297 @@
         """
         Allow adding plot to the same panel
-
         :param n: the number of layer
-
         """
         self.layernum = n
@@ -359 +324 @@
 
         """
-        #print "update left or right ", self.has_move
         self.left_moving = left
         theta3 = 0
@@ -396 +360 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -416 +379 @@
         self.theta = math.atan2(y, x)
         self.has_move = True
-        #ToDo: Simplify below
         if not self.left_moving:
             if  self.theta2 - self.theta <= 0 and self.theta2 > 0:
@@ -464 +426 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -472 +434 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         """
@@ -554 +516 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -582 +543 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -590 +551 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         """

src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

@@ -1 @@
-import wx
-import math
 import numpy
-from sas.sasgui.guiframe.events import NewPlotEvent
-from sas.sasgui.guiframe.events import StatusEvent
-from sas.sasgui.guiframe.events import SlicerParameterEvent
-from sas.sasgui.guiframe.events import EVT_SLICER_PARS
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
 from BaseInteractor import _BaseInteractor
 from sas.sasgui.guiframe.dataFitting import Data1D
-
-
-class BoxInteractor(_BaseInteractor):
+import sas.qtgui.GuiUtils as GuiUtils
+from sas.qtgui.SlicerModel import SlicerModel
+
+
+class BoxInteractor(_BaseInteractor, SlicerModel):
     """
     BoxInteractor define a rectangle that return data1D average of Data2D
     in a rectangle area defined by -x, x ,y, -y
     """
-    def __init__(self, base, axes, color='black', zorder=3):
+    def __init__(self, base, axes, item=None, color='black', zorder=3):
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # # Class initialization
+        SlicerModel.__init__(self)
+        # Class initialization
         self.markers = []
         self.axes = axes
-        # #connecting artist
+        self._item = item
+        #connecting artist
         self.connect = self.base.connect
-        # # which direction is the preferred interaction direction
+        # which direction is the preferred interaction direction
         self.direction = None
-        # # determine x y  values
-        self.x = 0.5 * min(math.fabs(self.base.data2D.xmax),
-                           math.fabs(self.base.data2D.xmin))
-        self.y = 0.5 * min(math.fabs(self.base.data2D.xmax),
-                           math.fabs(self.base.data2D.xmin))
-        # # when reach qmax reset the graph
-        self.qmax = max(self.base.data2D.xmax, self.base.data2D.xmin,
-                        self.base.data2D.ymax, self.base.data2D.ymin)
-        # # Number of points on the plot
+        # determine x y  values
+        self.x = 0.5 * min(numpy.fabs(self.base.data.xmax),
+                           numpy.fabs(self.base.data.xmin))
+        self.y = 0.5 * min(numpy.fabs(self.base.data.xmax),
+                           numpy.fabs(self.base.data.xmin))
+        # when reach qmax reset the graph
+        self.qmax = max(self.base.data.xmax, self.base.data.xmin,
+                        self.base.data.ymax, self.base.data.ymin)
+        # Number of points on the plot
         self.nbins = 30
-        # # If True, I(|Q|) will be return, otherwise,
+        # If True, I(|Q|) will be return, otherwise,
         # negative q-values are allowed
         self.fold = True
-        # # reference of the current  Slab averaging
+        # reference of the current  Slab averaging
         self.averager = None
-        # # Create vertical and horizaontal lines for the rectangle
+        # Create vertical and horizaontal lines for the rectangle
         self.vertical_lines = VerticalLines(self,
-                                            self.base.subplot,
+                                            self.axes,
                                             color='blue',
                                             zorder=zorder,
@@ -49 +50 @@
 
         self.horizontal_lines = HorizontalLines(self,
-                                                self.base.subplot,
+                                                self.axes,
                                                 color='green',
                                                 zorder=zorder,
@@ -55 +56 @@
                                                 y=self.y)
         self.horizontal_lines.qmax = self.qmax
-        # # draw the rectangle and plost the data 1D resulting
-        # # of averaging data2D
+        # draw the rectangle and plost the data 1D resulting
+        # of averaging data2D
         self.update()
         self._post_data()
-        # # Bind to slice parameter events
-        self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
-
-    def _onEVT_SLICER_PARS(self, event):
-        """
-        receive an event containing parameters values to reset the slicer
-
-        :param event: event of type SlicerParameterEvent with params as
-            attribute
-        """
-        wx.PostEvent(self.base.parent,
-                     StatusEvent(status="BoxSlicer._onEVT_SLICER_PARS"))
-        event.Skip()
-        if event.type == self.__class__.__name__:
-            self.set_params(event.params)
-            self.base.update()
+        self.setModelFromParams()
 
     def update_and_post(self):
@@ -102 +88 @@
         self.vertical_lines.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -123 +108 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.vertical_lines.save(ev)
         self.horizontal_lines.save(ev)
@@ -139 +123 @@
 
         """
-        if self.direction == None:
+        if self.direction is None:
             self.direction = direction
 
-        x_min = -1 * math.fabs(self.vertical_lines.x)
-        x_max = math.fabs(self.vertical_lines.x)
-        y_min = -1 * math.fabs(self.horizontal_lines.y)
-        y_max = math.fabs(self.horizontal_lines.y)
-
-        if nbins != None:
+        x_min = -1 * numpy.fabs(self.vertical_lines.x)
+        x_max = numpy.fabs(self.vertical_lines.x)
+        y_min = -1 * numpy.fabs(self.horizontal_lines.y)
+        y_max = numpy.fabs(self.horizontal_lines.y)
+
+        if nbins is not None:
             self.nbins = nbins
-        if self.averager == None:
-            if new_slab == None:
+        if self.averager is None:
+            if new_slab is None:
                 msg = "post data:cannot average , averager is empty"
                 raise ValueError, msg
@@ -158 +142 @@
                 x_low = 0
             else:
-                x_low = math.fabs(x_min)
+                x_low = numpy.fabs(x_min)
             bin_width = (x_max + x_low) / self.nbins
         elif self.direction == "Y":
@@ -164 +148 @@
                 y_low = 0
             else:
-                y_low = math.fabs(y_min)
+                y_low = numpy.fabs(y_min)
             bin_width = (y_max + y_low) / self.nbins
         else:
@@ -173 +157 @@
                             bin_width=bin_width)
         box.fold = self.fold
-        boxavg = box(self.base.data2D)
+        boxavg = box(self.base.data)
         # 3 Create Data1D to plot
         if hasattr(boxavg, "dxl"):
@@ -187 +171 @@
         new_plot.dxw = dxw
         new_plot.name = str(self.averager.__name__) + \
-                        "(" + self.base.data2D.name + ")"
-        new_plot.source = self.base.data2D.source
+                        "(" + self.base.data.name + ")"
+        new_plot.title = str(self.averager.__name__) + \
+                        "(" + self.base.data.name + ")"
+        new_plot.source = self.base.data.source
         new_plot.interactive = True
-        new_plot.detector = self.base.data2D.detector
+        new_plot.detector = self.base.data.detector
         # # If the data file does not tell us what the axes are, just assume...
         new_plot.xaxis("\\rm{Q}", "A^{-1}")
         new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}")
 
-        data = self.base.data2D
+        data = self.base.data
         if hasattr(data, "scale") and data.scale == 'linear' and \
-                self.base.data2D.name.count("Residuals") > 0:
+                self.base.data.name.count("Residuals") > 0:
             new_plot.ytransform = 'y'
             new_plot.yaxis("\\rm{Residuals} ", "/")
 
-        new_plot.group_id = "2daverage" + self.base.data2D.name
-        new_plot.id = (self.averager.__name__) + self.base.data2D.name
+        new_plot.group_id = "2daverage" + self.base.data.name
+        new_plot.id = (self.averager.__name__) + self.base.data.name
         new_plot.is_data = True
-        self.base.parent.update_theory(data_id=self.base.data2D.id, \
-                                       theory=new_plot)
-        wx.PostEvent(self.base.parent,
-                     NewPlotEvent(plot=new_plot, title=str(self.averager.__name__)))
+        variant_plot = QtCore.QVariant(new_plot)
+        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id)
+
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
 
     def moveend(self, ev):
@@ -215 +203 @@
         corresponding to the new average
         """
-        self.base.thaw_axes()
-        # Post paramters
-        event = SlicerParameterEvent()
-        event.type = self.__class__.__name__
-        event.params = self.get_params()
-        wx.PostEvent(self.base.parent, event)
-        # create the new data1D
         self._post_data()
 
@@ -240 +221 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -248 +229 @@
         """
         params = {}
-        params["x_max"] = math.fabs(self.vertical_lines.x)
-        params["y_max"] = math.fabs(self.horizontal_lines.y)
+        params["x_max"] = numpy.fabs(self.vertical_lines.x)
+        params["y_max"] = numpy.fabs(self.horizontal_lines.y)
         params["nbins"] = self.nbins
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -261 +242 @@
             values the user assigned to the slicer.
         """
-        self.x = float(math.fabs(params["x_max"]))
-        self.y = float(math.fabs(params["y_max"]))
+        self.x = float(numpy.fabs(params["x_max"]))
+        self.y = float(numpy.fabs(params["y_max"]))
         self.nbins = params["nbins"]
 
@@ -269 +250 @@
         self.post_data(nbins=None)
 
-    def freeze_axes(self):
-        """
-        """
-        self.base.freeze_axes()
-
-    def thaw_axes(self):
-        """
-        """
-        self.base.thaw_axes()
-
     def draw(self):
         """
@@ -294 +265 @@
         """
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # #Class initialization
+        # Class initialization
         self.markers = []
         self.axes = axes
-        # # Saving the end points of two lines
+        # Saving the end points of two lines
         self.x = x
         self.save_x = x
@@ -303 +274 @@
         self.y = y
         self.save_y = y
-        # # Creating a marker
+        # Creating a marker
         # Inner circle marker
         self.inner_marker = self.axes.plot([0], [self.y], linestyle='',
@@ -311 +282 @@
                                            zorder=zorder,
                                            visible=True)[0]
-        # # Define 2 horizontal lines
+        # Define 2 horizontal lines
         self.top_line = self.axes.plot([self.x, -self.x], [self.y, self.y],
                                        linestyle='-', marker='',
@@ -318 +289 @@
                                           linestyle='-', marker='',
                                           color=self.color, visible=True)[0]
-        # # Flag to check the motion of the lines
+        # Flag to check the motion of the lines
         self.has_move = False
-        # # Connecting markers to mouse events and draw
+        # Connecting markers to mouse events and draw
         self.connect_markers([self.top_line, self.inner_marker])
         self.update()
@@ -339 +310 @@
         """
         self.clear_markers()
-        try:
-            self.inner_marker.remove()
-            self.top_line.remove()
-            self.bottom_line.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.inner_marker.remove()
+        self.top_line.remove()
+        self.bottom_line.remove()
 
     def update(self, x=None, y=None):
@@ -356 +322 @@
 
         """
-        # # Reset x, y- coordinates if send as parameters
-        if x != None:
-            self.x = numpy.sign(self.x) * math.fabs(x)
-        if y != None:
-            self.y = numpy.sign(self.y) * math.fabs(y)
-        # # Draw lines and markers
+        # Reset x, y- coordinates if send as parameters
+        if x is not None:
+            self.x = numpy.sign(self.x) * numpy.fabs(x)
+        if y is not None:
+            self.y = numpy.sign(self.y) * numpy.fabs(y)
+        # Draw lines and markers
         self.inner_marker.set(xdata=[0], ydata=[self.y])
         self.top_line.set(xdata=[self.x, -self.x], ydata=[self.y, self.y])
@@ -373 +339 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -409 +374 @@
         self.markers = []
         self.axes = axes
-        self.x = math.fabs(x)
+        self.x = numpy.fabs(x)
         self.save_x = self.x
-        self.y = math.fabs(y)
+        self.y = numpy.fabs(y)
         self.save_y = y
         # Inner circle marker
@@ -446 +411 @@
         """
         self.clear_markers()
-        try:
-            self.inner_marker.remove()
-            self.left_line.remove()
-            self.right_line.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.inner_marker.remove()
+        self.left_line.remove()
+        self.right_line.remove()
 
     def update(self, x=None, y=None):
@@ -463 +423 @@
 
         """
-        # # reset x, y -coordinates if given as parameters
-        if x != None:
-            self.x = numpy.sign(self.x) * math.fabs(x)
-        if y != None:
-            self.y = numpy.sign(self.y) * math.fabs(y)
-        # # draw lines and markers
+        # Reset x, y -coordinates if given as parameters
+        if x is not None:
+            self.x = numpy.sign(self.x) * numpy.fabs(x)
+        if y is not None:
+            self.y = numpy.sign(self.y) * numpy.fabs(y)
+        # Draw lines and markers
         self.inner_marker.set(xdata=[self.x], ydata=[0])
         self.left_line.set(xdata=[-self.x, -self.x], ydata=[self.y, -self.y])
@@ -480 +440 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -510 +469 @@
     Average in Qx direction
     """
-    def __init__(self, base, axes, color='black', zorder=3):
-        BoxInteractor.__init__(self, base, axes, color=color)
+    def __init__(self, base, axes, item=None, color='black', zorder=3):
+        BoxInteractor.__init__(self, base, axes, item=item, color=color)
         self.base = base
         self._post_data()
@@ -527 +486 @@
     Average in Qy direction
     """
-    def __init__(self, base, axes, color='black', zorder=3):
-        BoxInteractor.__init__(self, base, axes, color=color)
+    def __init__(self, base, axes, item=None, color='black', zorder=3):
+        BoxInteractor.__init__(self, base, axes, item=item, color=color)
         self.base = base
         self._post_data()

src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py

@@ -1 +1 @@
 """
+Boxsum Class: determine 2 rectangular area to compute
+the sum of pixel of a Data.
+"""
+import numpy
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+from sas.qtgui.GuiUtils import formatNumber
+
+from BaseInteractor import _BaseInteractor
+from sas.sascalc.dataloader.manipulations import Boxavg
+from sas.sascalc.dataloader.manipulations import Boxsum
+
+from sas.qtgui.SlicerModel import SlicerModel
+
+
+class BoxSumCalculator(_BaseInteractor):
+    """
     Boxsum Class: determine 2 rectangular area to compute
     the sum of pixel of a Data.
-"""
-import math
-import wx
-from BaseInteractor import _BaseInteractor
-from sas.sasgui.guiframe.events import SlicerParamUpdateEvent
-from sas.sasgui.guiframe.events import EVT_SLICER_PARS
-from sas.sasgui.guiframe.events import StatusEvent
-
-
-class BoxSum(_BaseInteractor):
+    Uses PointerInteractor , VerticalDoubleLine,HorizontalDoubleLine.
+    @param zorder:  Artists with lower zorder values are drawn first.
+    @param x_min: the minimum value of the x coordinate
+    @param x_max: the maximum value of the x coordinate
+    @param y_min: the minimum value of the y coordinate
+    @param y_max: the maximum value of the y coordinate
+
     """
-        Boxsum Class: determine 2 rectangular area to compute
-        the sum of pixel of a Data.
-        Uses PointerInteractor , VerticalDoubleLine,HorizontalDoubleLine.
-        @param zorder:  Artists with lower zorder values are drawn first.
-        @param x_min: the minimum value of the x coordinate
-        @param x_max: the maximum value of the x coordinate
-        @param y_min: the minimum value of the y coordinate
-        @param y_max: the maximum value of the y coordinate
-
-    """
-    def __init__(self, base, axes, color='black', zorder=3, x_min=0.008,
-                 x_max=0.008, y_min=0.0025, y_max=0.0025):
-        """
-        """
+    def __init__(self, base, axes, color='black', zorder=3):
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # # class initialization
-        # # list of Boxsmun markers
+
+        # list of Boxsmun markers
         self.markers = []
         self.axes = axes
-        # # connect the artist for the motion
+        self._model = None
+        self.update_model = False
+
+        # connect the artist for the motion
         self.connect = self.base.connect
-        # # when qmax is reached the selected line is reset the its previous value
-        self.qmax = min(self.base.data2D.xmax, self.base.data2D.xmin)
-        # # Define the boxsum limits
-        self.xmin = -1 * 0.5 * min(math.fabs(self.base.data2D.xmax),
-                                   math.fabs(self.base.data2D.xmin))
-        self.ymin = -1 * 0.5 * min(math.fabs(self.base.data2D.xmax),
-                                   math.fabs(self.base.data2D.xmin))
-        self.xmax = 0.5 * min(math.fabs(self.base.data2D.xmax),
-                              math.fabs(self.base.data2D.xmin))
-        self.ymax = 0.5 * min(math.fabs(self.base.data2D.xmax),
-                              math.fabs(self.base.data2D.xmin))
-        # # center of the boxSum
+
+        # when qmax is reached the selected line is reset the its previous value
+        self.qmax = min(self.base.data.xmax, self.base.data.xmin)
+
+        # Define the boxsum limits
+        self.xmin = -1 * 0.5 * min(numpy.fabs(self.base.data.xmax),
+                                   numpy.fabs(self.base.data.xmin))
+        self.ymin = -1 * 0.5 * min(numpy.fabs(self.base.data.xmax),
+                                   numpy.fabs(self.base.data.xmin))
+        self.xmax = 0.5 * min(numpy.fabs(self.base.data.xmax),
+                              numpy.fabs(self.base.data.xmin))
+        self.ymax = 0.5 * min(numpy.fabs(self.base.data.xmax),
+                              numpy.fabs(self.base.data.xmin))
+        # center of the boxSum
         self.center_x = 0.0002
         self.center_y = 0.0003
-        # # Number of points on the plot
+        # Number of points on the plot
         self.nbins = 20
-        # # Define initial result the summation
+        # Define initial result the summation
         self.count = 0
         self.error = 0
@@ -56 +62 @@
         self.totalerror = 0
         self.points = 0
-        # # Flag to determine if the current figure has moved
-        # # set to False == no motion , set to True== motion
+        # Flag to determine if the current figure has moved
+        # set to False == no motion , set to True== motion
         self.has_move = False
-        # # Create Boxsum edges
+        # Create Boxsum edges
         self.horizontal_lines = HorizontalDoubleLine(self,
-                                                     self.base.subplot,
+                                                     self.axes,
                                                      color='blue',
                                                      zorder=zorder,
@@ -71 +77 @@
 
         self.vertical_lines = VerticalDoubleLine(self,
-                                                 self.base.subplot,
+                                                 self.axes,
                                                  color='black',
                                                  zorder=zorder,
@@ -81 +87 @@
 
         self.center = PointInteractor(self,
-                                      self.base.subplot, color='grey',
+                                      self.axes, color='grey',
                                       zorder=zorder,
                                       center_x=self.center_x,
                                       center_y=self.center_y)
-        # # Save the name of the slicer panel associate with this slicer
+        # Save the name of the slicer panel associate with this slicer
         self.panel_name = ""
-        # # Update and post slicer parameters
-        self.update()
-        self._post_data()
-        # # Bind to slice parameter events
-        self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
-
-    def set_panel_name(self, name):
-        """
-            Store the name of the panel associated to this slicer
-            @param name: the name of this panel
+        # Update and post slicer parameters
+        self.update_model = False
+        self.update()
+        self.postData()
+
+        # set up the model
+        self._model = QtGui.QStandardItemModel(1, 9)
+        self.setModelFromParams()
+        self.update_model = True
+        self._model.itemChanged.connect(self.setParamsFromModel)
+
+    def setModelFromParams(self):
+        """
+        Set up the Qt model for data handling between controls
+        """
+        parameters = self.getParams()
+        # Crete/overwrite model items
+        self._model.setData(self._model.index(0, 0),
+                    QtCore.QVariant(formatNumber(parameters['Height'])))
+        self._model.setData(self._model.index(0, 1),
+                    QtCore.QVariant(formatNumber(parameters['Width'])))
+        self._model.setData(self._model.index(0, 2),
+                    QtCore.QVariant(formatNumber(parameters['center_x'])))
+        self._model.setData(self._model.index(0, 3),
+                    QtCore.QVariant(formatNumber(parameters['center_y'])))
+
+        self.setReadOnlyParametersFromModel()
+
+    def model(self):
+        ''' model accessor '''
+        return self._model
+
+    def setReadOnlyParametersFromModel(self):
+        """
+        Cast model content onto "read-only" subset of parameters
+        """
+        parameters = self.getParams()
+        self._model.setData(self._model.index(0, 4),
+                    QtCore.QVariant(formatNumber(parameters['avg'])))
+        self._model.setData(self._model.index(0, 5),
+                    QtCore.QVariant(formatNumber(parameters['avg_error'])))
+        self._model.setData(self._model.index(0, 6),
+                    QtCore.QVariant(formatNumber(parameters['sum'])))
+        self._model.setData(self._model.index(0, 7),
+                    QtCore.QVariant(formatNumber(parameters['sum_error'])))
+        self._model.setData(self._model.index(0, 8),
+                    QtCore.QVariant(formatNumber(parameters['num_points'])))
+
+    def setParamsFromModel(self):
+        """
+        Cast model content onto params dict
+        """
+        params = {}
+        params["Height"] = float(self.model().item(0, 0).text())
+        params["Width"] = float(self.model().item(0, 1).text())
+        params["center_x"] = float(self.model().item(0, 2).text())
+        params["center_y"] = float(self.model().item(0, 3).text())
+        self.update_model = False
+        self.setParams(params)
+        self.setReadOnlyParametersFromModel()
+        self.update_model = True
+
+    def setPanelName(self, name):
+        """
+        Store the name of the panel associated to this slicer
+        @param name: the name of this panel
         """
         self.panel_name = name
 
-    def _onEVT_SLICER_PARS(self, event):
-        """
-            receive an event containing parameters values to reset the slicer
-            @param event: event of type SlicerParameterEvent with params as
-            attribute
-        """
-        # # Post e message to declare what kind of event has being received
-        wx.PostEvent(self.base.parent,
-                     StatusEvent(status="Boxsum._onEVT_SLICER_PARS"))
-        event.Skip()
-        # # reset the slicer with the values contains the event.params dictionary
-        if event.type == self.__class__.__name__:
-            self.set_params(event.params)
-            self.base.update()
-
-    def set_layer(self, n):
+    def setLayer(self, n):
         """
         Allow adding plot to the same panel
@@ -132 +179 @@
         self.center.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -139 +185 @@
         resetting the widgets.
         """
-        # # check if the center point has moved and update the figure accordingly
+        # check if the center point has moved and update the figure accordingly
         if self.center.has_move:
             self.center.update()
             self.horizontal_lines.update(center=self.center)
             self.vertical_lines.update(center=self.center)
-        # # check if the horizontal lines have moved and
+        # check if the horizontal lines have moved and
         # update the figure accordingly
         if self.horizontal_lines.has_move:
@@ -151 +197 @@
                                        y2=self.horizontal_lines.y2,
                                        height=self.horizontal_lines.half_height)
-        # # check if the vertical lines have moved and
+        # check if the vertical lines have moved and
         # update the figure accordingly
         if self.vertical_lines.has_move:
@@ -164 +210 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.horizontal_lines.save(ev)
         self.vertical_lines.save(ev)
         self.center.save(ev)
 
-    def _post_data(self):
+    def postData(self):
         """
         Get the limits of the boxsum and compute the sum of the pixel
         contained in that region and the error on that sum
         """
-        # # the region of the summation
+        # the region of the summation
         x_min = self.horizontal_lines.x2
         x_max = self.horizontal_lines.x1
         y_min = self.vertical_lines.y2
         y_max = self.vertical_lines.y1
-        # #computation of the sum and its error
-        from sas.sascalc.dataloader.manipulations import Boxavg
+        #computation of the sum and its error
         box = Boxavg(x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)
-        self.count, self.error = box(self.base.data2D)
+        self.count, self.error = box(self.base.data)
         # Dig out number of points summed, SMK & PDB, 04/03/2013
-        from sas.sascalc.dataloader.manipulations import Boxsum
         boxtotal = Boxsum(x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)
-        self.total, self.totalerror, self.points = boxtotal(self.base.data2D)
+        self.total, self.totalerror, self.points = boxtotal(self.base.data)
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
 
     def moveend(self, ev):
         """
-            After a dragging motion this function is called to compute
-            the error and the sum of pixel of a given data 2D
-        """
-        self.base.thaw_axes()
-        # # compute error an d sum of data's pixel
-        self._post_data()
-        # # Create and event ( posted to guiframe)that  set the
-        # #current slicer parameter to a panel of name self.panel_name
-        self.type = self.__class__.__name__
-        params = self.get_params()
-        event = SlicerParamUpdateEvent(type=self.type,
-                                       params=params,
-                                       panel_name=self.panel_name)
-        wx.PostEvent(self.base.parent, event)
+        After a dragging motion this function is called to compute
+        the error and the sum of pixel of a given data 2D
+        """
+        # compute error an d sum of data's pixel
+        self.postData()
 
     def restore(self):
@@ -213 +250 @@
         self.center.restore()
 
-    def move(self, x, y, ev):
-        """
-        Process move to a new position, making sure that the move is allowed.
-        """
-        pass
-
-    def set_cursor(self, x, y):
-        """
-        """
-        pass
-
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -230 +256 @@
         """
         params = {}
-        params["Width"] = math.fabs(self.vertical_lines.half_width) * 2
-        params["Height"] = math.fabs(self.horizontal_lines.half_height) * 2
+        params["Width"] = numpy.fabs(self.vertical_lines.half_width) * 2
+        params["Height"] = numpy.fabs(self.horizontal_lines.half_height) * 2
         params["center_x"] = self.center.x
         params["center_y"] = self.center.y
@@ -241 +267 @@
         return params
 
-    def get_result(self):
-        """
-            return the result of box summation
+    def getResult(self):
+        """
+        Return the result of box summation
         """
         result = {}
@@ -253 +279 @@
         return result
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
         in the values of the dictionary.
-        :param params: a dictionary containing name of slicer parameters and values the user assigned to the slicer.
-        """
-        x_max = math.fabs(params["Width"]) / 2
-        y_max = math.fabs(params["Height"]) / 2
+        :param params: a dictionary containing name of slicer parameters
+        and values the user assigned to the slicer.
+        """
+        x_max = numpy.fabs(params["Width"]) / 2
+        y_max = numpy.fabs(params["Height"]) / 2
 
         self.center_x = params["center_x"]
@@ -271 +298 @@
                                    width=x_max, height=y_max)
         # compute the new error and sum given values of params
-        self._post_data()
-
-    def freeze_axes(self):
-        """
-        """
-        self.base.freeze_axes()
-
-    def thaw_axes(self):
-        """
-        """
-        self.base.thaw_axes()
+        self.postData()
 
     def draw(self):
-        """
-        """
+        """ Redraw canvas"""
         self.base.draw()
 
@@ -297 +313 @@
     def __init__(self, base, axes, color='black', zorder=5, center_x=0.0,
                  center_y=0.0):
-        """
-        """
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # # Initialization the class
+        # Initialization the class
         self.markers = []
         self.axes = axes
@@ -306 +320 @@
         self.x = center_x
         self.y = center_y
-        # # saved value of the center coordinates
+        # saved value of the center coordinates
         self.save_x = center_x
         self.save_y = center_y
-        # # Create a marker
+        # Create a marker
         self.center_marker = self.axes.plot([self.x], [self.y], linestyle='',
                                             marker='s', markersize=10,
@@ -316 +330 @@
                                             zorder=zorder,
                                             visible=True)[0]
-        # # Draw a point
+        # Draw a point
         self.center = self.axes.plot([self.x], [self.y],
                                      linestyle='-', marker='',
                                      color=self.color,
                                      visible=True)[0]
-        # # Flag to determine the motion this point
+        # Flag to determine the motion this point
         self.has_move = False
-        # # connecting the marker to allow them to move
+        # connecting the marker to allow them to move
         self.connect_markers([self.center_marker])
-        # # Update the figure
-        self.update()
-
-    def set_layer(self, n):
-        """
-            Allow adding plot to the same panel
-            @param n: the number of layer
+        # Update the figure
+        self.update()
+
+    def setLayer(self, n):
+        """
+        Allow adding plot to the same panel
+        @param n: the number of layer
         """
         self.layernum = n
@@ -338 +352 @@
     def clear(self):
         """
-            Clear this figure and its markers
+        Clear this figure and its markers
         """
         self.clear_markers()
-        try:
-            self.center.remove()
-            self.center_marker.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.center.remove()
+        self.center_marker.remove()
 
     def update(self, center_x=None, center_y=None):
         """
-            Draw the new roughness on the graph.
+        Draw the new roughness on the graph.
         """
         if center_x != None:
@@ -367 +376 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -391 +399 @@
         self.base.base.update()
 
-    def set_cursor(self, x, y):
+    def setCursor(self, x, y):
         """
         """
@@ -399 +407 @@
 class VerticalDoubleLine(_BaseInteractor):
     """
-         Draw 2 vertical lines moving in opposite direction and centered on
-         a point (PointInteractor)
+    Draw 2 vertical lines moving in opposite direction and centered on
+    a point (PointInteractor)
     """
     def __init__(self, base, axes, color='black', zorder=5, x=0.5, y=0.5,
                  center_x=0.0, center_y=0.0):
-        """
-        """
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # # Initialization the class
+        # Initialization the class
         self.markers = []
         self.axes = axes
-        # # Center coordinates
+        # Center coordinates
         self.center_x = center_x
         self.center_y = center_y
-        # # defined end points vertical lignes and their saved values
+        # defined end points vertical lignes and their saved values
         self.y1 = y + self.center_y
         self.save_y1 = self.y1
@@ -429 +435 @@
         # # save the color of the line
         self.color = color
-        # # the height of the rectangle
-        self.half_height = math.fabs(y)
-        self.save_half_height = math.fabs(y)
-        # # the with of the rectangle
-        self.half_width = math.fabs(self.x1 - self.x2) / 2
-        self.save_half_width = math.fabs(self.x1 - self.x2) / 2
-        # # Create marker
+        # the height of the rectangle
+        self.half_height = numpy.fabs(y)
+        self.save_half_height = numpy.fabs(y)
+        # the with of the rectangle
+        self.half_width = numpy.fabs(self.x1 - self.x2) / 2
+        self.save_half_width = numpy.fabs(self.x1 - self.x2) / 2
+        # Create marker
         self.right_marker = self.axes.plot([self.x1], [0], linestyle='',
                                            marker='s', markersize=10,
@@ -442 +448 @@
                                            zorder=zorder, visible=True)[0]
 
-        # # define the left and right lines of the rectangle
+        # Define the left and right lines of the rectangle
         self.right_line = self.axes.plot([self.x1, self.x1], [self.y1, self.y2],
                                          linestyle='-', marker='',
@@ -449 +455 @@
                                         linestyle='-', marker='',
                                         color=self.color, visible=True)[0]
-        # # Flag to determine if the lines have moved
+        # Flag to determine if the lines have moved
         self.has_move = False
-        # # connection the marker and draw the pictures
+        # Connection the marker and draw the pictures
         self.connect_markers([self.right_marker])
         self.update()
 
-    def set_layer(self, n):
+    def setLayer(self, n):
         """
         Allow adding plot to the same panel
@@ -468 +474 @@
         """
         self.clear_markers()
-        try:
-            self.right_marker.remove()
-            self.right_line.remove()
-            self.left_line.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.right_marker.remove()
+        self.right_line.remove()
+        self.left_line.remove()
 
     def update(self, x1=None, x2=None, y1=None, y2=None, width=None,
@@ -489 +490 @@
         :param center: provided x, y  coordinates of the center point
         """
-        # # save the new height, witdh of the rectangle if given as a param
-        if width != None:
+        # Save the new height, witdh of the rectangle if given as a param
+        if width is not None:
             self.half_width = width
-        if height != None:
+        if height is not None:
             self.half_height = height
-        # # If new  center coordinates are given draw the rectangle
-        # #given these value
-        if center != None:
+        # If new  center coordinates are given draw the rectangle
+        # given these value
+        if center is not None:
             self.center_x = center.x
             self.center_y = center.y
@@ -510 +511 @@
                                ydata=[self.y1, self.y2])
             return
-        # # if x1, y1, y2, y3 are given draw the rectangle with this value
-        if x1 != None:
+        # if x1, y1, y2, y3 are given draw the rectangle with this value
+        if x1 is not None:
             self.x1 = x1
-        if x2 != None:
+        if x2 is not None:
             self.x2 = x2
-        if y1 != None:
+        if y1 is not None:
             self.y1 = y1
-        if y2 != None:
+        if y2 is not None:
             self.y2 = y2
-        # # Draw 2 vertical lines and a marker
+        # Draw 2 vertical lines and a marker
         self.right_marker.set(xdata=[self.x1], ydata=[self.center_y])
         self.right_line.set(xdata=[self.x1, self.x1], ydata=[self.y1, self.y2])
@@ -535 +536 @@
         self.save_half_height = self.half_height
         self.save_half_width = self.half_width
-        self.base.freeze_axes()
 
     def moveend(self, ev):
         """
-            After a dragging motion reset the flag self.has_move to False
+        After a dragging motion reset the flag self.has_move to False
         """
         self.has_move = False
@@ -562 +562 @@
         delta = self.x1 - self.center_x
         self.x2 = self.center_x - delta
-        self.half_width = math.fabs(self.x1 - self.x2) / 2
+        self.half_width = numpy.fabs(self.x1 - self.x2) / 2
         self.has_move = True
         self.base.base.update()
 
-    def set_cursor(self, x, y):
-        """
-            Update the figure given x and y
+    def setCursor(self, x, y):
+        """
+        Update the figure given x and y
         """
         self.move(x, y, None)
@@ -575 +575 @@
 class HorizontalDoubleLine(_BaseInteractor):
     """
-         Select an annulus through a 2D plot
+    Select an annulus through a 2D plot
     """
     def __init__(self, base, axes, color='black', zorder=5, x=0.5, y=0.5,
@@ -581 +581 @@
 
         _BaseInteractor.__init__(self, base, axes, color=color)
-        # # Initialization the class
+        # Initialization the class
         self.markers = []
         self.axes = axes
-        # # Center coordinates
+        # Center coordinates
         self.center_x = center_x
         self.center_y = center_y
@@ -598 +598 @@
         self.save_x2 = self.x2
         self.color = color
-        self.half_height = math.fabs(y)
-        self.save_half_height = math.fabs(y)
-        self.half_width = math.fabs(x)
-        self.save_half_width = math.fabs(x)
+        self.half_height = numpy.fabs(y)
+        self.save_half_height = numpy.fabs(y)
+        self.half_width = numpy.fabs(x)
+        self.save_half_width = numpy.fabs(x)
         self.top_marker = self.axes.plot([0], [self.y1], linestyle='',
                                          marker='s', markersize=10,
@@ -616 +616 @@
                                           linestyle='-', marker='',
                                           color=self.color, visible=True)[0]
-        # # Flag to determine if the lines have moved
+        # Flag to determine if the lines have moved
         self.has_move = False
-        # # connection the marker and draw the pictures
+        # connection the marker and draw the pictures
         self.connect_markers([self.top_marker])
         self.update()
 
-    def set_layer(self, n):
-        """
-            Allow adding plot to the same panel
-            @param n: the number of layer
+    def setLayer(self, n):
+        """
+        Allow adding plot to the same panel
+        @param n: the number of layer
         """
         self.layernum = n
@@ -632 +632 @@
     def clear(self):
         """
-            Clear this figure and its markers
+        Clear this figure and its markers
         """
         self.clear_markers()
-        try:
-            self.top_marker.remove()
-            self.bottom_line.remove()
-            self.top_line.remove()
-        except:
-            # Old version of matplotlib
-            for item in range(len(self.axes.lines)):
-                del self.axes.lines[0]
+        self.top_marker.remove()
+        self.bottom_line.remove()
+        self.top_line.remove()
 
     def update(self, x1=None, x2=None, y1=None, y2=None,
@@ -656 +651 @@
         :param center: provided x, y  coordinates of the center point
         """
-        # # save the new height, witdh of the rectangle if given as a param
-        if width != None:
+        # Save the new height, witdh of the rectangle if given as a param
+        if width is not None:
             self.half_width = width
-        if height != None:
+        if height is not None:
             self.half_height = height
-        # # If new  center coordinates are given draw the rectangle
-        # #given these value
-        if center != None:
+        # If new  center coordinates are given draw the rectangle
+        # given these value
+        if center is not None:
             self.center_x = center.x
             self.center_y = center.y
@@ -678 +673 @@
                                  ydata=[self.y2, self.y2])
             return
-        # # if x1, y1, y2, y3 are given draw the rectangle with this value
-        if x1 != None:
+        # if x1, y1, y2, y3 are given draw the rectangle with this value
+        if x1 is not None:
             self.x1 = x1
-        if x2 != None:
+        if x2 is not None:
             self.x2 = x2
-        if y1 != None:
+        if y1 is not None:
             self.y1 = y1
-        if y2 != None:
+        if y2 is not None:
             self.y2 = y2
-        # # Draw 2 vertical lines and a marker
+        # Draw 2 vertical lines and a marker
         self.top_marker.set(xdata=[self.center_x], ydata=[self.y1])
         self.top_line.set(xdata=[self.x1, self.x2], ydata=[self.y1, self.y1])
@@ -703 +698 @@
         self.save_half_height = self.half_height
         self.save_half_width = self.half_width
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -730 +724 @@
         delta = self.y1 - self.center_y
         self.y2 = self.center_y - delta
-        self.half_height = math.fabs(self.y1) - self.center_y
+        self.half_height = numpy.fabs(self.y1) - self.center_y
         self.has_move = True
         self.base.base.update()
 
-    def set_cursor(self, x, y):
-        """
-            Update the figure given x and y
+    def setCursor(self, x, y):
+        """
+        Update the figure given x and y
         """
         self.move(x, y, None)