Reverse Diff

data_processor.py [e54dbc3e:44d20af] in sasview

File:

: 1 edited

src/sas/guiframe/data_processor.py (modified) (65 diffs)

Legend:

: Unmodified
: Added
: Removed

src/sas/guiframe/data_processor.py

-                      re54dbc3e
+                      r44d20af
 """
+Implement grid used to store data
+Implement grid used to store results of a batch fit.
+This is in Guiframe rather than fitting which is probably where it should be.
+Actually could be a generic framework implemented in fit gui module.  At this
+point however there this grid behaves independently of the fitting panel and
+only knows about information sent to it but not about the fits or fit panel and
+thus cannot feed back to the fitting panel.  This could change in the future.
+The organization of the classes goes as:
+.. image::  ../../user/guiframe/BatchGridClassLayout.png
+   :align:   center
 """
 import wx
 …
     """
     Object describing a cell in  the grid.
     """
     def __init__(self):
+        """
+        Initialize attributes of class (label, value, col, row, object)
+        """
         self.label = ""
         self.value = None
 …
     """
     Return a dictionary of column label and index or row selected
     :param sentence: String to parse
     :param list: list of columns label
+    :returns: col_dict
     """
     p2 = re.compile(r'\d+')
     p = re.compile(r'[\+\-\*\%\/]')
 …
 class SPanel(ScrolledPanel):
+    """
+    ensure proper scrolling of GridPanel
+    Adds a SetupScrolling call to the normal ScrolledPanel init.
+    GridPanel then subclasses this class
+    """
     def __init__(self, parent, *args, **kwds):
+        """
+        initialize ScrolledPanel then force a call to SetupScrolling
+        """
         ScrolledPanel.__init__(self, parent, *args, **kwds)
         self.SetupScrolling()
 …
 class GridCellEditor(sheet.CCellEditor):
+    """ Custom cell editor """
+    """
+    Custom cell editor
+    This subclasses the sheet.CCellEditor (itself a subclass of
+    grid.GridCellEditor) in order to override two of its methods:
+    PaintBackrgound and EndEdit.
+    This is necessary as the sheet module is broken in wx 3.0.2 and
+    improperly subclasses grid.GridCellEditor
+    """
     def __init__(self, grid):
+        """
+        Override of CCellEditor init. Runs the grid.GridCellEditor init code
+        """
         super(GridCellEditor, self).__init__(grid)
+    def PaintBackground(self, dc, rect, attr):
+        """
+        Overrides wx.sheet.CCellEditor.PaintBackground which incorrectly calls
+        the base class method.
+        In wx3.0 all paint objects must explicitly
+        have a wxPaintDC (Device Context) object.  Thus the paint event which
+        generates a call to this method provides such a DC object and the
+        base class in grid expects to receive that object.  sheet was apparently
+        not updated to reflect this and hence fails.  This could thus
+        become obsolete in a future bug fix of wxPython.
+        Apart from adding a dc variable in the list of arguments in the def
+        and in the call to the base class the rest of this method is copied
+        as is from sheet.CCellEditor.PaintBackground
+        **From original GridCellEditor docs:**
+        Draws the part of the cell not occupied by the edit control.  The
+        base class version just fills it with background colour from the
+        attribute.
+        NOTE: There is no need to override this if you don't need
+        to do something out of the ordinary.
+        :param dc: the wxDC object for the paint
+        """
+        # Call base class method.
+        DC = dc
+        super(sheet.CCellEditor,self).PaintBackground(DC, rect, attr)
     def EndEdit(self, row, col, grid, previous):
+        """
+            Commit editing the current cell. Returns True if the value has changed.
+            @param previous: previous value in the cell
+        """
+        Commit editing the current cell. Returns True if the value has changed.
+        :param previous: previous value in the cell
         """
         changed = False                             # Assume value not changed
 …
 class GridPage(sheet.CSheet):
     """
+    Class that receives the results of a batch fit.
+    GridPage displays the received results in a wx.grid using sheet.  This is
+    then used by GridPanel and GridFrame to present the full GUI.
     """
     def __init__(self, parent, panel=None):
         """
