source: sasview/sansview/perspectives/fitting/fitpanel.py @ c4dd2fe

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 c4dd2fe was c4dd2fe, checked in by Gervaise Alina <gervyh@…>, 14 years ago

comment unused code
  • Property mode set to 100644
File size: 18.2 KB
Line 
1
2import numpy
3import string 
4import wx
5import wx.aui
6from sans.guicomm.events import NewPlotEvent, StatusEvent 
7import basepage
8
9_BOX_WIDTH = 80
10
11
12class StateIterator(object):
13    """
14    Contains all saved state of a given page.
15    Provide position of the current state of a page, the first save state
16    and the last state for a given page.
17    Allow easy undo or redo for a given page 
18    """
19    def __init__(self):
20        """
21        """
22        self._current=0
23       
24    def __iter__(self):
25        """
26        """
27        return self
28   
29    def first(self):
30        """
31        """
32        self._current =0
33        return self._current
34   
35    def next(self, max ):
36        """
37        """
38        if self._current < max:
39            self._current += 1
40        return self._current
41   
42    def previous(self):
43        """
44        """
45        if self._current > 0:
46            self._current = self._current -1
47        return self._current
48   
49    def currentPosition(self):
50        """
51        """
52        return self._current
53   
54    def setPosition(self, value):
55        """
56        """
57        if value >=0:
58            self._current = int(value)
59       
60   
61class ListOfState(list):   
62    """
63    """ 
64    def __init__(self, *args, **kw):
65        list.__init__(self, *args, **kw)
66        self.iterator = StateIterator()
67       
68    def appendItem(self, x):
69        """
70        """
71        self.append(x)
72        self.iterator.setPosition(value= len(self)-1)
73       
74    def removeItem(self, x):
75        """
76        """
77        self.iterator.previous()
78        self.remove(x)
79       
80    def getPreviousItem(self):
81        """
82        """
83        position = self.iterator.previous()
84       
85        if position < 0:
86            return None
87        else:
88            return self[position]
89       
90    def getNextItem(self):
91        """
92        """
93        position = self.iterator.next(max= len(self)-1)
94        if position >= len(self):
95            return None
96        else:
97            return self[position]
98       
99    def getCurrentItem(self):
100        """
101        """
102        postion = self.iterator.currentPosition()
103        if postion >= 0 and position < len(self):
104            return self[postion]
105        else:
106            return None
107       
108    def getCurrentPosition(self):
109        """
110        """
111        return self.iterator.currentPosition()
112         
113
114class PageInfo(object):
115    """
116    this class contains the minimum numbers of data members
117    a fitpage or model page need to be initialized.
118    """
119    data = None
120    model =  None
121    manager = None
122    event_owner= None
123    model_list_box = None
124    name = None
125    ## Internal name for the AUI manager
126    window_name = "Page"
127    ## Title to appear on top of the window
128    window_caption = "Page"
129    #type of page can be real data , theory 1D or therory2D
130    type = "Data"
131    def __init__(self, model=None, data=None, manager=None,
132                  event_owner=None, model_list_box=None, name=None):
133        """
134        Initialize data members
135        """
136        self.data = data
137        self.model= model
138        self.manager= manager
139        self.event_owner= event_owner
140        self.model_list_box = model_list_box
141        self.name=None
142        self.window_name = "Page"
143        self.window_caption = "Page"
144        self.type = "Data"
145       
146class FitPanel(wx.aui.AuiNotebook):   
147
148    """
149    FitPanel class contains fields allowing to fit  models and  data
150   
151    :note: For Fit to be performed the user should check at least one parameter
152        on fit Panel window.
153       
154    """
155    ## Internal name for the AUI manager
156    window_name = "Fit panel"
157    ## Title to appear on top of the window
158    window_caption = "Fit Panel "
159    CENTER_PANE = True
160   
161    def __init__(self, parent, *args, **kwargs):
162        """
163        """
164        wx.aui.AuiNotebook.__init__(self, parent, -1,
165                    style= wx.aui.AUI_NB_WINDOWLIST_BUTTON|
166                    wx.aui.AUI_NB_DEFAULT_STYLE|
167                    wx.CLIP_CHILDREN)
168   
169        self.manager=None
170        self.parent=parent
171        self.event_owner=None
172       
173        pageClosedEvent = wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE
174        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.on_close_page)
175       
176        #dictionary of miodel {model class name, model class}
177        self.model_list_box = {}
178        ## save the title of the last page tab added
179        self.fit_page_name = {}
180        ## list of existing fit page
181        self.opened_pages = {}
182        #page of simultaneous fit
183        self.sim_page = None
184        ## get the state of a page
185        self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate)
186        self.Bind(basepage.EVT_PREVIOUS_STATE, self._onUndo)
187        self.Bind(basepage.EVT_NEXT_STATE, self._onRedo)
188       
189        #add default page
190        from hint_fitpage import HintFitPage
191        self.hint_page = HintFitPage(self) 
192        self.AddPage(page=self.hint_page, caption=self.hint_page.window_caption)
193        # increment number for model name
194        self.count = 0
195        #updating the panel
196        self.Update()
197        self.Center()
198       
199    def set_data(self, list=[], state=None):
200        """
201        Receive a list of data from data manager
202        """
203        if len(list) ==0:
204            return 
205        #pos = self.GetPageIndex(self.hint_page)
206        #self.SetSelection(pos)
207        self.hint_page.set_data(list=list)
208     
209    def set_state(self, state):
210        """
211        Restore state of the panel
212        """
213        page_is_opened = False
214        if state is not None:
215            page_info = self.get_page_info(data=state.data)
216            if hasattr(state.data,"title"):
217                title = str(state.data.title.lstrip().rstrip())
218                if title == "":
219                    title = str(state.data.name)
220            else:
221                title = str(state.data.name)
222            for name, panel, type in self.opened_pages.values():
223                #Don't return any panel is the exact same page is created
224                if name == page_info.window_name:
225                    # the page is still opened
226                    panel.set_manager(self.manager)
227                    panel.set_owner(self.event_owner)
228                    if panel.model_list_box is None or len(panel.model_list_box) == 0: 
229                        page_info.model_list_box = self.model_list_box.get_list()
230                        panel.populate_box(dict=page_info.model_list_box)
231                        panel.initialize_combox()
232                        panel.set_page_info(page_info=page_info)
233                        self.opened_pages[page_info.window_name] = [page_info.window_name, panel, page_info.type]
234                    if panel is not None: 
235                        self.manager.store_page(page=panel, data=state.data)
236                    panel.reset_page(state=state)
237                    wx.PostEvent(self.parent, NewPlotEvent(plot=state.data, title=title))
238                    page_is_opened = True
239                   
240            if not page_is_opened:
241                panel = self.add_fit_page(data=state.data)
242                # add data associated to the page created
243                if panel is not None: 
244                    self.manager.store_page(page=panel, data=state.data)
245                    panel.reset_page(state=state)
246               
247                   
248    def on_close_page(self, event):
249        """
250        close page and remove all references to the closed page
251        """
252        nbr_page = self.GetPageCount()
253        pos = self.GetSelection()
254        if nbr_page == 1 or self.GetPage(pos)== self.hint_page:
255            event.Veto()
256            return 
257        selected_page = self.GetPage(self.GetSelection())
258        self._close_helper(selected_page=selected_page)
259       
260    def close_page_with_data(self, deleted_data):
261        """
262        close a fit page when its data is completely remove from the graph
263        """
264        if deleted_data is None:
265            return
266        for index in range(self.GetPageCount()):
267            selected_page = self.GetPage(index) 
268            if hasattr(selected_page,"get_data"):
269                data = selected_page.get_data()
270                if data is None:
271                    #the fitpanel exists and only the initial fit page is open
272                    #with no selected data
273                    return
274                if data.name == deleted_data.name:
275                    self._close_helper(selected_page)
276                    self.DeletePage(index)
277                    break
278       
279    def set_manager(self, manager):
280        """
281        set panel manager
282       
283        :param manager: instance of plugin fitting
284       
285        """
286        self.manager = manager
287        self.hint_page.set_manager(self.manager)
288       
289    def set_owner(self,owner):
290        """
291        set and owner for fitpanel
292       
293        :param owner: the class responsible of plotting
294       
295        """
296        self.event_owner = owner
297   
298    def set_model_list(self, dict):
299         """
300         copy a dictionary of model into its own dictionary
301         
302         :param dict: dictionnary made of model name as key and model class
303             as value
304         """
305         self.model_list_box = dict
306       
307    def get_current_page(self):
308        """
309        :return: the current page selected
310       
311        """
312        return self.GetPage(self.GetSelection() )
313   
314    def add_sim_page(self):
315        """
316        Add the simultaneous fit page
317        """
318        from simfitpage import SimultaneousFitPage
319        page_finder= self.manager.get_page_finder()
320        self.sim_page = SimultaneousFitPage(self,page_finder=page_finder, id=-1)
321       
322        self.AddPage(self.sim_page,caption="Simultaneous Fit",select=True)
323        self.sim_page.set_manager(self.manager)
324        return self.sim_page
325       
326    def get_page_info(self, data=None):
327        """
328        fill information required to add a page in the fit panel
329        """
330        name = "Fit Page"
331        type = 'empty'
332        print "get_page_info",data.is_data
333        if data is not None and hasattr(data, "is_data"):
334            if data.is_data:
335                name = data.name
336                type = 'Data'
337            else:
338                if data.__class__.__name__ == "Data2D":
339                    name = 'Model 2D Fit'
340                    type = 'Theory2D'
341                else:
342                    name = 'Model 1D Fit'
343                    type = 'Theory1D'
344        page_info = PageInfo(data=data, name=name)
345        page_info.event_owner = self.event_owner
346        page_info.manager = self.manager
347        page_info.window_name = name
348        page_info.window_caption = name
349        page_info.type = type
350        return page_info
351   
352    def add_empty_page(self):
353        """
354        add an empty page
355        """
356        page_info = self.get_page_info()
357        from fitpage import FitPage
358        panel = FitPage(parent=self, page_info=page_info)
359        self.AddPage(page=panel, caption=page_info.window_name, select=True)
360        self.opened_pages[page_info.window_name] = [page_info.window_name, panel, page_info.type]
361        return panel
362   
363    def add_page(self, page_info):
364        """
365        add a new page
366        """
367        from fitpage import FitPage
368        panel = FitPage(parent=self, page_info=page_info)
369        self.AddPage(page=panel, caption=page_info.window_name, select=True)
370        index = self.GetPageIndex(panel)
371        self.change_page_content(data=page_info.data, index=index)
372        return panel
373   
374    def change_page_content(self, data, index):
375        """
376        replace the contains of an existing page
377        """
378        page_info = self.get_page_info(data=data)
379        self.SetPageText(index, page_info.window_name)
380        panel = self.GetPage(index)
381        panel.set_data(data)
382        if panel.model_list_box is None or len(panel.model_list_box) == 0: 
383            page_info.model_list_box = self.model_list_box.get_list()
384            panel.populate_box(dict=page_info.model_list_box)
385            panel.initialize_combox()
386        panel.set_page_info(page_info=page_info)
387        self.opened_pages[page_info.window_name] = [page_info.window_name, panel, page_info.type]
388        return panel
389   
390    def replace_page(self, index, page_info, type):
391        """
392        replace an existing page
393        """
394        self.DeletePage(index)
395        del self.opened_pages[page_info.window_name]
396        return self.add_page(page_info=page_info)
397       
398    def add_fit_page(self, data, reset=False):
399        """
400        Add a fitting page on the notebook contained by fitpanel
401       
402        :param data: data to fit
403       
404        :return panel : page just added for further used. is used by fitting module
405       
406        """
407        if data is None:
408            return None
409        page_info = self.get_page_info(data=data)
410        type = page_info.type
411        print "add_fit_page",page_info.type
412        npages = len(self.opened_pages.keys())
413        if npages == 0:
414            # create new type of page
415            panel = self.add_page(page_info=page_info)
416            return panel
417        else:
418            if page_info.window_name not in self.opened_pages.keys() and \
419                page_info.type.lower() in ['data']:
420                #create new data type page
421                panel = self.add_page(page_info=page_info)
422                return panel
423            elif page_info.type.lower() not in ['data']:
424                #create new theory page
425                for open_tab_caption, value in self.opened_pages.iteritems():
426                    open_tab = value[1]
427                    open_type = value[2]
428                    if page_info.type == open_type:
429                        #replace theory fit tab
430                        existing_value = self.opened_pages[open_tab_caption]
431                        panel = existing_value[1]
432                        #delete the existing page and replace it
433                        index = self.GetPageIndex(panel)
434                        panel = self.replace_page(index=index, page_info=page_info,
435                                                   type=type)
436                        return panel
437                panel = self.add_page(page_info=page_info)
438                return panel
439            else:
440                _, panel, _ = self.opened_pages[page_info.window_name]
441                index = self.GetPageIndex(panel)
442                self.SetSelection(index)
443                #page already existing
444                return None
445             
446    def  _onGetstate(self, event):
447        """
448        copy the state of a page
449        """
450        page= event.page
451        if page.window_name in self.fit_page_name:
452            self.fit_page_name[page.window_name].appendItem(page.createMemento()) 
453           
454    def _onUndo(self, event ):
455        """
456        return the previous state of a given page is available
457        """
458        page = event.page
459        if page.window_name in self.fit_page_name:
460            if self.fit_page_name[page.window_name].getCurrentPosition()==0:
461                state = None
462            else:
463                state = self.fit_page_name[page.window_name].getPreviousItem()
464                page._redo.Enable(True)
465            page.reset_page(state)
466       
467    def _onRedo(self, event): 
468        """
469        return the next state available
470        """       
471        page = event.page
472        if page.window_name in self.fit_page_name:
473            length= len(self.fit_page_name[page.window_name])
474            if self.fit_page_name[page.window_name].getCurrentPosition()== length -1:
475                state = None
476                page._redo.Enable(False)
477                page._redo.Enable(True)
478            else:
479                state = self.fit_page_name[page.window_name].getNextItem()
480            page.reset_page(state) 
481                 
482    def _close_helper(self, selected_page):
483        """
484        Delete the given page from the notebook
485        """
486        #remove hint page
487        if selected_page == self.hint_page:
488            return
489        ## removing sim_page
490        if selected_page == self.sim_page :
491            self.manager.sim_page=None 
492            return
493       
494        ## closing other pages
495        state = selected_page.createMemento()
496        page_name = selected_page.window_name
497        page_finder = self.manager.get_page_finder() 
498        fitproblem = None
499        ## removing fit page
500        data = selected_page.get_data()
501        #Don' t remove plot for 2D
502        flag = True
503        if data.__class__.__name__ == 'Data2D':
504            flag = False
505        if selected_page in page_finder:
506            #Delete the name of the page into the list of open page
507            for type, list in self.opened_pages.iteritems():
508                #Don't return any panel is the exact same page is created
509                name = str(list[0])
510                if flag and selected_page.window_name == name:
511                    if type.lower() in ['theory1d', 'theory2d']:
512                        self.manager.remove_plot(selected_page, theory=True)
513                    else:
514                        self.manager.remove_plot(selected_page, theory=False)
515                    break 
516            del page_finder[selected_page]
517        ##remove the check box link to the model name of this page (selected_page)
518        try:
519            self.sim_page.draw_page()
520        except:
521            ## that page is already deleted no need to remove check box on
522            ##non existing page
523            pass
524               
525        #Delete the name of the page into the list of open page
526        for type, list in self.opened_pages.iteritems():
527            #Don't return any panel is the exact same page is created
528            name = str(list[0])
529            if selected_page.window_name == name:
530                del self.opened_pages[type]
531                break 
532     
533 
Note: See TracBrowser for help on using the repository browser.