Index: src/sas/qtgui/BoxSum.py
===================================================================
--- src/sas/qtgui/BoxSum.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/BoxSum.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,42 @@
+"""
+Allows users to modify the box slicer parameters.
+"""
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+# Local UI
+from sas.qtgui.UI.BoxSumUI import Ui_BoxSumUI
+
+class BoxSum(QtGui.QDialog, Ui_BoxSumUI):
+    apply_signal = QtCore.pyqtSignal(tuple, str)
+    def __init__(self, parent=None, model=None):
+        super(BoxSum, self).__init__()
+
+        self.setupUi(self)
+        assert isinstance(model, QtGui.QStandardItemModel)
+
+        self.txtBoxHeight.setValidator(QtGui.QDoubleValidator())
+        self.txtBoxWidth.setValidator(QtGui.QDoubleValidator())
+        self.txtCenterX.setValidator(QtGui.QDoubleValidator())
+        self.txtCenterY.setValidator(QtGui.QDoubleValidator())
+
+        self.model = model
+        self.mapper = QtGui.QDataWidgetMapper()
+        self.mapper.setModel(self.model)
+
+        # Map model items onto widget controls
+        self.mapper.addMapping(self.txtBoxHeight, 0)
+        self.mapper.addMapping(self.txtBoxWidth, 1)
+        self.mapper.addMapping(self.txtCenterX, 2)
+        self.mapper.addMapping(self.txtCenterY, 3)
+        self.mapper.addMapping(self.lblAvg, 4, "text")
+        self.mapper.addMapping(self.lblAvgErr, 5, "text")
+        self.mapper.addMapping(self.lblSum, 6, "text")
+        self.mapper.addMapping(self.lblSumErr, 7, "text")
+        self.mapper.addMapping(self.lblNumPoints, 8, "text")
+
+        # Populate the widgets with data from the first column
+        self.mapper.toFirst()
+
+        self.setFixedSize(self.minimumSizeHint())
+
Index: src/sas/qtgui/ColorMap.py
===================================================================
--- src/sas/qtgui/ColorMap.py	(revision 5d89f43266c67cb96a7bf395800ce4cce896c9f8)
+++ src/sas/qtgui/ColorMap.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -111,11 +111,4 @@
         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,5 +207,5 @@
                                             norm=self._norm,
                                             orientation='horizontal')
-        self.cb.set_label('Color map range')
+        self.cb.set_label('Detector Colors')
 
     def onColorMapReversed(self, isChecked):
Index: src/sas/qtgui/DataExplorer.py
===================================================================
--- src/sas/qtgui/DataExplorer.py	(revision 87cc73a1ade6168487d1841f4c285fadcf532e0c)
+++ src/sas/qtgui/DataExplorer.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -399,14 +399,15 @@
         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,5 +451,5 @@
 
         # 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
Index: src/sas/qtgui/GUITests.py
===================================================================
--- src/sas/qtgui/GUITests.py	(revision 092a3d9e371190b241becedfa1c1b6039185593a)
+++ src/sas/qtgui/GUITests.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -24,4 +24,6 @@
 from UnitTesting import PlotUtilitiesTest
 from UnitTesting import ColorMapTest
+from UnitTesting import BoxSumTest
+from UnitTesting import SlicerModelTest
 
 def suite():
@@ -50,4 +52,6 @@
         unittest.makeSuite(PlotUtilitiesTest.PlotUtilitiesTest, 'test'),
         unittest.makeSuite(ColorMapTest.ColorMapTest, 'test'),
+        unittest.makeSuite(BoxSumTest.BoxSumTest, 'test'),
+        unittest.makeSuite(SlicerModelTest.SlicerModelTest, 'test'),
     )
     return unittest.TestSuite(suites)
Index: src/sas/qtgui/GuiUtils.py
===================================================================
--- src/sas/qtgui/GuiUtils.py	(revision a66ff28037574eadcde466c7b04da5c45b314939)
+++ src/sas/qtgui/GuiUtils.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -242,4 +242,14 @@
     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,5 +259,4 @@
 
     # 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,5 +307,5 @@
         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,5 +313,5 @@
             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
