source: sasview/guiframe/gui_manager.py @ 5b396b3

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 5b396b3 was 700f9b4, checked in by Gervaise Alina <gervyh@…>, 16 years ago

small change on status bar

  • Property mode set to 100644
File size: 29.8 KB
Line 
1"""
2This software was developed by the University of Tennessee as part of the
3Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
4project funded by the US National Science Foundation.
5
6See the license text in license.txt
7
8copyright 2008, University of Tennessee
9
10How-to build an application using guiframe:
11
12 1- Write a main application script along the lines of dummyapp.py
13 2- Write a config script along the lines of config.py, and name it local_config.py
14 3- Write your plug-ins and place them in a directory called "perspectives".
15     - Look at local_perspectives/plotting for an example of a plug-in.
16     - A plug-in should define a class called Plugin. See abstract class below.
17
18"""
19import wx
20import wx.aui
21import os, sys
22try:
23    # Try to find a local config
24    import imp
25    path = os.getcwd()
26    if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
27      (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
28            fObj, path, descr = imp.find_module('local_config', [path])
29            config = imp.load_module('local_config', fObj, path, descr) 
30    else:
31        # Try simply importing local_config
32        import local_config as config
33except:
34    # Didn't find local config, load the default
35    import config
36   
37from sans.guicomm.events import EVT_STATUS,Model2DPanelEvent
38from sans.guicomm.events import EVT_NEW_PLOT,EVT_SLICER_PARS_UPDATE
39import history
40import warnings
41warnings.simplefilter("ignore")
42
43import logging
44
45class Plugin:
46    """
47        This class defines the interface for a Plugin class
48        that can be used by the gui_manager.
49       
50        Plug-ins should be placed in a sub-directory called "perspectives".
51        For example, a plug-in called Foo should be place in "perspectives/Foo".
52        That directory contains at least two files:
53            perspectives/Foo/__init.py contains two lines:
54           
55                PLUGIN_ID = "Foo plug-in 1.0"
56                from Foo import *
57               
58            perspectives/Foo/Foo.py contains the definition of the Plugin
59            class for the Foo plug-in. The interface of that Plugin class
60            should follow the interface of the class you are looking at.
61    """
62   
63    def __init__(self):
64        """
65            Abstract class for gui_manager Plugins.
66        """
67        ## Plug-in name. It will appear on the application menu.
68        self.sub_menu = "Plugin"       
69       
70        ## Reference to the parent window. Filled by get_panels() below.
71        self.parent = None
72       
73        ## List of panels that you would like to open in AUI windows
74        #  for your plug-in. This defines your plug-in "perspective"
75        self.perspective = []
76       
77        raise RuntimeError, "gui_manager.Plugin is an abstract class"
78       
79    def populate_menu(self, id, parent):
80        """
81            Create and return the list of application menu
82            items for the plug-in.
83           
84            @param id: deprecated. Un-used.
85            @param parent: parent window
86            @return: plug-in menu
87        """
88        import wx
89        # Create a menu
90        plug_menu = wx.Menu()
91
92        # Always get event IDs from wx
93        id = wx.NewId()
94       
95        # Fill your menu
96        plug_menu.Append(id, '&Do something')
97        wx.EVT_MENU(owner, id, self._on_do_something)
98   
99        # Returns the menu and a name for it.
100        return [(id, plug_menu, "name of the application menu")]
101   
102   
103    def get_panels(self, parent):
104        """
105            Create and return the list of wx.Panels for your plug-in.
106            Define the plug-in perspective.
107           
108            Panels should inherit from DefaultPanel defined below,
109            or should present the same interface. They must define
110            "window_caption" and "window_name".
111           
112            @param parent: parent window
113            @return: list of panels
114        """
115        ## Save a reference to the parent
116        self.parent = parent
117       
118        # Define a panel
119        mypanel = DefaultPanel(self.parent, -1)
120       
121        # If needed, add its name to the perspective list
122        self.perspective.append(self.control_panel.window_name)
123
124        # Return the list of panels
125        return [mypanel]
126   
127    def get_context_menu(self, graph=None):
128        """
129            This method is optional.
130       
131            When the context menu of a plot is rendered, the
132            get_context_menu method will be called to give you a
133            chance to add a menu item to the context menu.
134           
135            A ref to a Graph object is passed so that you can
136            investigate the plot content and decide whether you
137            need to add items to the context menu. 
138           
139            This method returns a list of menu items.
140            Each item is itself a list defining the text to
141            appear in the menu, a tool-tip help text, and a
142            call-back method.
143           
144            @param graph: the Graph object to which we attach the context menu
145            @return: a list of menu items with call-back function
146        """
147        return [["Menu text", 
148                 "Tool-tip help text", 
149                 self._on_context_do_something]]     
150   
151    def get_perspective(self):
152        """
153            Get the list of panel names for this perspective
154        """
155        return self.perspective
156   
157    def on_perspective(self, event):
158        """
159            Call back function for the perspective menu item.
160            We notify the parent window that the perspective
161            has changed.
162            @param event: menu event
163        """
164        self.parent.set_perspective(self.perspective)
165   
166    def post_init(self):
167        """
168            Post initialization call back to close the loose ends
169        """
170        pass
171
172
173class ViewerFrame(wx.Frame):
174    """
175        Main application frame
176    """
177    def __init__(self, parent, id, title, window_height=700, window_width=900):
178    #def __init__(self, parent, id, title, window_height=800, window_width=800):
179        """
180            Initialize the Frame object
181        """
182        from local_perspectives.plotting import plotting
183        #wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, size=(800, 700))
184        wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, size=(900, 600))
185       
186        # Preferred window size
187        self._window_height = window_height
188        self._window_width  = window_width
189       
190        # Logging info
191        logging.basicConfig(level=logging.DEBUG,
192                    format='%(asctime)s %(levelname)s %(message)s',
193                    filename='sans_app.log',
194                    filemode='w')       
195       
196        path = os.path.dirname(__file__)
197        ico_file = os.path.join(path,'images/ball.ico')
198        if os.path.isfile(ico_file):
199            self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
200        else:
201            ico_file = os.path.join(os.getcwd(),'images/ball.ico')
202            if os.path.isfile(ico_file):
203                self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
204       
205        ## Application manager
206        self.app_manager = None
207       
208        ## Find plug-ins
209        # Modify this so that we can specify the directory to look into
210        self.plugins = self._find_plugins()
211        self.plugins.append(plotting.Plugin())
212
213        ## List of panels
214        self.panels = {}
215
216        ## Next available ID for wx gui events
217        #TODO:  No longer used - remove all calls to this
218        self.next_id = 20000
219
220        # Default locations
221        self._default_save_location = os.getcwd()       
222
223        ## Default welcome panel
224        self.defaultPanel    = DefaultPanel(self, -1, style=wx.RAISED_BORDER)
225       
226        # History panel
227        #self.histPanel     = history.HistoryPanel(self, style=wx.RAISED_BORDER)
228        # self.build_gui()
229       
230        # Register the close event so it calls our own method
231        wx.EVT_CLOSE(self, self._onClose)
232        # Register to status events
233        self.Bind(EVT_STATUS, self._on_status_event)
234        self.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
235       
236       
237    def _onEVT_SLICER_PANEL(self, event):
238        """
239            receive and event telling to update a panel with a name starting with
240            event.panel_name. this method update slicer panel for a given interactor.
241            @param event: contains type of slicer , paramaters for updating the panel
242            and panel_name to find the slicer 's panel concerned.
243        """
244        for item in self.panels:
245            if self.panels[item].window_caption.startswith(event.panel_name): 
246                self.panels[item].set_slicer(event.type, event.params)
247                self._mgr.Update()
248                break
249       
250    def build_gui(self):
251        # Set up the layout
252        self._setup_layout()
253       
254        # Set up the menu
255        self._setup_menus()
256       
257        self.Fit()
258       
259        #self._check_update(None)
260             
261    def _setup_layout(self):
262        """
263            Set up the layout
264        """
265        # Status bar
266        from statusbar import MyStatusBar
267        self.sb = MyStatusBar(self,wx.ID_ANY)
268        self.SetStatusBar(self.sb)
269
270        # Add panel
271        self._mgr = wx.aui.AuiManager(self)
272       
273        # Load panels
274        self._load_panels()
275       
276        self._mgr.Update()
277
278    def add_perspective(self, plugin):
279        """
280            Add a perspective if it doesn't already
281            exist.
282        """
283        is_loaded = False
284        for item in self.plugins:
285             if plugin.__class__==item.__class__:
286                 print "Plugin %s already loaded" % plugin.__class__.__name__
287                 is_loaded = True
288                 
289        if not is_loaded:
290            self.plugins.append(plugin)
291     
292    def _find_plugins(self, dir="perspectives"):
293        """
294            Find available perspective plug-ins
295            @param dir: directory in which to look for plug-ins
296            @return: list of plug-ins
297        """
298        import imp
299        print "Looking for plug-ins in %s" % dir
300        # List of plug-in objects
301       
302        #path_exe = os.getcwd()
303        #path_plugs = os.path.join(path_exe, dir)
304        f = open("load.log",'w') 
305        f.write(os.getcwd()+'\n\n')
306        #f.write(str(os.listdir(dir))+'\n')
307       
308       
309        plugins = []
310        # Go through files in panels directory
311        try:
312            list = os.listdir(dir)
313            for item in list:
314                toks = os.path.splitext(os.path.basename(item))
315                name = None
316                if not toks[0] == '__init__':
317                   
318                    if toks[1]=='.py' or toks[1]=='':
319                        name = toks[0]
320               
321                    path = [os.path.abspath(dir)]
322                    file = None
323                    try:
324                        if toks[1]=='':
325                            f.write("trying to import \n")
326                            mod_path = '.'.join([dir, name])
327                            f.write("mod_path= %s\n" % mod_path)
328                            module = __import__(mod_path, globals(), locals(), [name])
329                            f.write(str(module)+'\n')
330                        else:
331                            (file, path, info) = imp.find_module(name, path)
332                            module = imp.load_module( name, file, item, info )
333                        if hasattr(module, "PLUGIN_ID"):
334                            try:
335                                plugins.append(module.Plugin())
336                                print "Found plug-in: %s" % module.PLUGIN_ID
337                            except:
338                                config.printEVT("Error accessing PluginPanel in %s\n  %s" % (name, sys.exc_value))
339                       
340                    except:
341                        print sys.exc_value
342                        f.write(str(sys.exc_value)+'\n')
343                    finally:
344                        if not file==None:
345                            file.close()
346        except:
347            # Should raise and catch at a higher level and display error on status bar
348            pass   
349        f.write(str(plugins)+'\n')
350        f.close()
351        return plugins
352   
353       
354     
355    def _load_panels(self):
356        """
357            Load all panels in the panels directory
358        """
359       
360        # Look for plug-in panels
361        panels = []       
362        for item in self.plugins:
363            if hasattr(item, "get_panels"):
364                ps = item.get_panels(self)
365                panels.extend(ps)
366
367        # Show a default panel with some help information
368        # It also sets the size of the application windows
369        self.panels["default"] = self.defaultPanel
370         # History panel
371        #self.panels["historyPanel"] = self.histPanel 
372       
373        self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo().
374                              Name("default").
375                              CenterPane().
376                              # This is where we set the size of the application window
377                              BestSize(wx.Size(self._window_width, self._window_height)).
378                              MinSize(wx.Size(self._window_width, self._window_height)).
379                              Show())
380        """
381        self._mgr.AddPane(self.histPanel, wx.aui.AuiPaneInfo().
382                          Name("historyPanel").Caption("History").
383                          #Float().
384                          Bottom().
385                          Dock().
386                          TopDockable().
387                          BottomDockable().
388                          LeftDockable().
389                          RightDockable().
390                          MinimizeButton().
391                          Hide().
392                          #Show().
393                          BestSize(wx.Size(500,600)).
394                          MinSize(wx.Size(200,150)))
395        """
396
397        # Add the panels to the AUI manager
398        for panel_class in panels:
399            p = panel_class
400            id = wx.NewId()
401           
402            # Check whether we need to put this panel
403            # in the center pane
404            if hasattr(p, "CENTER_PANE"):
405                if p.CENTER_PANE:
406                    self.panels[str(id)] = p
407                    self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
408                                          Name(p.window_name).Caption(p.window_caption).
409                                          CenterPane().
410                                          BestSize(wx.Size(600,600)).
411                                          MinSize(wx.Size(400,400)).
412                                          #BestSize(wx.Size(500,500)).
413                                          #MinSize(wx.Size(200,200)).
414                                          Hide())
415               
416            else:
417                self.panels[str(id)] = p
418                self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
419                                  Name(p.window_name).Caption(p.window_caption).
420                                  #Floatable().
421                                  #Float().
422                                  Right().
423                                  Dock().
424                                  TopDockable().
425                                  BottomDockable().
426                                  LeftDockable().
427                                  RightDockable().
428                                  MinimizeButton().
429                                  Hide().
430                                  #Show().
431                                  BestSize(wx.Size(600,600)).
432                                  MinSize(wx.Size(500,500)))
433                                  #BestSize(wx.Size(400,400)).
434                                  #MinSize(wx.Size(300,300)))
435
436               
437       
438    def get_context_menu(self, graph=None):
439        """
440            Get the context menu items made available
441            by the different plug-ins.
442            This function is used by the plotting module
443        """
444        menu_list = []
445        for item in self.plugins:
446            if hasattr(item, "get_context_menu"):
447                menu_list.extend(item.get_context_menu(graph))
448           
449        return menu_list
450       
451    def popup_panel(self, p):
452        """
453            Add a panel object to the AUI manager
454            @param p: panel object to add to the AUI manager
455            @return: ID of the event associated with the new panel [int]
456        """
457       
458        ID = wx.NewId()
459        self.panels[str(ID)] = p
460       
461        count = 0
462        for item in self.panels:
463            if self.panels[item].window_name.startswith(p.window_name): 
464                count += 1
465       
466        windowname = p.window_name
467        caption = p.window_caption
468       
469        if count>0:
470            windowname += str(count+1)
471            caption += (' '+str(count))
472         
473        p.window_name = windowname
474        p.window_caption = caption
475           
476        self._mgr.AddPane(p, wx.aui.AuiPaneInfo().
477                          Name(windowname).Caption(caption).
478                          Floatable().
479                          #Float().
480                          Right().
481                          Dock().
482                          TopDockable().
483                          BottomDockable().
484                          LeftDockable().
485                          RightDockable().
486                          MinimizeButton().
487                          #Hide().
488                          #Show().
489                          BestSize(wx.Size(600,600)).
490                          MinSize(wx.Size(500,500)))
491                          #BestSize(wx.Size(400,400)).
492                          #MinSize(wx.Size(350,350)))
493        pane = self._mgr.GetPane(windowname)
494        self._mgr.MaximizePane(pane)
495        self._mgr.RestoreMaximizedPane()
496       
497       
498        # Register for showing/hiding the panel
499       
500        wx.EVT_MENU(self, ID, self._on_view)
501       
502        self._mgr.Update()
503        return ID
504       
505    def _setup_menus(self):
506        """
507            Set up the application menus
508        """
509        # Menu
510        menubar = wx.MenuBar()
511       
512        # File menu
513        filemenu = wx.Menu()
514       
515        id = wx.NewId()
516        filemenu.Append(id, '&Open', 'Open a file')
517        wx.EVT_MENU(self, id, self._on_open)
518       
519        #id = wx.NewId()
520        #filemenu.Append(id, '&History', 'Register previous States')
521        #wx.EVT_MENU(self, id, self._onHistoryPanel)
522       
523        id = wx.NewId()
524        filemenu.Append(id,'&Quit', 'Exit') 
525        wx.EVT_MENU(self, id, self.Close)
526       
527        # Add sub menus
528        menubar.Append(filemenu,  '&File')
529       
530        # Plot menu
531        # Attach a menu item for each panel in our
532        # panel list that also appears in a plug-in.
533        # TODO: clean this up. We should just identify
534        # plug-in panels and add them all.
535       
536        # Only add the panel menu if there is more than one panel
537        n_panels = 0
538        for plug in self.plugins:
539            pers = plug.get_perspective()
540            if len(pers)>0:
541                n_panels += 1
542       
543        if n_panels>1:
544            viewmenu = wx.Menu()
545            for plug in self.plugins:
546                plugmenu = wx.Menu()
547                pers = plug.get_perspective()
548                if len(pers)>0:
549                    for item in self.panels:
550                        if item == 'default':
551                            continue
552                        panel = self.panels[item]
553                        if panel.window_name in pers:
554                            plugmenu.Append(int(item), panel.window_caption, "Show %s window" % panel.window_caption)
555                           
556                           
557                           
558                            wx.EVT_MENU(self, int(item), self._on_view)
559                   
560                    viewmenu.AppendMenu(wx.NewId(), plug.sub_menu, plugmenu, plug.sub_menu)
561               
562            menubar.Append(viewmenu, '&Panel')
563
564        # Perspective
565        # Attach a menu item for each defined perspective.
566        # Only add the perspective menu if there are more than one perspectves
567        n_perspectives = 0
568        for plug in self.plugins:
569            if len(plug.get_perspective()) > 0:
570                n_perspectives += 1
571       
572        if n_perspectives>1:
573            p_menu = wx.Menu()
574            for plug in self.plugins:
575                if len(plug.get_perspective()) > 0:
576                    id = wx.NewId()
577                    p_menu.Append(id, plug.sub_menu, "Switch to %s perspective" % plug.sub_menu)
578                    wx.EVT_MENU(self, id, plug.on_perspective)
579            menubar.Append(p_menu,   '&Perspective')
580 
581        # Help menu
582        helpmenu = wx.Menu()
583
584        # Look for help item in plug-ins
585        for item in self.plugins:
586            if hasattr(item, "help"):
587                id = wx.NewId()
588                helpmenu.Append(id,'&%s help' % item.sub_menu, '')
589                wx.EVT_MENU(self, id, item.help)
590       
591        if config._do_aboutbox:
592            id = wx.NewId()
593            helpmenu.Append(id,'&About', 'Software information')
594            wx.EVT_MENU(self, id, self._onAbout)
595        id = wx.NewId()
596        helpmenu.Append(id,'&Check for update', 'Check for the latest version of %s' % config.__appname__)
597        wx.EVT_MENU(self, id, self._check_update)
598       
599       
600       
601       
602        # Look for plug-in menus
603        # Add available plug-in sub-menus.
604        for item in self.plugins:
605            if hasattr(item, "populate_menu"):
606                for (self.next_id, menu, name) in item.populate_menu(self.next_id, self):
607                    menubar.Append(menu, name)
608                   
609
610        menubar.Append(helpmenu, '&Help')
611         
612        self.SetMenuBar(menubar)
613       
614       
615       
616    def _on_status_event(self, evt):
617        """
618            Display status message
619        """
620        self.sb.clear_gauge( msg="")
621        mythread=None
622        mytype= None
623        if hasattr(evt, "curr_thread"):
624            mythread= evt.curr_thread
625        if hasattr(evt, "type"):
626            mytype= evt.type
627        self.sb.set_status( type=mytype,msg=str(evt.status),thread=mythread)
628       
629
630       
631    def _on_view(self, evt):
632        """
633            A panel was selected to be shown. If it's not already
634            shown, display it.
635            @param evt: menu event
636        """
637        self.show_panel(evt.GetId())
638
639    def show_panel(self, uid):
640        """
641            Shows the panel with the given id
642            @param uid: unique ID number of the panel to show
643        """
644        ID = str(uid)
645        config.printEVT("show_panel: %s" % ID)
646        if ID in self.panels.keys():
647            if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():
648                self._mgr.GetPane(self.panels[ID].window_name).Show()
649                # Hide default panel
650                self._mgr.GetPane(self.panels["default"].window_name).Hide()
651           
652               
653            self._mgr.Update()
654    """
655    def _onHistoryPanel(self, event):
656        print "on history"
657        if not self._mgr.GetPane("historyPanel").IsShown():
658            self._mgr.GetPane("historyPanel").Show()
659        self._mgr.Update()
660        return
661    """   
662    def _on_open(self, event):
663   
664        from data_loader import plot_data
665        path = self.choose_file()
666        if path ==None:
667            return
668        if path and os.path.isfile(path):
669            plot_data(self, path)
670           
671       
672       
673    def _onClose(self, event):
674        import sys
675        wx.Exit()
676        sys.exit()
677                   
678    def Close(self, event=None):
679        """
680            Quit the application
681        """
682        import sys
683        wx.Frame.Close(self)
684        wx.Exit()
685        sys.exit()
686
687 
688    def _check_update(self, event=None): 
689        """
690            Check with the deployment server whether a new version
691            of the application is available
692        """
693        import urllib
694        try: 
695            h = urllib.urlopen(config.__update_URL__)
696            lines = h.readlines()
697            line = ''
698            if len(lines)>0:
699                line = lines[0]
700               
701                toks = line.lstrip().rstrip().split('.')
702                toks_current = config.__version__.split('.')
703                update_available = False
704                for i in range(len(toks)):
705                    if len(toks[i].strip())>0:
706                        if int(toks[i].strip())>int(toks_current[i]):
707                            update_available = True
708                if update_available:
709                    #print "Version %s is available" % line.rstrip().lstrip()
710                    self.SetStatusText("Version %s is available! See the Help menu to download it." % line.rstrip().lstrip())
711                    if event != None:
712                        import webbrowser
713                        webbrowser.open(config.__download_page__)
714                else:
715                    if event != None:
716                        self.SetStatusText("You have the latest version of %s" % config.__appname__)
717        except:
718            if event != None:
719                self.SetStatusText("You have the latest version of %s" % config.__appname__)
720           
721           
722    def _onAbout(self, evt):
723        """
724            Pop up the about dialog
725            @param evt: menu event
726        """
727        if config._do_aboutbox:
728            import aboutbox 
729            dialog = aboutbox.DialogAbout(None, -1, "")
730            dialog.ShowModal()
731           
732    def set_manager(self, manager):
733        """
734            Sets the application manager for this frame
735            @param manager: frame manager
736        """
737        self.app_manager = manager
738       
739    def post_init(self):
740        """
741            This initialization method is called after the GUI
742            has been created and all plug-ins loaded. It calls
743            the post_init() method of each plug-in (if it exists)
744            so that final initialization can be done.
745        """
746        for item in self.plugins:
747            if hasattr(item, "post_init"):
748                item.post_init()
749       
750    def set_perspective(self, panels):
751        """
752            Sets the perspective of the GUI.
753            Opens all the panels in the list, and closes
754            all the others.
755           
756            @param panels: list of panels
757        """
758        for item in self.panels:
759            # Check whether this is a sticky panel
760            if hasattr(self.panels[item], "ALWAYS_ON"):
761                if self.panels[item].ALWAYS_ON:
762                    continue 
763           
764            if self.panels[item].window_name in panels:
765                if not self._mgr.GetPane(self.panels[item].window_name).IsShown():
766                    self._mgr.GetPane(self.panels[item].window_name).Show()
767            else:
768                if self._mgr.GetPane(self.panels[item].window_name).IsShown():
769                    self._mgr.GetPane(self.panels[item].window_name).Hide()
770                 
771        self._mgr.Update()
772       
773    def choose_file(self):
774        """
775            Functionality that belongs elsewhere
776            Should add a hook to specify the preferred file type/extension.
777        """
778        #TODO: clean this up
779        from data_loader import choose_data_file
780        path = choose_data_file(self, self._default_save_location)
781        if not path==None:
782            try:
783                self._default_save_location = os.path.dirname(path)
784            except:
785                pass
786        return path
787   
788    def load_ascii_1D(self, path):
789        from data_loader import load_ascii_1D
790        return load_ascii_1D(path)
791                 
792class DefaultPanel(wx.Panel):
793    """
794        Defines the API for a panels to work with
795        the GUI manager
796    """
797    ## Internal nickname for the window, used by the AUI manager
798    window_name = "default"
799    ## Name to appear on the window title bar
800    window_caption = "Welcome panel"
801    ## Flag to tell the AUI manager to put this panel in the center pane
802    CENTER_PANE = True
803
804 
805# Toy application to test this Frame
806class ViewApp(wx.App):
807    def OnInit(self):
808        #from gui_manager import ViewerFrame
809        self.frame = ViewerFrame(None, -1, config.__appname__)   
810        self.frame.Show(True)
811
812        if hasattr(self.frame, 'special'):
813            print "Special?", self.frame.special.__class__.__name__
814            self.frame.special.SetCurrent()
815        self.SetTopWindow(self.frame)
816        return True
817   
818    def set_manager(self, manager):
819        """
820            Sets a reference to the application manager
821            of the GUI manager (Frame)
822        """
823        self.frame.set_manager(manager)
824       
825    def build_gui(self):
826        """
827            Build the GUI
828        """
829        self.frame.build_gui()
830        self.frame.post_init()
831       
832    def add_perspective(self, perspective):
833        """
834            Manually add a perspective to the application GUI
835        """
836        self.frame.add_perspective(perspective)
837       
838
839if __name__ == "__main__": 
840    app = ViewApp(0)
841    app.MainLoop()             
Note: See TracBrowser for help on using the repository browser.