source: sasview/sansguiframe/src/sans/guiframe/data_processor.py @ aac129aa

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since aac129aa was e25d908, checked in by Jae Cho <jhjcho@…>, 13 years ago

Batch Grid: fixed a bug when a file opened and read

  • Property mode set to 100644
File size: 53.5 KB
Line 
1"""
2Implement grid used to store data
3"""
4import wx
5import numpy
6import math
7import time
8import re
9import os
10import sys
11import copy
12from wx.lib.scrolledpanel import ScrolledPanel
13import  wx.grid as  Grid
14import wx.aui
15from wx.aui import AuiNotebook as nb
16import wx.lib.sheet as sheet
17from sans.guiframe.panel_base import PanelBase
18from sans.guiframe.utils import format_number
19from sans.guiframe.events import NewPlotEvent
20from sans.guiframe.events import StatusEvent 
21from danse.common.plottools import plottables
22from sans.guiframe.dataFitting import Data1D
23
24FUNC_DICT = {"sqrt": "math.sqrt",
25             "pow": "math.sqrt"}
26
27class BatchCell:
28    """
29    Object describing a cell in  the grid.
30   
31    """
32    def __init__(self):
33        self.label = ""
34        self.value = None
35        self.col = -1
36        self.row = -1
37        self.object = []
38       
39
40def parse_string(sentence, list):
41    """
42    Return a dictionary of column label and index or row selected
43    :param sentence: String to parse
44    :param list: list of columns label
45    """
46    toks = []
47    p2 = re.compile(r'\d+')
48    p = re.compile(r'[\+\-\*\%\/]')
49    labels = p.split(sentence)
50    col_dict = {}
51    for elt in labels:
52        rang = None
53        temp_arr = []
54        for label in  list:
55            label_pos =  elt.find(label)
56            separator_pos  = label_pos + len(label)
57            if label_pos != -1 and len(elt) >= separator_pos  and\
58                elt[separator_pos]== "[":
59                # the label contain , meaning the range selected is not
60                # continuous
61                if elt.count(',') > 0:
62                    new_temp = []
63                    temp = elt.split(label)
64                    for item in temp:
65                        range_pos = item.find(":")
66                        if range_pos != -1:
67                            rang = p2.findall(item)
68                            for i in xrange(int(rang[0]), int(rang[1])+1 ):
69                                new_temp.append(i)
70                    temp_arr += new_temp
71                else:
72                    # continuous range
73                    temp = elt.split(label)
74                    for item in temp:
75                        if item.strip() != "":
76                            range_pos = item.find(":")
77                            if range_pos != -1:
78                                rang = p2.findall(item)
79                                for i in xrange(int(rang[0]), int(rang[1])+1 ):
80                                    temp_arr.append(i)
81                col_dict[elt] = (label, temp_arr)
82    return col_dict
83
84         
85         
86class SPanel(ScrolledPanel):
87    def __init__(self, parent, *args, **kwds):
88        ScrolledPanel.__init__(self, parent , *args, **kwds)
89        self.SetupScrolling() 
90       
91class GridPage(sheet.CSheet):
92    """
93    """
94    def __init__(self, parent, panel=None):
95        """
96        """
97        sheet.CSheet.__init__(self, parent)
98       
99        self.AdjustScrollbars()
100        #self.SetLabelBackgroundColour('#DBD4D4')
101        self.uid = wx.NewId()
102        self.parent = parent
103        self.panel = panel
104        self.col_names = []
105        self.data_inputs = {}
106        self.data_outputs = {}
107        self.data = None
108        self.details = ""
109        self.file_name = None
110        self._cols = 50
111        self._rows = 51
112        self.last_selected_row = -1
113        self.last_selected_col = -1
114        self.col_width = 30
115        self.row_height = 20
116        self.max_row_touse = 0
117        self.axis_value = []
118        self.axis_label = ""
119        self.selected_cells = []
120        self.selected_cols = []
121        self.selected_rows = []
122        self.plottable_cells = []
123        self.plottable_flag = False
124        self.SetColMinimalAcceptableWidth(self.col_width)
125        self.SetRowMinimalAcceptableHeight(self.row_height)
126        self.SetNumberRows(self._cols)
127        self.SetNumberCols(self._rows)
128        self.AutoSize()
129        self.list_plot_panels = {}
130        self.default_col_width = 75
131        self.EnableEditing(False)
132        if self.GetNumberCols() > 0:
133            self.default_col_width =  self.GetColSize(0)
134        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_left_click)
135        self.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK, self.on_right_click)
136        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.on_selected_cell)
137        self.Bind(wx.grid.EVT_GRID_CMD_CELL_CHANGE, self.on_edit_cell)
138       
139       
140    def on_edit_cell(self, event):
141        """
142        """
143        row, col = event.GetRow(), event.GetCol()
144        if row > self.max_row_touse:
145            self.max_row_touse = row
146        event.Skip()
147       
148    def on_selected_cell(self, event):
149        """
150        Handler catching cell selection
151        """
152        flag = event.CmdDown() or event.ControlDown()
153        row, col = event.GetRow(), event.GetCol()
154        cell = (row, col)
155        event.Skip()
156        if not flag:
157            self.selected_cols = []
158            self.selected_rows = []
159            self.selected_cells = []
160            self.axis_label = ""
161            self.axis_value = []
162            self.plottable_list = []
163            self.plottable_cells = []
164            self.plottable_flag = False
165        self.last_selected_col = col
166        self.last_selected_row = row
167        if col >= 0:
168            label_row = 0
169            self.axis_label = self.GetCellValue(label_row, col)
170            self.selected_cols.append(col)
171        if cell not in self.selected_cells:
172            if row > 0:
173                self.selected_cells.append(cell)
174                self.selected_rows.append(row)
175        else:
176            if flag:
177                self.selected_cells.remove(cell)
178        self.axis_value = []
179        for cell_row, cell_col in self.selected_cells:
180            if cell_row > 0 and cell_row < self.max_row_touse:
181                self.axis_value.append(self.GetCellValue(cell_row, cell_col))
182
183               
184    def on_left_click(self, event):
185        """
186        Catch the left click on label mouse event
187        """
188        event.Skip()
189        flag = event.CmdDown() or event.ControlDown()
190        col = event.GetCol()
191        row = event.GetRow()
192        if not flag:
193            self.selected_cols = []
194            self.selected_rows = []
195            self.selected_cells = []
196            self.axis_label = ""
197            self.axis_value = []
198            self.plottable_list = []
199            self.plottable_cells = []
200            self.plottable_flag = False
201       
202        self.last_selected_col = col
203        self.last_selected_row = row
204        if row != -1 and row not in self.selected_rows:
205             self.selected_rows.append(row)
206             
207        if col != -1:
208            for row in range(1, self.GetNumberRows()+ 1):
209                cell = (row, col)
210                if row > 0 and row < self.max_row_touse:
211                    if cell not in self.selected_cells:
212                        self.selected_cells.append(cell)
213                    else:
214                        if flag:
215                             self.selected_cells.remove(cell)
216            self.selected_cols.append(col)
217            self.axis_value = []
218            for cell_row, cell_col in self.selected_cells:
219                self.axis_value.append(self.GetCellValue(cell_row, cell_col))
220            self.axis_label = self.GetCellValue(0, col)
221       
222    def on_right_click(self, event):
223        """
224        Catch the right click mouse
225        """
226       
227        col = event.GetCol()
228        self.selected_cols = []
229        self.selected_cols.append(col)
230        # Slicer plot popup menu
231        slicerpop = wx.Menu()
232        col_label_menu  = wx.Menu()
233        c_name = self.GetCellValue(0, col) 
234        label = "Insert column before %s " % str(c_name)
235        slicerpop.AppendSubMenu(col_label_menu , 
236                                 '&%s' % str(label), str(label))
237        col_name = [self.GetCellValue(0, c) 
238                        for c in range(self.GetNumberCols())]
239        row = 0
240        label = self.GetCellValue(row, col)
241        self.insert_col_menu(col_label_menu, label, self)
242       
243       
244        col_after_menu  = wx.Menu()
245        label = "Insert column after %s " % str(c_name)
246        slicerpop.AppendSubMenu(col_after_menu , 
247                                 '&%s' % str(label), str(label))
248        col_name = [self.GetCellValue(0, c) 
249                        for c in range(self.GetNumberCols())]
250        self.insert_after_col_menu(col_after_menu, label, self)
251       
252       
253        id = wx.NewId()   
254        hint = 'Remove selected column %s'
255        slicerpop.Append(id, '&Remove Column', hint)
256        wx.EVT_MENU(self, id, self.on_remove_column)
257       
258        pos = wx.GetMousePosition()
259        pos = self.ScreenToClient(pos)
260        self.PopupMenu(slicerpop, pos)
261        event.Skip()
262       
263    def insert_col_menu(self, menu, label, window):
264        """
265        """
266        if self.data is None:
267            return
268        id = wx.NewId()
269        title = "Empty"
270        hint = 'Insert empty column before %s' % str(label)
271        menu.Append(id, title, hint)
272        wx.EVT_MENU(window, id, self.on_insert_column)
273        row = 0
274        col_name = [self.GetCellValue(row, col) 
275                        for col in range(self.GetNumberCols())]
276        for c_name in self.data.keys():
277            if c_name not in col_name:
278                id = wx.NewId()
279                hint = "Insert %s column before the " % str(c_name)
280                hint += " %s column" % str(label)
281                menu.Append(id, '&%s' % str(c_name), hint)
282                wx.EVT_MENU(window, id, self.on_insert_column)
283           
284    def insert_after_col_menu(self, menu, label, window):
285        """
286        """
287        if self.data is None:
288            return
289        id = wx.NewId()
290        title = "Empty"
291        hint = 'Insert empty column after %s' % str(label)
292        menu.Append(id, title, hint)
293        wx.EVT_MENU(window, id, self.on_insert_after_column)
294        row = 0
295        col_name = [self.GetCellValue(row, col) 
296                        for col in range(self.GetNumberCols())]
297        for c_name in self.data.keys():
298            if c_name not in col_name:
299                id = wx.NewId()
300                hint = "Insert %s column after the " % str(c_name)
301                hint += " %s column" % str(label)
302                menu.Append(id, '&%s' % str(c_name), hint)
303                wx.EVT_MENU(window, id, self.on_insert_after_column)
304                               
305    def on_remove_column(self, event=None):
306        """
307        """
308        if self.selected_cols is not None or len(self.selected_cols) > 0:
309            col = self.selected_cols[0]
310            self.remove_column(col=col, numCols=1)
311           
312    def remove_column(self, col, numCols=1):
313        """
314        Remove column to the current grid
315        """
316        # add data to the grid   
317        row = 0
318        col_name = self.GetCellValue(row, col)
319        self.data[col_name] = []
320        for row in range(1, self.GetNumberRows() + 1):
321            if row < self.max_row_touse:
322                value = self.GetCellValue(row, col)
323                self.data[col_name].append(value)
324                for k , value_list in self.data.iteritems():
325                    if k != col_name:
326                        length = len(value_list)
327                        if length < self.max_row_touse:
328                            diff = self.max_row_touse - length
329                            for i in range(diff):
330                                self.data[k].append("")
331        self.DeleteCols(pos=col, numCols=numCols, updateLabels=True)
332           
333    def on_insert_column(self, event):
334        """
335        """
336        if self.selected_cols is not None or len(self.selected_cols) > 0:
337            col = self.selected_cols[0]
338            # add data to the grid   
339            row = 0
340            id = event.GetId()
341            col_name = event.GetEventObject().GetLabelText(id)
342            self.insert_column(col=col, col_name=col_name)
343            if  not issubclass(event.GetEventObject().__class__ , wx.Menu):
344                col += 1
345                self.selected_cols[0] += 1
346               
347    def on_insert_after_column(self, event):
348        """
349        Insert the given column after the highlighted column
350        """
351        if self.selected_cols is not None or len(self.selected_cols) > 0:
352            col = self.selected_cols[0] + 1
353            # add data to the grid   
354            row = 0
355            id = event.GetId()
356            col_name = event.GetEventObject().GetLabelText(id)
357            self.insert_column(col=col, col_name=col_name)
358            if  not issubclass(event.GetEventObject().__class__ , wx.Menu):
359                self.selected_cols[0] += 1
360           
361    def insert_column(self, col, col_name):
362        """
363        """ 
364         
365        row = 0
366        self.InsertCols(pos=col, numCols=1, updateLabels=True)
367        if col_name.strip() != "Empty":
368            self.SetCellValue(row, col, str(col_name.strip()))
369        if col_name in self.data.keys():
370            value_list = self.data[col_name]
371            cell_row =  1
372            for value in value_list:
373                label = value#format_number(value, high=True)
374                self.SetCellValue(cell_row, col, str(label))
375                cell_row += 1
376        self.AutoSizeColumn(col, True)
377        width = self.GetColSize(col)
378        if width < self.default_col_width:
379           self.SetColSize(col, self.default_col_width)
380        self.ForceRefresh()
381       
382    def on_set_x_axis(self, event):
383        """
384        """
385        self.panel.set_xaxis(x=self.axis_value, label=self.axis_label)
386   
387    def on_set_y_axis(self, event):
388        """
389        """
390        self.panel.set_yaxis(y=self.axis_value, label=self.axis_label)     
391           
392    def set_data(self, data_inputs, data_outputs, details, file_name):
393        """
394        Add data to the grid
395        :param data_inputs: data to use from the context menu of the grid
396        :param data_ouputs: default columns deplayed
397        """
398        self.file_name = file_name
399        self.details = details
400       
401        if data_outputs is None:
402            data_outputs = {}
403        self.data_outputs = data_outputs
404        if data_inputs is None:
405            data_inputs = {}
406        self.data_inputs = data_inputs
407        self.data = {}
408        for item in (self.data_outputs, self.data_inputs):
409            self.data.update(item)
410           
411        if len(self.data) + len(self.data_inputs) +len(self.data_outputs) == 0:
412            self.EnableEditing(False)
413        else:
414            self.EnableEditing(True)
415        if  len(self.data_outputs) > 0:
416            self._cols = self.GetNumberCols()
417            self._rows = self.GetNumberRows()
418            self.col_names = self.data_outputs.keys()
419            self.col_names.sort() 
420            nbr_user_cols = len(self.col_names)
421            #Add more columns to the grid if necessary
422            if nbr_user_cols > self._cols:
423                new_col_nbr = nbr_user_cols -  self._cols
424                self.AppendCols(new_col_nbr, True)
425            #Add more rows to the grid if necessary 
426            nbr_user_row = len(self.data_outputs.values())
427            if nbr_user_row > self._rows + 1:
428                new_row_nbr =  nbr_user_row - self._rows
429                self.AppendRows(new_row_nbr, True)
430            # add data to the grid   
431            row = 0
432            col = 0
433            cell_col = 0
434            for col_name in  self.col_names:
435                # use the first row of the grid to add user defined labels
436                self.SetCellValue(row, col, str(col_name))
437                col += 1
438                cell_row =  1
439                value_list = self.data_outputs[col_name]
440               
441                for value in value_list:
442                    label = value
443                    if issubclass(value.__class__, BatchCell):
444                        label = value.label
445                    try:
446                        float(label)
447                        label = str(label)#format_number(label, high=True)
448                    except:
449                        label = str(label)
450                    self.SetCellValue(cell_row, cell_col, label)
451                    self.AutoSizeColumn(cell_col, True)
452                    width = self.GetColSize(cell_col)
453                    if width < self.default_col_width:
454                       self.SetColSize(cell_col, self.default_col_width)
455                   
456                    cell_row += 1
457                cell_col += 1
458                if cell_row > self.max_row_touse:
459                    self.max_row_touse = cell_row
460        self.ForceRefresh()
461       
462    def get_grid_view(self):
463        """
464        Return value contained in the grid
465        """
466        grid_view = {}
467        for col in xrange(self.GetNumberCols()):
468            label = self.GetCellValue(row=0, col=col) 
469            label = label.strip()
470            if label != "":
471                grid_view[label] = []
472                for row in range(1, self.max_row_touse):
473                    value = self.GetCellValue(row=row, col=col)
474                    if value != "":
475                        grid_view[label].append(value) 
476                    else:
477                        grid_view[label].append(None) 
478        return grid_view
479   
480class Notebook(nb, PanelBase):
481    """
482    ## Internal name for the AUI manager
483    window_name = "Fit panel"
484    ## Title to appear on top of the window
485    """
486    window_caption = "Notebook "
487   
488    def __init__(self, parent, manager=None, data=None, *args, **kwargs):
489        """
490        """
491        nb.__init__(self, parent, -1,
492                    style=wx.aui.AUI_NB_WINDOWLIST_BUTTON| 
493                    wx.aui.AUI_BUTTON_DOWN|
494                    wx.aui.AUI_NB_DEFAULT_STYLE|
495                    wx.CLIP_CHILDREN)
496        PanelBase.__init__(self, parent)
497        self.enable_close_button()
498        self.parent = parent
499        self.manager = manager
500        self.data = data
501        #add empty page
502        self.add_empty_page()
503       
504        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.on_close_page)
505   
506    def add_empty_page(self):
507        """
508        """
509        grid = GridPage(self, panel=self.parent)
510        self.AddPage(grid, "", True)
511        pos = self.GetPageIndex(grid)
512        title = "Batch" + str(self.GetPageCount())
513        self.SetPageText(pos, title)
514        self.SetSelection(pos)
515        return grid , pos
516       
517    def enable_close_button(self):
518        """
519        display the close button on tab for more than 1 tabs else remove the
520        close button
521        """
522        if self.GetPageCount() <= 1:
523            style = self.GetWindowStyleFlag() 
524            flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
525            if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB == flag:
526                style = style & ~wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
527                self.SetWindowStyle(style)
528        else:
529            style = self.GetWindowStyleFlag()
530            flag = wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
531            if style & wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB != flag:
532                style |= wx.aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
533                self.SetWindowStyle(style)
534             
535    def on_edit_axis(self):
536        """
537        Return the select cell of a given selected column. Check that all cells
538        are from the same column
539        """
540        pos = self.GetSelection()
541        grid = self.GetPage(pos)
542        if len(grid.selected_cols) >= 1:
543            col = grid.selected_cols[0]
544            for c in grid.selected_cols:
545                if c != col:
546                    msg = "Edit axis doesn't understand this selection.\n"
547                    msg += "Please select only one column"
548                    raise ValueError, msg
549            for (cell_row, cell_col) in grid.selected_cells:
550                if cell_col != col:
551                    msg = "Cannot use cells from different columns for "
552                    msg += "this operation.\n"
553                    msg += "Please select elements of the same col.\n"
554                    raise ValueError, msg
555        else:
556            msg = "No item selected.\n"
557            msg += "Please select only one column or one cell"
558            raise ValueError, msg
559       
560        return grid.selected_cells
561       
562   
563    def get_column_labels(self):
564        """
565        return dictionary of columns labels of the current page
566        """
567        pos = self.GetSelection()
568        grid = self.GetPage(pos)
569        labels = {}
570        row = 0
571        for col in range(grid.GetNumberCols()):
572            label = grid.GetCellValue(row, col)
573            if label.strip() != "" :
574                labels[label.strip()] = col
575        return labels
576       
577    def create_axis_label(self, cell_list):
578        """
579        Receive a list of cells and  create a string presenting the selected
580        cells.
581        :param cell_list: list of tuple
582       
583        """
584        pos = self.GetSelection()
585        grid = self.GetPage(pos)
586        label = ""
587        col_name = ""
588        def create_label(col_name,  row_min=None, row_max=None):
589            """
590            """
591            result = ""
592            if row_min is not  None or row_max is not None:
593                if row_min is None:
594                    result = str(row_max) + "]"
595                elif row_max is None:
596                     result = str(col_name) + "[" + str(row_min) + ":"
597                else:
598                    result = str(col_name) +  "[" + str(row_min) + ":"
599                    result += str(row_max) + "]"
600            return str(result)
601           
602        if len(cell_list) > 0:
603            if len(cell_list) == 1:
604                 row_min, col  = cell_list[0]   
605                 col_name = grid.GetCellValue(0, col)
606                 label = create_label(col_name, row_min+1 , row_min+1)
607                 return  label,  col_name
608            else:
609                temp_list = copy.deepcopy(cell_list)
610                temp_list.sort()
611                length = len(temp_list)
612                row_min, col  = temp_list[0]   
613                row_max, _  = temp_list[length-1]
614                col_name = grid.GetCellValue(0, col)
615                index = 0
616                for row in xrange(row_min, row_max +1):
617                    if index > 0 and index < len(temp_list):
618                        new_row, _ = temp_list[index]
619                        if row != new_row:
620                            temp_list.insert(index, (None, None))
621                            if index -1 >= 0:
622                                new_row, _ = temp_list[index-1]
623                                label += create_label(col_name, None, new_row +1)
624                                label += ","
625                            if index + 1 < len(temp_list):
626                                new_row, _ = temp_list[index + 1]
627                                label += create_label(col_name, new_row+1, None)
628                    if index == 0:
629                        label += create_label(col_name,  row_min+1, None)
630                    elif index == len(temp_list)-1:
631                        label += create_label(col_name, None, row_max+1)
632                    index += 1
633                return label, col_name
634   
635    def on_close_page(self, event):
636        """
637        close the page
638        """
639        if self.GetPageCount() == 1:
640            event.Veto()
641        self.enable_close_button()
642       
643    def set_data(self, data_inputs, data_outputs, details="", file_name=None):
644        if data_outputs is None or data_outputs == {}:
645            return
646        inputs, outputs = self.get_odered_results(data_inputs, data_outputs)
647        for pos in range(self.GetPageCount()):
648            grid = self.GetPage(pos)
649            if grid.data is None:
650                #Found empty page
651                grid.set_data(data_inputs=inputs, 
652                              data_outputs=outputs,
653                              details=details,
654                              file_name=file_name) 
655                self.SetSelection(pos) 
656                return
657               
658        grid, pos = self.add_empty_page()
659        grid.set_data(data_inputs=inputs, 
660                      data_outputs=outputs,
661                      file_name=file_name,
662                      details=details)
663       
664    def get_odered_results(self, inputs, outputs=None):
665        """
666        Get ordered the results
667        """
668        # Let's re-order the data from the keys in 'Data' name.
669        if outputs == None:
670            return
671        try:
672            # For outputs from batch
673            to_be_sort = [str(item.label) for item in outputs['Data']]
674        except:
675            # When inputs are from an external file
676            return inputs, outputs
677        inds = numpy.lexsort((to_be_sort, to_be_sort))
678        for key in outputs.keys():
679            key_list = outputs[key]
680            temp_key = [item for item in key_list]
681            for ind in inds:
682                temp_key[ind] = key_list[inds[ind]]
683            outputs[key] = temp_key
684        for key in inputs.keys():
685            key_list = inputs[key]
686            if len(key_list) > 0:
687                temp_key = [item for item in key_list]
688                for ind in inds:
689                    temp_key[ind] = key_list[inds[ind]]
690                inputs[key] = temp_key
691        return inputs, outputs
692   
693    def add_column(self):
694        """
695        Append a new column to the grid
696        """
697        pos = self.GetSelection()
698        grid = self.GetPage(pos)
699        grid.AppendCols(1, True)
700       
701class GridPanel(SPanel):
702    def __init__(self, parent, data_inputs=None,
703                 data_outputs=None, *args, **kwds):
704        SPanel.__init__(self, parent , *args, **kwds)
705       
706        self.vbox = wx.BoxSizer(wx.VERTICAL)
707       
708        self.plotting_sizer = wx.FlexGridSizer(3, 7, 10, 5)
709        self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
710        self.grid_sizer = wx.BoxSizer(wx.HORIZONTAL)
711        self.vbox.AddMany([(self.grid_sizer, 1, wx.EXPAND, 0),
712                           (wx.StaticLine(self, -1), 0, wx.EXPAND, 0),
713                           (self.plotting_sizer),
714                           (self.button_sizer)])
715        self.parent = parent
716        self._data_inputs = data_inputs
717        self._data_outputs = data_outputs
718        self.x = []
719        self.= []
720        self.x_axis_label = None
721        self.y_axis_label = None
722        self.x_axis_title = None
723        self.y_axis_title = None
724        self.x_axis_unit = None
725        self.y_axis_unit = None
726        self.view_button = None
727        self.plot_button = None
728        self.notebook = None
729       
730        self.layout_grid()
731        self.layout_plotting_area()
732        self.SetSizer(self.vbox)
733
734    def set_xaxis(self, label="", x=None):
735        """
736        """
737        if x is None:
738            x = []
739        self.x = x
740        self.x_axis_label.SetValue("%s[:]" % str(label))
741        self.x_axis_title.SetValue(str(label))
742       
743    def set_yaxis(self, label="", y=None):
744        """
745        """
746        if y is None:
747            y = []
748        self.y = y
749        self.y_axis_label.SetValue("%s[:]" % str(label))
750        self.y_axis_title.SetValue(str(label))
751       
752    def get_plot_axis(self, col, list):
753        """
754       
755        """
756        axis = []
757        pos = self.notebook.GetSelection()
758        grid = self.notebook.GetPage(pos)
759        for row in list:
760            label = grid.GetCellValue(0, col)
761            value = grid.GetCellValue(row - 1, col).strip()
762            if value != "":
763                if label.lower().strip() == "data":
764                    axis.append(float(row - 1))
765                else:
766                    try:
767                        axis.append(float(value))
768                    except:
769                        msg = "Invalid data in row %s column %s" % (str(row),
770                                                                    str(col))
771                        wx.PostEvent(self.parent.parent, 
772                             StatusEvent(status=msg, info="error")) 
773            else:
774                axis.append(None) 
775        return axis
776   
777    def on_save_column(self, parent):
778        """
779        """
780        pos = self.notebook.GetSelection()
781        grid = self.notebook.GetPage(pos)
782        if parent is not None and  self.data is not None:
783            parent.write_batch_tofile(data=grid.data, 
784                                               file_name=path,
785                                               details=self.details)
786       
787    def on_view(self, event):
788        """
789        Get object represented buy the given cell and plot them.
790        """
791        pos = self.notebook.GetSelection()
792        grid = self.notebook.GetPage(pos)
793        title = self.notebook.GetPageText(pos)
794        if len(grid.selected_cells) == 0:
795            msg = "Highlight a Data or Chi2 column first..."
796            wx.PostEvent(self.parent.parent, 
797                             StatusEvent(status=msg, info="error")) 
798            return
799        for cell in grid.selected_cells:
800            row, col = cell
801            label_row = 0
802            label = grid.GetCellValue(label_row, col)
803            if label in grid.data:
804                values = grid.data[label]
805                if row > len(values) or row < 1:
806                    msg = "Invalid cell was chosen." 
807                    wx.PostEvent(self.parent.parent, StatusEvent(status=msg, 
808                                                                info="error"))
809                    time.sleep(0.5)
810                    continue
811                else:
812                     value = values[row -1]
813                if issubclass(value.__class__, BatchCell):
814                    if value.object is None or len(value.object) == 0:
815                        msg = "Row %s , " % str(row)
816                        msg += "Column %s is NOT " % str(label)
817                        msg += "the results of fits to view..."
818                        #raise ValueError, msg
819                        wx.PostEvent(self.parent.parent, StatusEvent(status=msg, 
820                                                                info="error")) 
821                        return
822                    for new_plot in value.object:
823                        if new_plot is None or \
824                         not issubclass(new_plot.__class__, 
825                                        plottables.Plottable):
826                            msg = "Row %s , " % str(row)
827                            msg += "Column %s is NOT " % str(label)
828                            msg += "the results of fits to view..."
829                            #raise ValueError, msg
830                            wx.PostEvent(self.parent.parent, 
831                                 StatusEvent(status=msg, info="error")) 
832                            time.sleep(0.5)
833                            continue
834                        #new_plot.name =  title + ': ' + new_plot.title
835                        if issubclass(new_plot.__class__, Data1D):
836                            if label in grid.list_plot_panels.keys():
837                                group_id = grid.list_plot_panels[label]
838                            else:
839                                group_id = str(new_plot.group_id) + str(grid.uid)
840                                grid.list_plot_panels[label] = group_id
841                            if group_id not in new_plot.list_group_id:
842                                new_plot.group_id = group_id
843                                new_plot.list_group_id.append(group_id)
844                        else:
845                            if label.lower() in ["data", "chi2"]:
846                                if len(grid.selected_cells) != 1:
847                                    msg = "2D View: Please select one data set"
848                                    msg += " at a time for View Results."
849                                    wx.PostEvent(self.parent.parent, 
850                                                 StatusEvent(status=msg,
851                                                              info="error"))
852                                    time.sleep(0.5) 
853                                    continue 
854                        """
855                        wx.PostEvent(self.parent.parent,
856                                     NewPlotEvent(action="clear",
857                                                  group_id=str(group_id),
858                                                  title=title))
859                        """ 
860                        wx.PostEvent(self.parent.parent, 
861                                     NewPlotEvent(plot=new_plot, 
862                                                group_id=str(new_plot.group_id),
863                                                title=title)) 
864                        msg = "Plotting the View Results  completed!"
865                        wx.PostEvent( self.parent.parent, 
866                                      StatusEvent(status=msg)) 
867                else:
868                   
869                    msg = "Row %s , " % str(row)
870                    msg += "Column %s is NOT " % str(label)
871                    msg += "the results of fits to view..."
872                    #raise ValueError, msg
873                    wx.PostEvent(self.parent.parent, 
874                         StatusEvent(status=msg, info="error")) 
875                    time.sleep(0.5)
876                    continue
877   
878       
879     
880   
881    def on_plot(self, event):
882        """
883        Evaluate the contains of textcrtl and plot result
884        """ 
885        pos = self.notebook.GetSelection()
886        grid = self.notebook.GetPage(pos)
887        column_names = {}
888        if grid is not None:
889            column_names = self.notebook.get_column_labels()
890        #evaluate x
891        sentence = self.x_axis_label.GetValue()
892        try:
893            if sentence.strip() == "":
894                msg = "Select column values for x axis"
895                raise ValueError, msg
896        except:
897             wx.PostEvent(self.parent.parent, 
898                             StatusEvent(status=msg, info="error")) 
899             return
900
901        dict = parse_string(sentence, column_names.keys())
902        for tok, (col_name, list) in dict.iteritems():
903            col = column_names[col_name]
904            xaxis = self.get_plot_axis(col, list)
905            sentence = sentence.replace(tok, 
906                                        "numpy.array(%s)" % str(xaxis))
907        for key, value in FUNC_DICT.iteritems():
908            sentence = sentence.replace(key.lower(), value)
909        x = eval(sentence)
910        #evaluate y
911        sentence = self.y_axis_label.GetValue()
912        if sentence.strip() == "":
913            msg = "select value for y axis"
914            raise ValueError, msg
915        dict = parse_string(sentence, column_names.keys())
916        for tok, (col_name, list) in dict.iteritems():
917            col = column_names[col_name]
918            yaxis = self.get_plot_axis(col, list)
919            sentence = sentence.replace(tok, 
920                                        "numpy.array(%s)" % str(yaxis))
921        for key, value in FUNC_DICT.iteritems():
922            sentence = sentence.replace(key, value)
923        y = eval(sentence)
924        if len(x) != len(y) and (len(x) == 0 or len(y) == 0):
925            msg = "Need same length for X and Y axis and both greater than 0"
926            msg += " to plot.\n"
927            msg += "Got X length = %s, Y length = %s" % (str(len(x)),
928                                                          str(len(y)))
929            wx.PostEvent(self.parent.parent, 
930                             StatusEvent(status=msg, info="error")) 
931            return
932           
933        #plotting
934        new_plot = Data1D(x=x, y=y)
935        new_plot.id =  wx.NewId()
936        new_plot.group_id = wx.NewId()
937        title = "%s vs %s" % (self.y_axis_title.GetValue(), 
938                              self.x_axis_title.GetValue())
939        new_plot.xaxis(self.x_axis_title.GetValue(), 
940                       self.x_axis_unit.GetValue())
941        new_plot.yaxis(self.y_axis_title.GetValue(), 
942                       self.y_axis_unit.GetValue())
943        try:
944            title = self.notebook.GetPageText(pos)
945            new_plot.name = title
946            new_plot.xtransform = "x"
947            new_plot.ytransform  = "y" 
948            wx.PostEvent(self.parent.parent, 
949                        NewPlotEvent(plot=new_plot, 
950                        group_id=str(new_plot.group_id), title =title)) 
951            msg = "Plotting completed!"
952            wx.PostEvent( self.parent.parent, 
953                                      StatusEvent(status=msg))   
954        except:
955             wx.PostEvent(self.parent.parent, 
956                             StatusEvent(status=msg, info="error")) 
957
958    def layout_grid(self):
959        """
960        Draw the area related to the grid
961        """
962        self.notebook = Notebook(parent=self)
963        self.notebook.set_data(self._data_inputs, self._data_outputs)
964        self.grid_sizer.Add(self.notebook, 1, wx.EXPAND, 0)
965       
966    def layout_plotting_area(self):
967        """
968        Draw area containing options to plot
969        """
970       
971        self.x_axis_title = wx.TextCtrl(self, -1)
972        self.y_axis_title = wx.TextCtrl(self, -1)
973        self.x_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
974        self.y_axis_label = wx.TextCtrl(self, -1, size=(200, -1))
975        self.x_axis_add = wx.Button(self, -1, "Add")
976        self.x_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis, 
977                            id=self.x_axis_add.GetId())
978        self.y_axis_add = wx.Button(self, -1, "Add")
979        self.y_axis_add.Bind(event=wx.EVT_BUTTON, handler=self.on_edit_axis, 
980                            id=self.y_axis_add.GetId())
981        self.x_axis_unit = wx.TextCtrl(self, -1)
982        self.y_axis_unit = wx.TextCtrl(self, -1)
983        self.view_button = wx.Button(self, -1, "View Results")
984        view_tip = "Highlight the data set or the Chi2 column first."
985        self.view_button.SetToolTipString(view_tip)
986        wx.EVT_BUTTON(self, self.view_button.GetId(), self.on_view)
987        self.plot_button = wx.Button(self, -1, "Plot")
988        plot_tip = "Highlight a column for each axis and \n"
989        plot_tip += "click the Add buttons first."
990        self.plot_button.SetToolTipString(plot_tip)
991        self.button_sizer.AddMany( [ (500, 30),
992                                (self.view_button, 0, wx.RIGHT|wx.BOTTOM, 10),
993                                (self.plot_button, 0, wx.RIGHT|wx.BOTTOM, 10)])
994       
995        wx.EVT_BUTTON(self, self.plot_button.GetId(), self.on_plot)
996        self.plotting_sizer.AddMany([
997                    (wx.StaticText(self, -1, 
998                                   "X-axis Label\nSelection Range"), 1,
999                      wx.TOP|wx.BOTTOM|wx.LEFT, 10),
1000                    (self.x_axis_label, 1, wx.TOP|wx.BOTTOM, 10),
1001                    (self.x_axis_add, 1, wx.TOP|wx.BOTTOM|wx.RIGHT, 10),
1002                    (wx.StaticText(self, -1, "X-axis Label"), 1, 
1003                     wx.TOP|wx.BOTTOM|wx.LEFT, 10),
1004                    (self.x_axis_title, 1, wx.TOP|wx.BOTTOM, 10),
1005                    (wx.StaticText(self, -1 , "X-axis Unit"), 1, 
1006                     wx.TOP|wx.BOTTOM, 10),
1007                    (self.x_axis_unit, 1, wx.TOP|wx.BOTTOM, 10),
1008                    (wx.StaticText(self, -1, 
1009                                   "Y-axis Label\nSelection Range"), 1, 
1010                     wx.BOTTOM|wx.LEFT, 10),
1011                    (self.y_axis_label, wx.BOTTOM, 10),
1012                    (self.y_axis_add, 1, wx.BOTTOM|wx.RIGHT, 10),
1013                    (wx.StaticText(self, -1, "Y-axis Label"), 1, 
1014                     wx.BOTTOM|wx.LEFT, 10),
1015                    (self.y_axis_title,  wx.BOTTOM, 10),
1016                    (wx.StaticText(self, -1 , "Y-axis Unit"), 1, wx.BOTTOM, 10),
1017                    (self.y_axis_unit, 1, wx.BOTTOM, 10),
1018                      (-1, -1),
1019                      (-1, -1),
1020                      (-1, -1),
1021                      (-1, -1),
1022                      (-1, -1),
1023                      (-1, -1),
1024                      (-1, 1)])
1025   
1026    def on_edit_axis(self, event):
1027        """
1028        Get the selected column on  the visible grid and set values for axis
1029        """
1030        try:
1031            cell_list = self.notebook.on_edit_axis()
1032        except:
1033            msg = str(sys.exc_value)
1034            wx.PostEvent(self.parent.parent, 
1035                             StatusEvent(status=msg, info="error")) 
1036            return 
1037        label, title = self.create_axis_label(cell_list)
1038        tcrtl = event.GetEventObject()
1039        if tcrtl == self.x_axis_add:
1040            self.edit_axis_helper(self.x_axis_label, self.x_axis_title,
1041                                   label, title)
1042        elif tcrtl == self.y_axis_add:
1043            self.edit_axis_helper(self.y_axis_label, self.y_axis_title,
1044                                   label, title)
1045           
1046    def create_axis_label(self, cell_list):
1047        """
1048        Receive a list of cells and  create a string presenting the selected
1049        cells.
1050        :param cell_list: list of tuple
1051       
1052        """
1053        if self.notebook is not None:
1054            return self.notebook.create_axis_label(cell_list)
1055   
1056    def edit_axis_helper(self, tcrtl_label, tcrtl_title, label, title):
1057        """
1058        get controls to modify
1059        """
1060        tcrtl_label.SetValue(str(label))
1061        tcrtl_title.SetValue(str(title))
1062       
1063    def add_column(self):
1064        """
1065        """
1066        if self.notebook is not None:
1067            self.notebook.add_column()
1068       
1069    def on_remove_column(self):
1070        """
1071        """
1072        if self.notebook is not None:
1073            self.notebook.on_remove_column()
1074       
1075       
1076class GridFrame(wx.Frame):
1077    def __init__(self, parent=None, data_inputs=None, data_outputs=None, id=-1, 
1078                 title="Batch Window", size=(800, 500)):
1079        wx.Frame.__init__(self, parent=parent, id=id, title=title, size=size)
1080        self.parent = parent
1081        self.panel = GridPanel(self, data_inputs, data_outputs)
1082        menubar = wx.MenuBar()
1083        self.SetMenuBar(menubar)
1084       
1085        self.curr_col = None
1086        self.curr_grid = None
1087        self.curr_col_name = ""
1088        file = wx.Menu()
1089        menubar.Append(file, "&File")
1090       
1091        hint = "Open file containing batch results"
1092        open_menu = file.Append(wx.NewId(), 'Open ', hint)
1093        wx.EVT_MENU(self, open_menu.GetId(), self.on_open)
1094       
1095        hint = "Open the the current grid into excel"
1096        open_excel_menu = file.Append(wx.NewId(), 'Open with Excel', hint)
1097        wx.EVT_MENU(self, open_excel_menu.GetId(), self.open_with_excel)
1098        file.AppendSeparator()
1099        save_menu = file.Append(wx.NewId(), 'Save As', 'Save into File')
1100        wx.EVT_MENU(self, save_menu.GetId(), self.on_save_page)
1101       
1102        self.edit = wx.Menu()
1103        hint = "Insert column before the selected column"
1104        self.insert_before_menu = wx.Menu()
1105        self.insert_sub_menu = self.edit.AppendSubMenu(self.insert_before_menu, 
1106                                                      'Insert Before', hint)
1107 
1108        hint = "Remove the selected column"
1109        self.remove_menu = self.edit.Append(-1, 'Remove Column', hint)
1110        wx.EVT_MENU(self, self.remove_menu.GetId(), self.on_remove_column)
1111       
1112        self.Bind(wx.EVT_MENU_OPEN, self.on_menu_open)
1113        menubar.Append(self.edit, "&Edit")
1114        self.Bind(wx.EVT_CLOSE, self.on_close)
1115    def GetLabelText(self, id):
1116        """
1117        """
1118        for item in self.insert_before_menu.GetMenuItems():
1119            m_id = item.GetId() 
1120            if m_id == id:
1121                return item.GetLabel() 
1122   
1123    def on_remove_column(self, event):
1124        """
1125        """
1126        pos = self.panel.notebook.GetSelection()
1127        grid = self.panel.notebook.GetPage(pos)
1128        grid.on_remove_column(event=None)
1129       
1130    def on_menu_open(self, event):
1131        """
1132       
1133        """
1134        if self.edit == event.GetMenu():
1135            #get the selected column
1136            pos = self.panel.notebook.GetSelection()
1137            grid = self.panel.notebook.GetPage(pos)
1138            col_list = grid.GetSelectedCols()
1139            if len(col_list) > 0:
1140                self.remove_menu.Enable(True)
1141            else:
1142                self.remove_menu.Enable(False)
1143            if len(col_list)== 0 or len(col_list) > 1:
1144                self.insert_sub_menu.Enable(False)
1145               
1146                label = "Insert Column Before"
1147                self.insert_sub_menu.SetText(label)
1148            else:
1149                self.insert_sub_menu.Enable(True)
1150               
1151                col = col_list[0]
1152                #GetColLabelValue(self, col)
1153                col_name = grid.GetCellValue(row=0, col=col)
1154                label = "Insert Column Before " + str(col_name)
1155                self.insert_sub_menu.SetText(label)
1156                for item in self.insert_before_menu.GetMenuItems():
1157                    self.insert_before_menu.DeleteItem(item)
1158                grid.insert_col_menu(menu=self.insert_before_menu, 
1159                                     label=col_name, window=self)
1160        event.Skip()
1161       
1162 
1163       
1164    def on_save_page(self, event):
1165        """
1166        """
1167        if self.parent is not None:
1168            pos = self.panel.notebook.GetSelection()
1169            grid = self.panel.notebook.GetPage(pos)
1170            if grid.file_name is None or grid.file_name.strip() == "" or \
1171                grid.data is None or len(grid.data) == 0:
1172                name = self.panel.notebook.GetPageText(pos)
1173                msg = " %s has not data to save" % str(name)
1174                wx.PostEvent(self.parent, 
1175                             StatusEvent(status=msg, info="error")) 
1176           
1177                return
1178            reader, ext = os.path.splitext(grid.file_name)
1179            path = None
1180            if self.parent is not None: 
1181                location = os.path.dirname(grid.file_name)
1182                dlg = wx.FileDialog(self, "Save Project file",
1183                            location, grid.file_name, ext, wx.SAVE)
1184                path = None
1185                if dlg.ShowModal() == wx.ID_OK:
1186                    path = dlg.GetPath()
1187                dlg.Destroy()
1188                if path != None:
1189                    if self.parent is not None:
1190                        data = grid.get_grid_view()
1191                        self.parent.write_batch_tofile(data=data, 
1192                                               file_name=path,
1193                                               details=grid.details)
1194   
1195    def on_open(self, event):
1196        """
1197        Open file containg batch result
1198        """
1199        if self.parent is not None:
1200            self.parent.on_read_batch_tofile(event)
1201           
1202    def open_with_excel(self, event):
1203        """
1204        open excel and display batch result in Excel
1205        """
1206        if self.parent is not None:
1207            pos = self.panel.notebook.GetSelection()
1208            grid = self.panel.notebook.GetPage(pos)
1209            data = grid.get_grid_view()
1210            if grid.file_name is None or grid.file_name.strip() == "" or \
1211                grid.data is None or len(grid.data) == 0:
1212                name = self.panel.notebook.GetPageText(pos)
1213                msg = " %s has not data to open on excel" % str(name)
1214                wx.PostEvent(self.parent, 
1215                             StatusEvent(status=msg, info="error")) 
1216           
1217                return
1218            self.parent.open_with_externalapp(data=data,
1219                                               file_name=grid.file_name, 
1220                                               details=grid.details)
1221           
1222    def on_close(self, event):
1223        """
1224        """
1225        self.Hide()
1226       
1227   
1228    def on_append_column(self, event):
1229        """
1230        Append a new column to the grid
1231        """
1232        self.panel.add_column()
1233       
1234    def set_data(self, data_inputs, data_outputs, details="", file_name=None):
1235        """
1236        """
1237       
1238        self.panel.notebook.set_data(data_inputs=data_inputs, 
1239                            file_name=file_name,
1240                            details=details,
1241                            data_outputs=data_outputs)
1242     
1243     
1244class BatchOutputFrame(wx.Frame):
1245    """
1246    Allow to select where the result of batch will be displayed or stored
1247    """
1248    def __init__(self, parent, data_inputs, data_outputs, file_name="",
1249                 details="", *args, **kwds):
1250        """
1251        :param parent: Window instantiating this dialog
1252        :param result: result to display in a grid or export to an external
1253                application.
1254        """
1255        #kwds['style'] = wx.CAPTION|wx.SYSTEM_MENU
1256        wx.Frame.__init__(self, parent, *args, **kwds)
1257        self.parent = parent
1258        self.panel = wx.Panel(self)
1259        self.file_name = file_name
1260        self.details = details
1261        self.data_inputs = data_inputs
1262        self.data_outputs = data_outputs
1263        self.data = {}
1264        for item in (self.data_outputs, self.data_inputs):
1265            self.data.update(item)
1266        self.flag = 1
1267        self.SetSize((300, 200))
1268        self.local_app_selected = None
1269        self.external_app_selected = None
1270        self.save_to_file = None
1271        self._do_layout()
1272   
1273    def _do_layout(self):
1274        """
1275        Draw the content of the current dialog window
1276        """
1277        vbox = wx.BoxSizer(wx.VERTICAL)
1278        box_description = wx.StaticBox(self.panel, -1, str("Batch Outputs"))
1279        hint_sizer = wx.StaticBoxSizer(box_description, wx.VERTICAL)
1280        selection_sizer = wx.GridBagSizer(5, 5)
1281        button_sizer = wx.BoxSizer(wx.HORIZONTAL)
1282        text = "Open with %s" % self.parent.application_name
1283        self.local_app_selected = wx.RadioButton(self.panel, -1, text,
1284                                                style=wx.RB_GROUP)
1285        self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1286                    id=self.local_app_selected.GetId())
1287        text = "Open with Excel"
1288        self.external_app_selected  = wx.RadioButton(self.panel, -1, text)
1289        self.Bind(wx.EVT_RADIOBUTTON, self.onselect,
1290                    id=self.external_app_selected.GetId())
1291        text = "Save to File"
1292        self.save_to_file = wx.CheckBox(self.panel, -1, text)
1293        self.Bind(wx.EVT_CHECKBOX, self.onselect,
1294                    id=self.save_to_file.GetId())
1295        self.local_app_selected.SetValue(True)
1296        self.external_app_selected.SetValue(False)
1297        self.save_to_file.SetValue(False)
1298        button_close = wx.Button(self.panel, -1, "Close")
1299        button_close.Bind(wx.EVT_BUTTON, id=button_close.GetId(),
1300                           handler=self.on_close)
1301        button_apply = wx.Button(self.panel, -1, "Apply")
1302        button_apply.Bind(wx.EVT_BUTTON, id=button_apply.GetId(),
1303                        handler=self.on_apply)
1304        button_apply.SetFocus()
1305        hint = ""
1306        hint_sizer.Add(wx.StaticText(self.panel, -1, hint))
1307        hint_sizer.Add(selection_sizer)
1308        #draw area containing radio buttons
1309        ix = 0
1310        iy = 0
1311        selection_sizer.Add(self.local_app_selected, (iy, ix),
1312                           (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1313        iy += 1
1314        selection_sizer.Add(self.external_app_selected, (iy, ix),
1315                           (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1316        iy += 1
1317        selection_sizer.Add(self.save_to_file, (iy, ix),
1318                           (1, 1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1319        #contruction the sizer contaning button
1320        button_sizer.Add((20, 20), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
1321
1322        button_sizer.Add(button_close, 0,
1323                        wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)
1324        button_sizer.Add(button_apply, 0,
1325                                wx.LEFT|wx.RIGHT|wx.ADJUST_MINSIZE, 10)
1326        vbox.Add(hint_sizer,  0, wx.EXPAND|wx.ALL, 10)
1327        vbox.Add(wx.StaticLine(self.panel, -1),  0, wx.EXPAND, 0)
1328        vbox.Add(button_sizer, 0 , wx.TOP|wx.BOTTOM, 10)
1329        self.SetSizer(vbox)
1330       
1331    def on_apply(self, event):
1332        """
1333        Get the user selection and display output to the selected application
1334        """
1335        if self.flag == 1:
1336            self.parent.open_with_localapp(data_inputs=self.data_inputs,
1337                                            data_outputs=self.data_outputs)
1338        elif self.flag == 2:
1339            self.parent.open_with_externalapp(data=self.data, 
1340                                           file_name=self.file_name,
1341                                           details=self.details)
1342    def on_close(self, event):
1343        """
1344        close the Window
1345        """
1346        self.Close()
1347       
1348    def onselect(self, event=None):
1349        """
1350        Receive event and display data into third party application
1351        or save data to file.
1352       
1353        """
1354        if self.save_to_file.GetValue():
1355            reader, ext = os.path.splitext(self.file_name)
1356            path = None
1357            location = os.getcwd()
1358            if self.parent is not None: 
1359                location = os.path.dirname(self.file_name)
1360                dlg = wx.FileDialog(self, "Save Project file",
1361                            location, self.file_name, ext, wx.SAVE)
1362                path = None
1363                if dlg.ShowModal() == wx.ID_OK:
1364                    path = dlg.GetPath()
1365                dlg.Destroy()
1366                if path != None:
1367                    if self.parent is not None and  self.data is not None:
1368                        self.parent.write_batch_tofile(data=self.data, 
1369                                               file_name=path,
1370                                               details=self.details)
1371        if self.local_app_selected.GetValue():
1372            self.flag = 1
1373        else:
1374            self.flag = 2
1375        return self.flag
1376   
1377 
1378       
1379if __name__ == "__main__":
1380    app = wx.App()
1381   
1382    try:
1383        data = {}
1384        j = 0
1385        for i in range(4):
1386            j += 1
1387            data["index"+str(i)] = [i/j, i*j, i, i+j]
1388       
1389        data_input =  copy.deepcopy(data)   
1390        data_input["index5"] = [10,20,40, 50]
1391        frame = GridFrame(data_outputs=data, data_inputs=data_input)
1392        frame.Show(True)
1393    except:
1394        print sys.exc_value
1395       
1396    app.MainLoop()
Note: See TracBrowser for help on using the repository browser.