Index: src/sas/qtgui/Plotter.py
===================================================================
--- src/sas/qtgui/Plotter.py	(revision 092a3d9e371190b241becedfa1c1b6039185593a)
+++ src/sas/qtgui/Plotter.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -516,4 +516,169 @@
         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):
Index: src/sas/qtgui/Plotter2D.py
===================================================================
--- src/sas/qtgui/Plotter2D.py	(revision 5d89f43266c67cb96a7bf395800ce4cce896c9f8)
+++ src/sas/qtgui/Plotter2D.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -11,10 +11,22 @@
 
 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,4 +41,10 @@
         # 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,5 +71,15 @@
         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,5 +89,5 @@
             self.data = data
 
-        assert(self._data)
+        assert self._data
 
         # Toggle the scale
@@ -128,7 +156,10 @@
         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,38 +197,133 @@
         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,6 +351,5 @@
 
     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,7 +435,6 @@
             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,9 +443,10 @@
             # 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,7 +457,16 @@
             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)
Index: src/sas/qtgui/PlotterBase.py
===================================================================
--- src/sas/qtgui/PlotterBase.py	(revision 092a3d9e371190b241becedfa1c1b6039185593a)
+++ src/sas/qtgui/PlotterBase.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -220,168 +220,33 @@
         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):
