Index: src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py	(revision 7432acb919f4013119ca918a73350297e0d4c93f)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py	(revision 83eb5208b8acb86b064162274de583670f72da47)
@@ -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.Utilities.GuiUtils as GuiUtils
+from sas.qtgui.Utilities.GuiUtils import formatNumber
+from sas.qtgui.Plotting.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,15 +97,14 @@
         """
         # Data to average
-        data = self.base.data2D
-        # If we have no data, just return
+        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 is None:
@@ -136,7 +112,7 @@
         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,72 @@
         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)
+        self.base.manager.communicator.plotUpdateSignal.emit([new_plot])
+
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
+
+    def validate(self, param_name, param_value):
+        """
+        Test the proposed new value "value" for row "row" of parameters
+        """
+        MIN_DIFFERENCE = 0.01
+        isValid = True
+
+        if param_name == 'inner_radius':
+            # First, check the closeness
+            if numpy.fabs(param_value - self.getParams()['outer_radius']) < MIN_DIFFERENCE:
+                print("Inner and outer radii too close. Please adjust.")
+                isValid = False
+            elif param_value > self.qmax:
+                print("Inner radius exceeds maximum range. Please adjust.")
+                isValid = False
+        elif param_name == 'outer_radius':
+            # First, check the closeness
+            if numpy.fabs(param_value - self.getParams()['inner_radius']) < MIN_DIFFERENCE:
+                print("Inner and outer radii too close. Please adjust.")
+                isValid = False
+            elif param_value > self.qmax:
+                print("Outer radius exceeds maximum range. Please adjust.")
+                isValid = False
+        elif param_name == 'nbins':
+            # Can't be 0
+            if param_value < 1:
+                print("Number of bins cannot be less than or equal to 0. Please adjust.")
+                isValid = False
+
+        return isValid
 
     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 +209,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 +227,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 +270,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 +301,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 +318,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 +337,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 +366,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 +402,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 +415,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 +422,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 +437,4 @@
         self.outer_circle.clear()
         self.base.connect.clearall()
-        # self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -498,5 +445,5 @@
         # Update locations
         self.outer_circle.update()
-        # if self.is_inside is not None:
+        self._post_data()
         out = self._post_data()
         return out
@@ -507,5 +454,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.outer_circle.save(ev)
 
@@ -527,7 +473,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 +482,4 @@
         else:
             out = (mask(data))
-        # self.base.data.mask=out
         return out
 
@@ -566,5 +511,5 @@
         pass
 
-    def get_params(self):
+    def getParams(self):
         """
         Store a copy of values of parameters of the slicer into a dictionary.
@@ -574,8 +519,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 +530,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/AzimutSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/AzimutSlicer.py	(revision d85c194ea2f78cb2b9b3de9c969e1b8ebea6b6d2)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/AzimutSlicer.py	(revision 161713c8e6fadc0d5442315916ec49e4df8f4dee)
@@ -182,4 +182,12 @@
                      NewPlotEvent(plot=new_plot, title=str(new_sector.__name__)))
 
+
+    def validate(self, param_name, param_value):
+        """
+        Test the proposed new value "value" for row "row" of parameters
+        """
+        # Here, always return true
+        return True
+
     def moveend(self, ev):
         #TODO: why is this empty?
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py	(revision 7432acb919f4013119ca918a73350297e0d4c93f)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py	(revision 7432acb919f4013119ca918a73350297e0d4c93f)
@@ -1,3 +1,2 @@
-
 ################################################################################
 # This software was developed by the University of Tennessee as part of the
