source: sasview/sansview/perspectives/fitting/fitpanel.py @ 9466f2d6

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

make sure plugin model are recompile online when the plugin dir has changed
  • Property mode set to 100644
File size: 14.2 KB
Line 
1
2import numpy
3import string 
4import wx
5import wx.lib.flatnotebook as fnb
6
7from sans.guiframe.panel_base import PanelBase
8from sans.guiframe.events import PanelOnFocusEvent
9from sans.guiframe.events import StatusEvent
10
11import basepage
12import models
13_BOX_WIDTH = 80
14
15
16class FitPanel(fnb.FlatNotebook, PanelBase):   
17
18    """
19    FitPanel class contains fields allowing to fit  models and  data
20   
21    :note: For Fit to be performed the user should check at least one parameter
22        on fit Panel window.
23       
24    """
25    ## Internal name for the AUI manager
26    window_name = "Fit panel"
27    ## Title to appear on top of the window
28    window_caption = "Fit Panel "
29    CENTER_PANE = True
30   
31    def __init__(self, parent, manager=None, *args, **kwargs):
32        """
33        """
34        fnb.FlatNotebook.__init__(self, parent, -1,
35                    style= wx.aui.AUI_NB_WINDOWLIST_BUTTON|
36                    wx.aui.AUI_NB_DEFAULT_STYLE|
37                    wx.CLIP_CHILDREN)
38        PanelBase.__init__(self, parent)
39        self.SetWindowStyleFlag(style=fnb.FNB_FANCY_TABS)
40        self._manager = manager
41        self.parent = parent
42        self.event_owner = None
43        #dictionary of miodel {model class name, model class}
44        self.menu_mng = models.ModelManager()
45        self.model_list_box = self.menu_mng.get_model_list()
46        #pageClosedEvent = fnb.EVT_FLATNOTEBOOK_PAGE_CLOSING
47        self.Bind(fnb.EVT_FLATNOTEBOOK_PAGE_CLOSING , self.on_close_page)
48         ## save the title of the last page tab added
49        self.fit_page_name = {}
50        ## list of existing fit page
51        self.opened_pages = {}
52        #page of simultaneous fit
53        self.sim_page = None
54        self.fit_engine_type = "scipy"
55        ## get the state of a page
56        self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate)
57        self.Bind(basepage.EVT_PREVIOUS_STATE, self._onUndo)
58        self.Bind(basepage.EVT_NEXT_STATE, self._onRedo)
59        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, self.on_page_changing)
60     
61        #add default pages
62        self.add_default_pages()
63   
64    def _on_engine_change(self, name='scipy'):
65        """
66        """
67        for panel in self.opened_pages.values():
68            self.set_engine_helper(panel=panel, name=name)
69           
70    def set_engine_helper(self, panel, name='scipy'):
71        """
72        """
73        self.fit_engine_type = name
74        if panel != self.sim_page:
75            panel._on_engine_change(name=self.fit_engine_type)
76               
77    def update_model_list(self):
78        """
79        """
80        temp = self.menu_mng.update()
81        if len(temp):
82            self.model_list_box = temp
83        return temp
84       
85       
86    def get_page_by_id(self, uid): 
87        """
88        """
89        if uid not in self.opened_pages:
90            msg = "Fitpanel cannot find ID: %s in self.opened_pages" % str(uid)
91            raise ValueError, msg
92        else:
93            return self.opened_pages[uid]
94       
95    def on_page_changing(self, event):
96        """
97        """
98        pos = self.GetSelection()
99        if pos != -1:
100            selected_page = self.GetPage(pos)
101            wx.PostEvent(self.parent, PanelOnFocusEvent(panel=selected_page))
102           
103    def on_set_focus(self, event):
104        """
105        """
106        pos = self.GetSelection()
107        if pos != -1:
108            selected_page = self.GetPage(pos)
109            wx.PostEvent(self.parent, PanelOnFocusEvent(panel=selected_page))
110       
111    def get_data(self):
112        """
113        get the data in the current page
114        """
115        pos = self.GetSelection()
116        if pos != -1:
117            selected_page = self.GetPage(pos)
118            return selected_page.get_data()
119   
120    def set_model_state(state):
121        """
122        receive a state to reset the model in the current page
123        """
124        pos = self.GetSelection()
125        if pos != -1:
126            selected_page = self.GetPage(pos)
127            selected_page.set_model_state(state)
128           
129    def get_state(self):
130        """
131         return the state of the current selected page
132        """
133        pos = self.GetSelection()
134        if pos != -1:
135            selected_page = self.GetPage(pos)
136            return selected_page.get_state()
137   
138    def add_default_pages(self):
139        """
140        Add default pages such as a hint page and an empty fit page
141        """
142        #add default page
143        from hint_fitpage import HintFitPage
144        self.hint_page = HintFitPage(self) 
145        self.AddPage(self.hint_page,"Hint")
146        self.hint_page.set_manager(self._manager)
147 
148    def close_all(self):
149        """
150        remove all pages, used when a svs file is opened
151        """
152       
153        #get number of pages
154        nop = self.GetPageCount()
155        #use while-loop, for-loop will not do the job well.
156        while (nop>0):
157            #delete the first page until no page exists
158            page = self.GetPage(0)
159            if self._manager.parent.panel_on_focus == page:
160                self._manager.parent.panel_on_focus = None
161            self._close_helper(selected_page=page)
162            self.DeletePage(0)
163            nop = nop - 1
164           
165        ## save the title of the last page tab added
166        self.fit_page_name = {}
167        ## list of existing fit page
168        self.opened_pages = {} 
169         
170    def set_state(self, state):
171        """
172        Restore state of the panel
173        """
174        page_is_opened = False
175        if state is not None:
176            for uid, panel in self.opened_pages.iteritems():
177                #Don't return any panel is the exact same page is created
178                if uid == panel.uid:
179                    # the page is still opened
180                    panel.reset_page(state=state)
181                    panel.save_current_state() 
182                    page_is_opened = True
183            if not page_is_opened:
184                panel = self._manager.add_fit_page(data=state.data)
185                # add data associated to the page created
186                if panel is not None: 
187                    self._manager.store_page(page=panel.uid, data=state.data)
188                    panel.reset_page(state=state)
189                    panel.save_current_state()
190                   
191    def clear_panel(self):
192        """
193        Clear and close all panels, used by guimanager
194        """
195       
196        #close all panels only when svs file opened
197        self.close_all()
198        self._manager.mypanels = []
199       
200                       
201    def on_close_page(self, event=None):
202        """
203        close page and remove all references to the closed page
204        """
205        nbr_page = self.GetPageCount()
206        if nbr_page == 1:
207           
208            event.Veto()
209            return 
210        selected_page = self.GetPage(self.GetSelection())
211        self._close_helper(selected_page=selected_page)
212       
213    def close_page_with_data(self, deleted_data):
214        """
215        close a fit page when its data is completely remove from the graph
216        """
217        if deleted_data is None:
218            return
219        for index in range(self.GetPageCount()):
220            selected_page = self.GetPage(index) 
221            if hasattr(selected_page,"get_data"):
222                data = selected_page.get_data()
223               
224                if data is None:
225                    #the fitpanel exists and only the initial fit page is open
226                    #with no selected data
227                    return
228                if data.name == deleted_data.name:
229                    self._close_helper(selected_page)
230                    self.DeletePage(index)
231                    break
232       
233    def set_manager(self, manager):
234        """
235        set panel manager
236       
237        :param manager: instance of plugin fitting
238       
239        """
240        self._manager = manager
241        for pos in range(self.GetPageCount()):
242            page = self.GetPage(pos)
243            if page is not None:
244                page.set_manager(self._manager)
245
246    def set_model_list(self, dict):
247         """
248         copy a dictionary of model into its own dictionary
249         
250         :param dict: dictionnary made of model name as key and model class
251             as value
252         """
253         self.model_list_box = dict
254       
255    def get_current_page(self):
256        """
257        :return: the current page selected
258       
259        """
260        return self.GetPage(self.GetSelection())
261   
262    def add_sim_page(self):
263        """
264        Add the simultaneous fit page
265        """
266        from simfitpage import SimultaneousFitPage
267        page_finder= self._manager.get_page_finder()
268        self.sim_page = SimultaneousFitPage(self,page_finder=page_finder, id=-1)
269        self.sim_page.uid = wx.NewId()
270        self.AddPage(self.sim_page,"Simultaneous Fit", True)
271        self.sim_page.set_manager(self._manager)
272        return self.sim_page
273       
274 
275    def add_empty_page(self):
276        """
277        add an empty page
278        """
279        from fitpage import FitPage
280        panel = FitPage(parent=self)
281        panel.uid = wx.NewId()
282        panel.populate_box(dict=self.model_list_box)
283        panel.set_manager(self._manager)
284        caption = str(panel.window_name) + " " + str(self._manager.index_model)
285        self.AddPage(panel, caption, select=True)
286        self.opened_pages[panel.uid] = panel
287        self.set_engine_helper(panel=panel)
288        return panel
289   
290    def delete_data(self, data):
291        """
292        Delete the given data
293        """
294        if data is None:
295            return None
296    def set_data(self, data):
297        """
298        Add a fitting page on the notebook contained by fitpanel
299       
300        :param data: data to fit
301       
302        :return panel : page just added for further used. is used by fitting module
303       
304        """
305        if data is None:
306            return None
307        for page in self.opened_pages.values():
308            #check if the selected data existing in the fitpanel
309            pos = self.GetPageIndex(page)
310            if page.get_data() is None:
311                enable2D = page.get_view_mode()
312                if (data.__class__.__name__ == "Data2D" and enable2D)\
313                or (data.__class__.__name__ == "Data1D" and not enable2D):
314                    page.set_data(data)
315                    self.SetPageText(pos, str(data.name))
316                    self.SetSelection(pos)
317                    return page
318               
319            elif page.get_data().id == data.id:
320                msg = "Data already existing in the fitting panel"
321                wx.PostEvent(self._manager.parent, 
322                             StatusEvent(status=msg, info='warning')) 
323                self.SetSelection(pos)
324                return page
325       
326        page = self.add_empty_page()
327        pos = self.GetPageIndex(page)
328        page.set_data(data)
329        self.SetPageText(pos, str(data.name))
330        self.opened_pages[page.uid] = page
331       
332        return page
333       
334    def _onGetstate(self, event):
335        """
336        copy the state of a page
337        """
338        page = event.page
339        if page.uid in self.fit_page_name:
340           self.fit_page_name[page.uid].appendItem(page.createMemento()) 
341           
342    def _onUndo(self, event ):
343        """
344        return the previous state of a given page is available
345        """
346        page = event.page
347        if page.uid in self.fit_page_name:
348            if self.fit_page_name[page.uid].getCurrentPosition()==0:
349                state = None
350            else:
351                state = self.fit_page_name[page.uid].getPreviousItem()
352                page._redo.Enable(True)
353            page.reset_page(state)
354       
355    def _onRedo(self, event): 
356        """
357        return the next state available
358        """       
359        page = event.page
360        if page.uid in self.fit_page_name:
361            length= len(self.fit_page_name[page.uid])
362            if self.fit_page_name[page.uid].getCurrentPosition()== length -1:
363                state = None
364                page._redo.Enable(False)
365                page._redo.Enable(True)
366            else:
367                state =self.fit_page_name[page.uid].getNextItem()
368            page.reset_page(state) 
369                 
370    def _close_helper(self, selected_page):
371        """
372        Delete the given page from the notebook
373        """
374        #remove hint page
375        if selected_page == self.hint_page:
376            return
377        ## removing sim_page
378        if selected_page == self.sim_page :
379            self._manager.sim_page=None 
380            return
381       
382        ## closing other pages
383        state = selected_page.createMemento()
384        page_name = selected_page.window_name
385        page_finder = self._manager.get_page_finder() 
386        fitproblem = None
387        ## removing fit page
388        data = selected_page.get_data()
389        #Don' t remove plot for 2D
390        flag = True
391        if data.__class__.__name__ == 'Data2D':
392            flag = False
393        if selected_page in page_finder:
394            #Delete the name of the page into the list of open page
395            for uid, list in self.opened_pages.iteritems():
396                #Don't return any panel is the exact same page is created
397               
398                if flag and selected_page.uid == uid:
399                    self._manager.remove_plot(uid, theory=False)
400                    break 
401            del page_finder[selected_page]
402        ##remove the check box link to the model name of this page (selected_page)
403        try:
404            self.sim_page.draw_page()
405        except:
406            ## that page is already deleted no need to remove check box on
407            ##non existing page
408            pass
409               
410        #Delete the name of the page into the list of open page
411        for uid, list in self.opened_pages.iteritems():
412            #Don't return any panel is the exact same page is created
413           
414            if selected_page.uid == uid:
415                del self.opened_pages[selected_page.uid]
416                break 
417     
418 
Note: See TracBrowser for help on using the repository browser.