Index: src/sas/qtgui/SlicerModel.py
===================================================================
--- src/sas/qtgui/SlicerModel.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/SlicerModel.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,53 @@
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+import sas.qtgui.GuiUtils as GuiUtils
+
+class SlicerModel(object):
+    def __init__(self):
+        # Model representation of local parameters
+        self._model = QtGui.QStandardItemModel()
+
+        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()
+        self._model.removeRows( 0, self._model.rowCount() )
+        # Crete/overwrite model items
+        for parameter in parameters.keys():
+            item1 = QtGui.QStandardItem(parameter)
+            item2 = QtGui.QStandardItem(GuiUtils.formatNumber(parameters[parameter]))
+            self._model.appendRow([item1, item2])
+        self._model.setHeaderData(0, QtCore.Qt.Horizontal, QtCore.QVariant("Parameter"))
+        self._model.setHeaderData(1, QtCore.Qt.Horizontal, QtCore.QVariant("Value"))
+
+    def setParamsFromModel(self, item):
+        """
+        Set up the params dictionary based on the model content.
+        """
+        params = self.getParams()
+        index = self._model.indexFromItem(item)
+        row_index = index.row()
+        param_name = str(self._model.item(row_index, 0).text())
+        params[param_name] = float(self._model.item(row_index, 1).text())
+
+        self.update_model = False
+        self.setParams(params)
+        self.update_model = True
+
+    def model(self):
+        '''getter for the model'''
+        return self._model
+
+    def getParams(self):
+        ''' pure virtual '''
+        raise NotImplementedError("Parameter getter must be implemented in derived class.")
+
+    def setParams(self):
+        ''' pure virtual '''
+        raise NotImplementedError("Parameter setter must be implemented in derived class.")
+
Index: src/sas/qtgui/SlicerParameters.py
===================================================================
--- src/sas/qtgui/SlicerParameters.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/SlicerParameters.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,72 @@
+"""
+Allows users to modify the box slicer parameters.
+"""
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+# Local UI
+from sas.qtgui.UI.SlicerParametersUI import Ui_SlicerParametersUI
+
+class SlicerParameters(QtGui.QDialog, Ui_SlicerParametersUI):
+    """
+    Interaction between the QTableView and the underlying model,
+    passed from a slicer instance.
+    """
+    def __init__(self, parent=None, model=None):
+        super(SlicerParameters, self).__init__()
+
+        self.setupUi(self)
+        assert isinstance(model, QtGui.QStandardItemModel)
+
+        self.model = model
+
+        # Define a proxy model so cell enablement can be finegrained.
+        self.proxy = ProxyModel(self)
+        self.proxy.setSourceModel(self.model)
+
+        # Set the proxy model for display in the Table View.
+        self.lstParams.setModel(self.proxy)
+
+        # Disallow edit of the parameter name column.
+        self.lstParams.model().setColumnReadOnly(0, True)
+
+        # Specify the validator on the parameter value column.
+        self.lstParams.setItemDelegate(ValidatedItemDelegate())
+
+class ProxyModel(QtGui.QIdentityProxyModel):
+    """
+    Trivial proxy model with custom column edit flag
+    """
+    def __init__(self, parent=None):
+        super(ProxyModel, self).__init__(parent)
+        self._columns = set()
+
+    def columnReadOnly(self, column):
+        return column in self._columns
+
+    def setColumnReadOnly(self, column, readonly=True):
+        if readonly:
+            self._columns.add(column)
+        else:
+            self._columns.discard(column)
+
+    def flags(self, index):
+        flags = super(ProxyModel, self).flags(index)
+        if self.columnReadOnly(index.column()):
+            flags &= ~QtCore.Qt.ItemIsEditable
+        return flags
+
+
+class ValidatedItemDelegate(QtGui.QStyledItemDelegate):
+    """
+    Simple delegate enabling adding a validator to a cell editor.
+    """
+    def createEditor(self, widget, option, index):
+        if not index.isValid():
+            return 0
+        if index.column() == 1: # Edir only cells in the second column
+            editor = QtGui.QLineEdit(widget)
+            validator = QtGui.QDoubleValidator()
+            editor.setValidator(validator)
+            return editor
+        return super(ValidatedItemDelegate, self).createEditor(widget, option, index)
Index: src/sas/qtgui/UI/BoxSumUI.ui
===================================================================
--- src/sas/qtgui/UI/BoxSumUI.ui	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/UI/BoxSumUI.ui	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,318 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>BoxSumUI</class>
+ <widget class="QDialog" name="BoxSumUI">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>529</width>
+    <height>492</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Box Sum</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="main_resources.qrc">
+    <normaloff>:/res/ball.ico</normaloff>:/res/ball.ico</iconset>
+  </property>
+  <layout class="QGridLayout" name="gridLayout_7">
+   <item row="0" column="0" colspan="2">
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>Box dimensions</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="0" column="0">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QGroupBox" name="groupBox_4">
+          <property name="title">
+           <string>Box size</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout">
+           <item row="0" column="0">
+            <widget class="QLabel" name="label">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Height of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Height</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QLineEdit" name="txtBoxHeight">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Height of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="2">
+            <widget class="QLabel" name="label_10">
+             <property name="text">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;A&lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_2">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Width of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>Width</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QLineEdit" name="txtBoxWidth">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Width of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="2">
+            <widget class="QLabel" name="label_11">
+             <property name="text">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;A&lt;span style=&quot; vertical-align:super;&quot;&gt;-1&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+        <item>
+         <widget class="QGroupBox" name="groupBox_2">
+          <property name="title">
+           <string>Box center</string>
+          </property>
+          <layout class="QGridLayout" name="gridLayout_2">
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_3">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;X coordinate of the center of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Q&lt;span style=&quot; vertical-align:sub;&quot;&gt;X&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QLineEdit" name="txtCenterX">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;X coordinate of the center of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_4">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Y coordinate of the center of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Q&lt;span style=&quot; vertical-align:sub;&quot;&gt;Y&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QLineEdit" name="txtCenterY">
+             <property name="toolTip">
+              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Y coordinate of the center of the box.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+             </property>
+             <property name="text">
+              <string/>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="2">
+    <widget class="QGroupBox" name="groupBox_3">
+     <property name="title">
+      <string>Box parameters</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_5">
+      <item row="0" column="0">
+       <layout class="QFormLayout" name="formLayout">
+        <item row="0" column="0">
+         <widget class="QLabel" name="label_5">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Average point count in selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>Avg:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QLabel" name="lblAvg">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Average point count in selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel" name="label_6">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Error of average point count in selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>Avg error:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QLabel" name="lblAvgErr">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Error of average point count in selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <widget class="QLabel" name="label_7">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Total number of points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>Num. of points:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
+         <widget class="QLabel" name="lblNumPoints">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Total number of points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
+        <item row="3" column="0">
+         <widget class="QLabel" name="label_8">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Sum of point intensities for all points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>Sum:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="3" column="1">
+         <widget class="QLabel" name="lblSum">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Sum of point intensities for all points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="0">
+         <widget class="QLabel" name="label_9">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Error of point intensity sum for all points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>Sum error:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="4" column="1">
+         <widget class="QLabel" name="lblSumErr">
+          <property name="toolTip">
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Error of point intensity sum for all points in the selected region.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          </property>
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>18</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="3" column="1">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Close</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="main_resources.qrc"/>
+ </resources>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>BoxSumUI</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>BoxSumUI</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
Index: src/sas/qtgui/UI/SlicerParametersUI.ui
===================================================================
--- src/sas/qtgui/UI/SlicerParametersUI.ui	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/UI/SlicerParametersUI.ui	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SlicerParametersUI</class>
+ <widget class="QDialog" name="SlicerParametersUI">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>328</width>
+    <height>266</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Slicer Parameters</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="main_resources.qrc">
+    <normaloff>:/res/ball.ico</normaloff>:/res/ball.ico</iconset>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0" colspan="2">
+    <widget class="QTableView" name="lstParams"/>
+   </item>
+   <item row="1" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>21</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="2" column="1">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="main_resources.qrc"/>
+ </resources>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>SlicerParametersUI</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>SlicerParametersUI</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
Index: src/sas/qtgui/UnitTesting/BoxSumTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/BoxSumTest.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/UnitTesting/BoxSumTest.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,47 @@
+import sys
+import unittest
+from mock import MagicMock
+
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+# set up import paths
+import path_prepare
+
+# Local
+from BoxSum import BoxSum
+
+app = QtGui.QApplication(sys.argv)
+
+class BoxSumTest(unittest.TestCase):
+    '''Test the BoxSum'''
+    def setUp(self):
+        '''Create the BoxSum'''
+        # example model
+        model = QtGui.QStandardItemModel()
+        parameters = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
+        for index, parameter in enumerate(parameters):
+            model.setData(model.index(0, index),
+                    QtCore.QVariant(parameter))
+        self.widget = BoxSum(None, model=model)
+
+    def tearDown(self):
+        '''Destroy the GUI'''
+        self.widget.close()
+        self.widget = None
+
+    def testDefaults(self):
+        '''Test the GUI in its default state'''
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(0), QtGui.QLineEdit)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(1), QtGui.QLineEdit)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(2), QtGui.QLineEdit)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(3), QtGui.QLineEdit)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(4), QtGui.QLabel)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(5), QtGui.QLabel)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(6), QtGui.QLabel)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(7), QtGui.QLabel)
+        self.assertIsInstance(self.widget.mapper.mappedWidgetAt(8), QtGui.QLabel)
+        
+        
+if __name__ == "__main__":
+    unittest.main()
Index: src/sas/qtgui/UnitTesting/Plotter2DTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/Plotter2DTest.py	(revision 03c372db88a55844b6aa666b125e708bd0c77b0a)
+++ src/sas/qtgui/UnitTesting/Plotter2DTest.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -1,4 +1,5 @@
 import sys
 import unittest