Index: src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py
===================================================================
--- src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py	(revision 8de66b66b52c8e66ba582290c53d3257a6fa6401)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py	(revision 8de66b66b52c8e66ba582290c53d3257a6fa6401)
@@ -2,83 +2,66 @@
     Sector interactor
 """
-import math
-import wx
+import numpy
+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.Utilities.GuiUtils as GuiUtils
+from sas.qtgui.Plotting.SlicerModel import SlicerModel
+
+MIN_PHI = 0.05
+
+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)
-        self.qmax = math.sqrt(x + y)
-        ## Number of points on the plot
+        # Compute qmax limit to reset the graph
+        x = numpy.power(max(self.base.data.xmax,
+                         numpy.fabs(self.base.data.xmin)), 2)
+        y = numpy.power(max(self.base.data.ymax,
+                         numpy.fabs(self.base.data.ymin)), 2)
+        self.qmax = numpy.sqrt(x + y)
+        # Number of points on the plot
         self.nbins = 20
-        ## Angle of the middle line
-        self.theta2 = math.pi / 3
-        ## Absolute value of the Angle between the middle line and any side line
-        self.phi = math.pi / 12
-        # Binning base for log/lin binning
-        self.bin_base = 0
-        ## Middle line
-        self.main_line = LineInteractor(self, self.base.subplot, color='blue',
+        # Angle of the middle line
+        self.theta2 = numpy.pi / 3
+        # Absolute value of the Angle between the middle line and any side line
+        self.phi = numpy.pi / 12
+        # 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
@@ -94,5 +77,4 @@
         self.right_line.clear()
         self.base.connect.clearall()
-        self.base.Unbind(EVT_SLICER_PARS)
 
     def update(self):
@@ -102,6 +84,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()
@@ -110,5 +92,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()
@@ -118,6 +100,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()
@@ -132,5 +113,4 @@
         can restore on Esc.
         """
-        self.base.freeze_axes()
         self.main_line.save(ev)
         self.right_line.save(ev)
@@ -143,23 +123,22 @@
         :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 is None:
+        if data == None:
             return
-        ## Averaging
+        # Averaging
         from sas.sascalc.dataloader.manipulations import SectorQ
         radius = self.qmax
         phimin = -self.left_line.phi + self.main_line.theta
         phimax = self.left_line.phi + self.main_line.theta
-        bin_base = self.bin_base
-        if nbins is None:
+        if nbins == None:
             nbins = 20
         sect = SectorQ(r_min=0.0, r_max=radius,
-                       phi_min=phimin + math.pi,
-                       phi_max=phimax + math.pi, nbins=nbins, base=bin_base)
-
-        sector = sect(self.base.data2D)
-        ##Create 1D data resulting from average
+                       phi_min=phimin + numpy.pi,
+                       phi_max=phimax + numpy.pi, nbins=nbins)
+
+        sector = sect(self.base.data)
+        # Create 1D data resulting from average
 
         if hasattr(sector, "dxl"):
@@ -174,23 +153,46 @@
         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)
+        self.base.manager.communicator.plotUpdateSignal.emit([new_plot])
+
+        if self.update_model:
+            self.setModelFromParams()
+        self.draw()
+
+    def validate(self, param_name, param_value):
+        """
+        Test the proposed new value "value" for row "row" of parameters
+        """
+        MIN_DIFFERENCE = 0.01
+        isValid = True
+
+        if param_name == 'Delta_Phi [deg]':
+            # First, check the closeness
+            if numpy.fabs(param_value) < MIN_DIFFERENCE:
+                print("Sector angles too close. Please adjust.")
+                isValid = False
+        elif param_name == 'nbins':
+            # Can't be 0
+            if param_value < 1:
+                print("Number of bins cannot be less than or equal to 0. Please adjust.")
+                isValid = False
+        return isValid
 
     def moveend(self, ev):
@@ -198,11 +200,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):
@@ -225,25 +222,22 @@
         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
-        if math.fabs(self.left_line.phi) != math.fabs(self.right_line.phi):
+        # Always make sure that the left and the right line are at phi
+        # angle of the middle line
+        if numpy.fabs(self.left_line.phi) != numpy.fabs(self.right_line.phi):
             msg = "Phi left and phi right are different"
             msg += " %f, %f" % (self.left_line.phi, self.right_line.phi)
             raise ValueError, msg