+        Initialize
+        Initialize all the attributes of GridPage, and the events. include
+        the init stuff from sheet.CSheet as well.
         """
         #sheet.CSheet.__init__(self, parent)
         # The following is the __init__ from CSheet. ##########################
         # We re-write it here because the class is broken in wx 3.0,
 …
         # Sink events
+        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
+        self.Bind(wx.grid.EVT_GRID_ROW_SIZE, self.OnRowSize)
+        self.Bind(wx.grid.EVT_GRID_COL_SIZE, self.OnColSize)
+        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnGridSelectCell)
+        # NOTE: the following bind to standard sheet methods that are
+        # overriden in this subclassn - actually we have currently
+        # disabled the on_context_menu that would override the OnRightClick
+        self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnCellChange)
         self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnLeftClick)
         self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightClick)
         #self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.OnLeftDoubleClick)
-        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
-        self.Bind(wx.grid.EVT_GRID_ROW_SIZE, self.OnRowSize)
-        self.Bind(wx.grid.EVT_GRID_COL_SIZE, self.OnColSize)
-        self.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnCellChange)
-        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnGridSelectCell)
         # This ends the __init__ section for CSheet. ##########################
+        # The following events must be bound even if CSheet is working
+        # properly and does not need the above re-implementation of the
+        # CSheet init method.  Basically these override any intrinsic binding
+        self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
+        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
         self.AdjustScrollbars()
 …
         if self.GetNumberCols() > 0:
             self.default_col_width = self.GetColSize(0)
+        # We have moved these to the top of the init section with the
+        # rest of the grid event bindings from the sheet init when
+        # appropriate
         #self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
         #self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
 …
     def OnLeftClick(self, event):
+        """
+        Overrides sheet.CSheet.OnLefClick.
+        Processes when a cell is selected by left clicking on that cell. First
+        process the base Sheet method then the current class specific method
+        """
         sheet.CSheet.OnLeftClick(self, event)
         self.on_selected_cell(event)
+    def on_edit_cell(self, event):
+        """
+    def OnCellChange(self, event):
+        """
+        Overrides sheet.CSheet.OnCellChange.
+        Processes when a cell has been edited by a cell editor. Checks for the
+        edited row being outside the max row to use attribute and if so updates
+        the last row.  Then calls the base handler using skip.
         """
         row, _ = event.GetRow(), event.GetCol()
 …
     def on_selected_cell(self, event):
         """
+        Handler catching cell selection
+        """
+        Handler catching cell selection.
+        Called after calling base 'on left click' method.
+        """
         flag = event.CmdDown() or event.ControlDown()
         flag_shift = event.ShiftDown()
 …
     def on_left_click(self, event):
         """
+        Catch the left click on label mouse event
+        """
+        Is triggered when the left mouse button is clicked while the mouse
+        is hovering over the column 'label.'
+        This processes the information on the selected column: the column name
+        (in row 0 of column) and the range of cells with a valid value to be
+        used by the GridPanel set_axis methods.
+        """
         flag = event.CmdDown() or event.ControlDown()
 …
     def on_right_click(self, event):
         """
+        Catch the right click mouse
+        """
+        Is triggered when the right mouse button is clicked while the mouse
+        is hovering over the column 'label.'
+        This brings up a context menu that allows the deletion of the column,
+        or the insertion of a new column either to the right or left of the
+        current column.  If inserting a new column can insert a blank column or
+        choose a number of hidden columns.  By default all the error parameters
+        are in hidden columns so as to save space on the grid.  Also any other
+        intrinsic variables stored with the data such as Temperature, pressure,
+        time etc can be used to populate this menu.
+        """
         col = event.GetCol()
         row = event.GetRow()
 …
     def insert_col_menu(self, menu, label, window):
         """
+        """
+        method called to populate the 'insert column before current column'
+        submenu.
+        """
         if self.data is None:
             return
 …
     def insert_after_col_menu(self, menu, label, window):
         """
+        """
+        Method called to populate the 'insert column after current column'
+        submenu
+        """
         if self.data is None:
             return
 …
     def on_remove_column(self, event=None):
         """
+        """
+        Called when user chooses remove from the column right click menu
+        Checks the columnn exists then calls the remove_column method
+        """
         if self.selected_cols is not None or len(self.selected_cols) > 0:
             col = self.selected_cols[0]
 …
     def remove_column(self, col, numCols=1):
         """
+        Remove column to the current grid
+        """
+        Remove the col column from the current grid
+        """
         # add data to the grid
         row = 0
 …
     def on_insert_column(self, event):
         """