+import numpy
 
 from PyQt4 import QtGui
@@ -24,5 +25,13 @@
     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,4 +112,24 @@
 
         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):
Index: src/sas/qtgui/UnitTesting/SlicerModelTest.py
===================================================================
--- src/sas/qtgui/UnitTesting/SlicerModelTest.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
+++ src/sas/qtgui/UnitTesting/SlicerModelTest.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -0,0 +1,77 @@
+import sys
+import unittest
+from mock import MagicMock
+
+from PyQt4 import QtGui
+from PyQt4 import QtCore
+
+# set up import paths
+import path_prepare
+
+# Local
+from SlicerModel import SlicerModel
+
+app = QtGui.QApplication(sys.argv)
+
+class SlicerModelTest(unittest.TestCase):
+    '''Test the SlicerModel'''
+    def setUp(self):
+        '''Create the SlicerModel'''
+        class SModel(SlicerModel):
+            params = {"a":1, "b":2}
+            def __init__(self):
+                SlicerModel.__init__(self)
+            def getParams(self):
+                return self.params
+            def setParams(self, par):
+                self.params = par
+        self.model = SModel()
+
+    def tearDown(self):
+        '''Destroy the model'''
+        self.model = None
+
+    def testBaseClass(self):
+        '''Assure that SlicerModel contains pure virtuals'''
+        model = SlicerModel()
+        with self.assertRaises(NotImplementedError):
+            model.setParams()
+        with self.assertRaises(NotImplementedError):
+            model.setModelFromParams()
+
+    def testDefaults(self):
+        '''Test the GUI in its default state'''
+        self.assertIsInstance(self.model.model(), QtGui.QStandardItemModel)
+
+    def testSetModelFromParams(self):
+        '''Test the model update'''
+        # Add a row to params
+        new_dict = self.model.getParams()
+        new_dict["c"] = 3
+        self.model.setParams(new_dict)
+
+        # Call the update
+        self.model.setModelFromParams()
+
+        # Check the new model.
+        self.assertEqual(self.model.model().rowCount(), 3)
+        self.assertEqual(self.model.model().columnCount(), 2)
+
+    def testSetParamsFromModel(self):
+        ''' Test the parameters update'''
+        # First - the default model
+        self.model.setModelFromParams()
+        self.assertEqual(self.model.model().rowCount(), 2)
+        self.assertEqual(self.model.model().columnCount(), 2)
+
+        # Add a row
+        item1 = QtGui.QStandardItem("c")
+        item2 = QtGui.QStandardItem(3)
+        self.model.model().appendRow([item1, item2])
+        # Check the new model. The update should be automatic
+        self.assertEqual(self.model.model().rowCount(), 3)
+        self.assertEqual(self.model.model().columnCount(), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
Index: src/sas/qtgui/run_tests.bat
===================================================================
--- src/sas/qtgui/run_tests.bat	(revision 092a3d9e371190b241becedfa1c1b6039185593a)
+++ src/sas/qtgui/run_tests.bat	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -23,2 +23,4 @@
 python -m UnitTesting.PlotUtilitiesTest
 python -m UnitTesting.ColorMapTest
+python -m UnitTesting.BoxSumTest
+python -m UnitTesting.SlicerModelTest
Index: src/sas/qtgui/run_tests.sh
===================================================================
--- src/sas/qtgui/run_tests.sh	(revision 092a3d9e371190b241becedfa1c1b6039185593a)
+++ src/sas/qtgui/run_tests.sh	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -22,2 +22,4 @@
 python -m UnitTesting.PlotUtilitiesTest
 python -m UnitTesting.ColorMapTest
+python -m UnitTesting.BoxSumTest
+python -m UnitTesting.SlicerModelTest
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -1,21 +1,13 @@
-# 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,19 +16,22 @@
     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,9 +40,9 @@
             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,21 +51,5 @@
         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,5 +71,4 @@
         self.inner_circle.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -108,5 +86,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.inner_circle.save(ev)
         self.outer_circle.save(ev)
@@ -120,23 +97,22 @@
         """
         # 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,43 +124,41 @@
         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,18 +178,16 @@
         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,24 +196,13 @@
         :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,31 +239,15 @@
         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,11 +270,6 @@
         """
         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,13 +287,13 @@
         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,5 +306,4 @@
         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,17 +335,14 @@
         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,6 +371,6 @@
         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,5 +384,5 @@
             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,27 +391,8 @@
         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,5 +406,4 @@
         self.outer_circle.clear()
         self.base.connect.clearall()
-        # self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -498,5 +414,5 @@
         # Update locations
         self.outer_circle.update()
-        # if self.is_inside != None:
+        self._post_data()
         out = self._post_data()
         return out
@@ -507,5 +423,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.outer_circle.save(ev)
 
@@ -521,5 +436,5 @@
 
         # If we have no data, just return
-        if data == None:
+        if data is None:
             return
         mask = data.mask
@@ -527,7 +442,7 @@
 
         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,5 +451,4 @@
         else:
             out = (mask(data))
-        # self.base.data.mask=out
         return out
 
@@ -566,5 +480,5 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -574,8 +488,8 @@
         """
         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,15 +499,9 @@
             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):
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -3,80 +3,64 @@
 """
 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,5 +76,4 @@
         self.right_line.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -100,6 +83,6 @@
         """
         # 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,5 +91,5 @@
             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,6 +99,5 @@
                                    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,5 +112,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.main_line.save(ev)
         self.right_line.save(ev)
@@ -141,10 +122,10 @@
         :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,6 +138,6 @@
                        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,23 +152,26 @@
         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,11 +179,6 @@
         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,14 +201,12 @@
         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,5 +218,5 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -253,5 +230,5 @@
         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,16 +236,6 @@
         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,23 +258,23 @@
         """
         _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,13 +283,13 @@
                                            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,7 +297,5 @@
         """
         Allow adding plot to the same panel
-
         :param n: the number of layer
-
         """
         self.layernum = n
@@ -359,5 +324,4 @@
 
         """
-        #print "update left or right ", self.has_move
         self.left_moving = left
         theta3 = 0
@@ -396,5 +360,4 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -416,5 +379,4 @@
         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,5 +426,5 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -472,5 +434,5 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         """
@@ -554,5 +516,4 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -582,5 +543,5 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -590,5 +551,5 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         """
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -1,45 +1,46 @@
-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,5 +50,5 @@
 
         self.horizontal_lines = HorizontalLines(self,
-                                                self.base.subplot,
+                                                self.axes,
                                                 color='green',
                                                 zorder=zorder,
@@ -55,24 +56,9 @@
                                                 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,5 +88,4 @@
         self.vertical_lines.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -123,5 +108,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.vertical_lines.save(ev)
         self.horizontal_lines.save(ev)
@@ -139,16 +123,16 @@
 
         """
-        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,5 +142,5 @@
                 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,5 +148,5 @@
                 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,5 +157,5 @@
                             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,25 +171,29 @@
         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,11 +203,4 @@
         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,5 +221,5 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -248,10 +229,10 @@
         """
         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,6 +242,6 @@
             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,14 +250,4 @@
         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,8 +265,8 @@
         """
         _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,5 +274,5 @@
         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,5 +282,5 @@
                                            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,7 +289,7 @@
                                           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,12 +310,7 @@
         """
         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,10 +322,10 @@
 
         """
-        # # 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,5 +339,4 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -409,7 +374,7 @@
         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,12 +411,7 @@
         """
         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,10 +423,10 @@
 
         """
-        # # 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,5 +440,4 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -510,6 +469,6 @@
     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,6 +486,6 @@
     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()
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py	(revision 3bdbfcc5cdff8a3a11a9bb19c1cc8c3660a9c2e2)
@@ -1,54 +1,60 @@
 """
+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,10 +62,10 @@
         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,5 +77,5 @@
 
         self.vertical_lines = VerticalDoubleLine(self,
-                                                 self.base.subplot,
+                                                 self.axes,
                                                  color='black',
                                                  zorder=zorder,
@@ -81,39 +87,80 @@
 
         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,5 +179,4 @@
         self.center.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -139,10 +185,10 @@
         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,5 +197,5 @@
                                        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,44 +210,35 @@
         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,16 +250,5 @@
         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,6 +256,6 @@
         """
         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,7 +267,7 @@
         return params
 
-    def get_result(self):
-        """
-            return the result of box summation
+    def getResult(self):
+        """
+        Return the result of box summation
         """
         result = {}
@@ -253,12 +279,13 @@
         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,19 +298,8 @@
                                    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,8 +313,6 @@
     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,8 +320,8 @@
         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,20 +330,20 @@
                                             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,18 +352,13 @@
     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,5 +376,4 @@
         self.save_x = self.x
         self.save_y = self.y
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -391,5 +399,5 @@
         self.base.base.update()
 
-    def set_cursor(self, x, y):
+    def setCursor(self, x, y):
         """
         """
@@ -399,19 +407,17 @@
 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,11 +435,11 @@
         # # 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,5 +448,5 @@
                                            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,11 +455,11 @@
                                         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,12 +474,7 @@
         """
         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,12 +490,12 @@
         :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,14 +511,14 @@
                                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,9 +536,8 @@
         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,11 +562,11 @@
         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,5 +575,5 @@
 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,8 +581,8 @@
 
         _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,8 +598,8 @@
         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,14 +616,14 @@
                                           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,15 +632,10 @@
     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,12 +651,12 @@
         :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,14 +673,14 @@
                                  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,5 +698,4 @@
         self.save_half_height = self.half_height
         self.save_half_width = self.half_width
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -730,11 +724,11 @@
         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)