-        params["Phi [deg]"] = self.main_line.theta * 180 / math.pi
-        params["Delta_Phi [deg]"] = math.fabs(self.left_line.phi * 180 / math.pi)
+        params["Phi [deg]"] = self.main_line.theta * 180 / numpy.pi
+        params["Delta_Phi [deg]"] = numpy.fabs(self.left_line.phi * 180 / numpy.pi)
         params["nbins"] = self.nbins
-        params["binning base"] = self.bin_base
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         Receive a dictionary and reset the slicer with values contained
@@ -253,10 +247,15 @@
             values the user assigned to the slicer.
         """
-        main = params["Phi [deg]"] * math.pi / 180
-        phi = math.fabs(params["Delta_Phi [deg]"] * math.pi / 180)
+        main = params["Phi [deg]"] * numpy.pi / 180
+        phi = numpy.fabs(params["Delta_Phi [deg]"] * numpy.pi / 180)
+
+        # phi should not be too close.
+        if numpy.fabs(phi) < MIN_PHI:
+            phi = MIN_PHI
+            params["Delta_Phi [deg]"] = MIN_PHI
+
         self.nbins = int(params["nbins"])
-        self.bin_base = params["binning base"]
         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,
@@ -264,19 +263,10 @@
         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):
         """
+        Redraw canvas
         """
         self.base.draw()
@@ -292,27 +282,27 @@
     """
     def __init__(self, base, axes, color='black', zorder=5, r=1.0,
-                 phi=math.pi / 4, theta2=math.pi / 3):
+                 phi=numpy.pi / 4, theta2=numpy.pi / 3):
         """
         """
         _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
-        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
+        # End points polar coordinates
+        x1 = self.radius * numpy.cos(self.theta)
+        y1 = self.radius * numpy.sin(self.theta)
+        x2 = -1 * self.radius * numpy.cos(self.theta)
+        y2 = -1 * self.radius * numpy.sin(self.theta)
+        # Defining a new marker
         self.inner_marker = self.axes.plot([x1 / 2.5], [y1 / 2.5], linestyle='',
                                            marker='s', markersize=10,
@@ -321,13 +311,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])
 
@@ -335,7 +325,5 @@
         """
         Allow adding plot to the same panel
-
         :param n: the number of layer
-
         """
         self.layernum = n
@@ -364,20 +352,19 @@
 
         """
-        #print "update left or right ", self.has_move
         self.left_moving = left
         theta3 = 0
-        if phi is not None:
+        if phi != None:
             self.phi = phi
-        if delta is None:
+        if delta == None:
             delta = 0
         if  right:
-            self.phi = -1 * math.fabs(self.phi)
+            self.phi = -1 * numpy.fabs(self.phi)
             #delta=-delta
         else:
-            self.phi = math.fabs(self.phi)
+            self.phi = numpy.fabs(self.phi)
         if side:
             self.theta = mline.theta + self.phi
 
-        if mline is not None:
+        if mline != None:
             if delta != 0:
                 self.theta2 = mline + delta
@@ -388,8 +375,8 @@
         else:
             theta3 = self.theta2 + delta
-        x1 = self.radius * math.cos(theta3)
-        y1 = self.radius * math.sin(theta3)
-        x2 = -1 * self.radius * math.cos(theta3)
-        y2 = -1 * self.radius * math.sin(theta3)
+        x1 = self.radius * numpy.cos(theta3)
+        y1 = self.radius * numpy.sin(theta3)
+        x2 = -1 * self.radius * numpy.cos(theta3)
+        y2 = -1 * self.radius * numpy.sin(theta3)
         self.inner_marker.set(xdata=[x1 / 2.5], ydata=[y1 / 2.5])
         self.line.set(xdata=[x1, x2], ydata=[y1, y2])
@@ -401,5 +388,4 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -419,7 +405,6 @@
         Process move to a new position, making sure that the move is allowed.
         """