+        """
+        Called when user chooses insert 'column before' submenu
+        of the column context menu obtained when right clicking on a given
+        column header.
+        Sets up to insert column into the current grid before the current
+        highlighted column location and sets up what to populate that column
+        with.  Then calls insert_column method to actually do the insertion.
+        """
         if self.selected_cols is not None or len(self.selected_cols) > 0:
             col = self.selected_cols[0]
 …
     def on_insert_after_column(self, event):
         """
+        Insert the given column after the highlighted column
+        """
+        Called when user chooses insert 'column after' submenu
+        of the column context menu obtained when right clicking on a given
+        column header.
+        Sets up to insert column into the current grid after the current
+        highlighted column location and sets up what to populate that column
+        with.  Then calls insert_column method to actually do the insertion.
+        """
         if self.selected_cols is not None or len(self.selected_cols) > 0:
             col = self.selected_cols[0] + 1
 …
     def insert_column(self, col, col_name):
         """
+        """
+        Insert column at position col with data[col_name] into the current
+        grid.
+        """
         row = 0
         self.InsertCols(pos=col, numCols=1, updateLabels=True)
 …
     def on_set_x_axis(self, event):
         """
+        """
+        Just calls the panel version of the method
+        """
         self.panel.set_xaxis(x=self.axis_value, label=self.axis_label)
     def on_set_y_axis(self, event):
         """
+        """
+        Just calls the panel version of the method
+        """
         self.panel.set_yaxis(y=self.axis_value, label=self.axis_label)
 …
         """
         Add data to the grid
         :param data_inputs: data to use from the context menu of the grid
+        :param data_ouputs: default columns deplayed
+        """
+        :param data_ouputs: default columns displayed
+        """
         self.file_name = file_name
         self.details = details
 …
         Set the values in grids
         """
         # add data to the grid
         row = 0
 …
         Return value contained in the grid
         """
         grid_view = {}
         for col in xrange(self.GetNumberCols()):
 …
     def onContextMenu(self, event):
         """
+        Default context menu
+        """
+        Method to handle cell right click context menu.
+        THIS METHOD IS NOT CURRENTLY USED.  It is designed to provide a
+        cell pop up context by right clicking on a cell and gives the
+        option to cut, paste, and clear. This will probably be removed in
+        future versions and is being superceded by more traditional cut and
+        paste options.
+        """
         wx_id = wx.NewId()
         c_menu = wx.Menu()
 …
     def on_copy(self, event):
         """
+        On copy event from the contextmenu
+        """
+        Called when copy is chosen from cell right click context menu
+        THIS METHOD IS NOT CURRENTLY USED.  it is part of right click cell
+        context menu which is being removed. This will probably be removed in
+        future versions and is being superceded by more traditional cut and
+        paste options
+        """
         self.Copy()
     def on_paste(self, event):
         """
+        On paste event from the contextmenu
+        """
+        Called when paste is chosen from cell right click context menu
+        THIS METHOD IS NOT CURRENTLY USED.  it is part of right click cell
+        context menu which is being removed. This will probably be removed in
+        future versions and is being superceded by more traditional cut and
+        paste options
+        """
         if self.data == None:
             self.data = {}
 …
     def on_clear(self, event):
         """
+        Clear the cells selected
+        """
+        Called when clear cell is chosen from cell right click context menu
+        THIS METHOD IS NOT CURRENTLY USED.  it is part of right click cell
+        context menu which is being removed. This will probably be removed in
+        future versions and is being superceded by more traditional cut and
+        paste options
+        """
         self.Clear()
 …
     ## Title to appear on top of the window
     """
     window_caption = "Notebook "
 …
     def enable_close_button(self):
         """
+        display the close button on tab for more than 1 tabs else remove the
+        close button
+        """
+        display the close button on the tab if more than 1 tab exits.
+        Otherwise remove the close button
+        """
         if self.GetPageCount() <= 1:
             style = self.GetWindowStyleFlag()
 …
     def on_edit_axis(self):
         """