-        self.theta = math.atan2(y, x)
+        self.theta = numpy.arctan2(y, x)
         self.has_move = True
-        #ToDo: Simplify below
         if not self.left_moving:
             if  self.theta2 - self.theta <= 0 and self.theta2 > 0:
@@ -431,17 +416,17 @@
                 return
             elif  self.theta2 < 0 and self.theta > 0 and \
-                (self.theta2 + 2 * math.pi - self.theta) >= math.pi / 2:
+                (self.theta2 + 2 * numpy.pi - self.theta) >= numpy.pi / 2:
                 self.restore()
                 return
             elif  self.theta2 < 0 and self.theta < 0 and \
-                (self.theta2 - self.theta) >= math.pi / 2:
-                self.restore()
-                return
-            elif self.theta2 > 0 and (self.theta2 - self.theta >= math.pi / 2 or \
-                (self.theta2 - self.theta >= math.pi / 2)):
+                (self.theta2 - self.theta) >= numpy.pi / 2:
+                self.restore()
+                return
+            elif self.theta2 > 0 and (self.theta2 - self.theta >= numpy.pi / 2 or \
+                (self.theta2 - self.theta >= numpy.pi / 2)):
                 self.restore()
                 return
         else:
-            if  self.theta < 0 and (self.theta + math.pi * 2 - self.theta2) <= 0:
+            if  self.theta < 0 and (self.theta + numpy.pi * 2 - self.theta2) <= 0:
                 self.restore()
                 return
@@ -452,13 +437,12 @@
                 self.restore()
                 return
-            elif self.theta - self.theta2 >= math.pi / 2 or  \
-                ((self.theta + math.pi * 2 - self.theta2) >= math.pi / 2 and \
+            elif self.theta - self.theta2 >= numpy.pi / 2 or  \
+                ((self.theta + numpy.pi * 2 - self.theta2) >= numpy.pi / 2 and \
                  self.theta < 0 and self.theta2 > 0):
                 self.restore()
                 return
-
-        self.phi = math.fabs(self.theta2 - self.theta)
-        if self.phi > math.pi:
-            self.phi = 2 * math.pi - math.fabs(self.theta2 - self.theta)
+        self.phi = numpy.fabs(self.theta2 - self.theta)
+        if self.phi > numpy.pi:
+            self.phi = 2 * numpy.pi - numpy.fabs(self.theta2 - self.theta)
         self.base.base.update()
 
@@ -469,5 +453,5 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -477,5 +461,5 @@
         return params
 
-    def set_params(self, params):
+    def setParams(self, params):
         """
         """
@@ -489,5 +473,5 @@
     """
     def __init__(self, base, axes, color='black',
-                 zorder=5, r=1.0, theta=math.pi / 4):
+                 zorder=5, r=1.0, theta=numpy.pi / 4):
         """
         """
@@ -501,8 +485,8 @@
         self.scale = 10.0
         # Inner circle
-        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)
+        x1 = self.radius * numpy.cos(self.theta)
+        y1 = self.radius * numpy.sin(self.theta)
+        x2 = -1 * self.radius * numpy.cos(self.theta)
+        y2 = -1 * self.radius * numpy.sin(self.theta)
         # Inner circle marker
         self.inner_marker = self.axes.plot([x1 / 2.5], [y1 / 2.5], linestyle='',
@@ -543,10 +527,10 @@
         """
 
-        if theta is not None:
+        if theta != None:
             self.theta = theta
-        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)
+        x1 = self.radius * numpy.cos(self.theta)
+        y1 = self.radius * numpy.sin(self.theta)
+        x2 = -1 * self.radius * numpy.cos(self.theta)
+        y2 = -1 * self.radius * numpy.sin(self.theta)
 
         self.inner_marker.set(xdata=[x1 / 2.5], ydata=[y1 / 2.5])
@@ -559,5 +543,4 @@
         """
         self.save_theta = self.theta
-        self.base.freeze_axes()
 
     def moveend(self, ev):
@@ -577,5 +560,5 @@
         Process move to a new position, making sure that the move is allowed.
         """
-        self.theta = math.atan2(y, x)
+        self.theta = numpy.arctan2(y, x)
         self.has_move = True
         self.base.base.update()
@@ -587,5 +570,5 @@
         self.update()
 
-    def get_params(self):
+    def getParams(self):
         """
         """
@@ -595,5 +578,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 7432acb919f4013119ca918a73350297e0d4c93f)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py	(revision 83eb5208b8acb86b064162274de583670f72da47)
@@ -1,45 +1,46 @@
-import wx
-import math
-import numpy as np
-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 BoxInteractor(_BaseInteractor):
+import sas.qtgui.Utilities.GuiUtils as GuiUtils
+from sas.qtgui.Plotting.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)
@@ -142,8 +126,8 @@
             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)
+        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:
@@ -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
+        # Reset x, y- coordinates if send as parameters
         if x is not None:
-            self.x = np.sign(self.x) * math.fabs(x)
+            self.x = numpy.sign(self.x) * numpy.fabs(x)
         if y is not None:
-            self.y = np.sign(self.y) * math.fabs(y)
-        # # Draw lines and markers
+            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
+        # Reset x, y -coordinates if given as parameters
         if x is not None:
-            self.x = np.sign(self.x) * math.fabs(x)
+            self.x = numpy.sign(self.x) * numpy.fabs(x)
         if y is not None:
-            self.y = np.sign(self.y) * math.fabs(y)
-        # # draw lines and markers
+            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 7432acb919f4013119ca918a73350297e0d4c93f)
+++ src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py	(revision 83eb5208b8acb86b064162274de583670f72da47)
@@ -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.Utilities.GuiUtils import formatNumber
+
+from BaseInteractor import _BaseInteractor
+from sas.sascalc.dataloader.manipulations import Boxavg
+from sas.sascalc.dataloader.manipulations import Boxsum
+
+from sas.qtgui.Plotting.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 is not 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,11 +490,11 @@
         :param center: provided x, y  coordinates of the center point
         """
-        # # save the new height, witdh of the rectangle if given as a param
+        # Save the new height, witdh of the rectangle if given as a param
         if width is not None:
             self.half_width = width
         if height is not None:
             self.half_height = height
-        # # If new  center coordinates are given draw the rectangle
-        # #given these value
+        # If new  center coordinates are given draw the rectangle
+        # given these value
         if center is not None:
             self.center_x = center.x
@@ -510,5 +511,5 @@
                                ydata=[self.y1, self.y2])
             return
-        # # if x1, y1, y2, y3 are given draw the rectangle with this value
+        # if x1, y1, y2, y3 are given draw the rectangle with this value
         if x1 is not None:
             self.x1 = x1
@@ -519,5 +520,5 @@
         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,11 +651,11 @@
         :param center: provided x, y  coordinates of the center point
         """
-        # # save the new height, witdh of the rectangle if given as a param
+        # Save the new height, witdh of the rectangle if given as a param
         if width is not None:
             self.half_width = width
         if height is not None:
             self.half_height = height
-        # # If new  center coordinates are given draw the rectangle
-        # #given these value
+        # If new  center coordinates are given draw the rectangle
+        # given these value
         if center is not None:
             self.center_x = center.x
@@ -678,5 +673,5 @@
                                  ydata=[self.y2, self.y2])
             return
-        # # if x1, y1, y2, y3 are given draw the rectangle with this value
+        # if x1, y1, y2, y3 are given draw the rectangle with this value
         if x1 is not None:
             self.x1 = x1
@@ -687,5 +682,5 @@
         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)