+        Return the select cell of a given selected column. Check that all cells
+        are from the same column
+        """
+        Return the select cell range from a given selected column. Checks that
+        all cells are from the same column
+        """
         pos = self.GetSelection()
         grid = self.GetPage(pos)
 …
         Add highlight rows
         """
         pos = self.GetSelection()
         grid = self.GetPage(pos)
 …
     def get_column_labels(self):
         """
+        return dictionary of columns labels of the current page
+        """
+        return dictionary of columns labels on the current page
+        """
         pos = self.GetSelection()
         grid = self.GetPage(pos)
 …
         """
         Receive a list of cells and  create a string presenting the selected
+        cells.
+        cells that can be used as data for one axis of a plot.
         :param cell_list: list of tuple
         """
         pos = self.GetSelection()
 …
         close the page
         """
         if self.GetPageCount() == 1:
             event.Veto()
 …
     def set_data(self, data_inputs, data_outputs, details="", file_name=None):
+        """
+        """
         if data_outputs is None or data_outputs == {}:
             return
 …
     def get_odered_results(self, inputs, outputs=None):
         """
+        Get ordered the results
+        """
+        Order a list of 'inputs.' Used to sort rows and columns to present
+        in batch results grid.
+        """
         # Let's re-order the data from the keys in 'Data' name.
         if outputs == None:
 …
         Append a new column to the grid
         """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         pos = self.GetSelection()
         grid = self.GetPage(pos)
 …
         Remove the selected column from the grid
         """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         pos = self.GetSelection()
         grid = self.GetPage(pos)
 …
 class GridPanel(SPanel):
+    """
+    A ScrolledPanel class that contains the grid sheet as well as a number of
+    widgets to create interesting plots and buttons for help etc.
+    """
     def __init__(self, parent, data_inputs=None,
                  data_outputs=None, *args, **kwds):
+        """
+        Initialize the GridPanel
+        """
         SPanel.__init__(self, parent, *args, **kwds)
 …
     def get_plot_axis(self, col, list):
         """
         """
         axis = []
 …
     def on_view(self, event):
         """
+        Get object represented buy the given cell and plot them.
+        """
+        Get object represented by the given cells and plot them.  Basically
+        plot the colum in y vs the column in x.
+        """
         pos = self.notebook.GetSelection()
         grid = self.notebook.GetPage(pos)
 …
         Evaluate the contains of textcrtl and plot result
         """
         pos = self.notebook.GetSelection()
         grid = self.notebook.GetPage(pos)
 …
         running "file:///...."
+    :param evt: Triggers on clicking the help button
+    """
+        :param evt: Triggers on clicking the help button
+        """
         #import documentation window here to avoid circular imports
         #if put at top of file with rest of imports.
 …
         Get sentence from dict
         """
         for tok, (col_name, list) in dict.iteritems():
             col = column_names[col_name]
 …
     def layout_grid(self):
         """
+        Draw the area related to the grid
+        """
+        Draw the area related to the grid by adding it as the first element
+        in the panel's grid_sizer
+        """
         self.notebook = Notebook(parent=self)
         self.notebook.set_data(self._data_inputs, self._data_outputs)
 …
     def layout_plotting_area(self):
         """
+        Draw area containing options to plot
+        """
+        Add the area containing all the plot options, buttons etc to a plotting
+        area sizer to later be added to the top level grid_sizer
+        """
         view_description = wx.StaticBox(self, -1, 'Plot Fits/Residuals')
         note = "To plot the fits (or residuals), click the 'View Fits' button"
 …
                                    (self.plot_button, 0,
                                     wx.LEFT | wx.TOP | wx.BOTTOM, 12),
                                    (self.help_button,0,
+                                   (self.help_button,0,
                                     wx.LEFT | wx.TOP | wx.BOTTOM, 12)])
 …
         Get the selected column on  the visible grid and set values for axis
         """
         try:
             cell_list = self.notebook.on_edit_axis()
 …
         Receive a list of cells and  create a string presenting the selected
         cells.
         :param cell_list: list of tuple
+        """
+        """
         if self.notebook is not None:
             return self.notebook.create_axis_label(cell_list)
 …
         get controls to modify
         """
         if label != None:
             tcrtl_label.SetValue(str(label))
 …
         """
         """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         if self.notebook is not None:
             self.notebook.add_column()
 …
         """
         """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         if self.notebook is not None:
             self.notebook.on_remove_column()
 …
 class GridFrame(wx.Frame):
+    """
+    The main wx.Frame for the batch results grid
+    """
     def __init__(self, parent=None, data_inputs=None, data_outputs=None, id=-1,
+                 title="Grid Window", size=(800, 500)):
+                 title="Batch Fitting Results Panel", size=(800, 500)):
+        """
+        Initialize the Frame
+        """
         wx.Frame.__init__(self, parent=parent, id=id, title=title, size=size)
         self.parent = parent
 …
         wx.EVT_MENU(self, self.save_menu.GetId(), self.on_save_page)
+        # To add the edit menu, call add_edit_menu() here.
+        self.edit = None
+        # We need to grab a WxMenu handle here, otherwise the next one to grab
+        # the handle will be treated as the Edit Menu handle when checking in
+        # on_menu_open event handler and thus raise an exception when it hits an
+        # unitialized object.  Alternative is to comment out that whole section
+        # in on_menu_open, but that would make it more difficult to undo the
+        # hidding of the menu.   PDB  July 12, 2015.
+        #
+        # To enable the Edit menubar comment out next line and uncomment the
+        # following line.
+        self.edit = wx.Menu()
+        #self.add_edit_menu()
         self.Bind(wx.EVT_MENU_OPEN, self.on_menu_open)
         self.Bind(wx.EVT_CLOSE, self.on_close)
     def add_edit_menu(self, menubar):
+        """
+        populates the edit menu on the menubar.  Not activated as of SasView
+.1.0
+        """
         self.edit = wx.Menu()
 …
     def on_copy(self, event):
         """
+        On Copy
+        """
+        On Copy from the Edit menu item on the menubar
+        """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         if event != None:
             event.Skip()
 …
     def on_paste(self, event):
         """
+        On Paste
+        """
+        On Paste from the Edit menu item on the menubar
+        """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         if event != None:
             event.Skip()
 …
     def on_clear(self, event):
         """
+        On Clear
+        """
+        On Clear from the Edit menu item on the menubar
+        """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         pos = self.panel.notebook.GetSelection()
         grid = self.panel.notebook.GetPage(pos)
 …
     def on_remove_column(self, event):
         """
+        On remove column
+        """
+        On remove column from the Edit menu Item on the menubar
+        """
+        # I Believe this is no longer used now that we have removed the
+        # edit menu from the menubar - PDB July 12, 2015
         pos = self.panel.notebook.GetSelection()
         grid = self.panel.notebook.GetPage(pos)
 …
     def on_save_page(self, event):
         """
+        """
+        Saves data in grid to a csv file.
+        At this time only the columns displayed get saved.  Thus any error
+        bars not inserted before saving will not be saved in the file
+        """
         if self.parent is not None:
             pos = self.panel.notebook.GetSelection()
 …
     def on_open(self, event):
         """
+        Open file containg batch result
+        """
+        Open file containing batch result
+        """
         if self.parent is not None:
             self.parent.on_read_batch_tofile(self)
 …
         open excel and display batch result in Excel
         """
         if self.parent is not None:
             pos = self.panel.notebook.GetSelection()
 …
                  details="", *args, **kwds):
         """
+        Initialize dialog
         :param parent: Window instantiating this dialog
         :param result: result to display in a grid or export to an external
+        :param result: result to display in a grid or export to an external\
                 application.
         """
         #kwds['style'] = wx.CAPTION|wx.SYSTEM_MENU
         wx.Frame.__init__(self, parent, *args, **kwds)
 …
         Draw the content of the current dialog window
         """
         vbox = wx.BoxSizer(wx.VERTICAL)
         box_description = wx.StaticBox(self.panel, -1, str("Batch Outputs"))
 …
         Get the user selection and display output to the selected application
         """
         if self.flag == 1:
             self.parent.open_with_localapp(data_inputs=self.data_inputs,
 …
         close the Window
         """
         self.Close()
 …
         Receive event and display data into third party application
         or save data to file.
         """
         if self.save_to_file.GetValue():

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changes in src/sas/guiframe/data_processor.py [e54dbc3e:44d20af] in sasview

Legend:

src/sas/guiframe/data_processor.py

Download in other formats: