source: sasview/src/sas/sasgui/guiframe/gui_manager.py @ 5f08251

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249unittest-saveload
Last change on this file since 5f08251 was 5f08251, checked in by smk78, 9 months ago

Removed old commented text

  • Property mode set to 100644
File size: 125.2 KB
Line 
1"""
2    Gui manager: manages the widgets making up an application
3"""
4################################################################################
5# This software was developed by the University of Tennessee as part of the
6# Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
7# project funded by the US National Science Foundation.
8#
9# See the license text in license.txtz
10#
11# copyright 2008, University of Tennessee
12################################################################################
13
14
15import wx
16import wx.aui
17import os
18import sys
19import time
20import imp
21import warnings
22import re
23import logging
24import traceback
25import urllib
26import json
27
28from matplotlib import _pylab_helpers
29
30from sas import get_local_config, get_custom_config, get_app_dir, get_user_dir
31from sas.sasgui.guiframe.events import EVT_CATEGORY
32from sas.sasgui.guiframe.events import EVT_STATUS
33from sas.sasgui.guiframe.events import EVT_APPEND_BOOKMARK
34from sas.sasgui.guiframe.events import EVT_PANEL_ON_FOCUS
35from sas.sasgui.guiframe.events import EVT_NEW_LOAD_DATA
36from sas.sasgui.guiframe.events import EVT_NEW_COLOR
37from sas.sasgui.guiframe.events import StatusEvent
38from sas.sasgui.guiframe.events import NewPlotEvent
39from sas.sasgui.guiframe.gui_style import GUIFRAME
40from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
41from sas.sasgui.guiframe.data_panel import DataPanel
42from sas.sasgui.guiframe.panel_base import PanelBase
43from sas.sasgui.guiframe.gui_toolbar import GUIToolBar
44from sas.sasgui.guiframe.data_processor import GridFrame
45from sas.sasgui.guiframe.events import EVT_NEW_BATCH
46from sas.sasgui.guiframe.CategoryManager import CategoryManager
47from sas.sascalc.dataloader.loader import Loader
48from sas.sasgui.guiframe.proxy import Connection
49
50logger = logging.getLogger(__name__)
51warnings.simplefilter("ignore")
52
53config = get_local_config()
54custom_config = get_custom_config()
55
56# read some constants from config
57APPLICATION_STATE_EXTENSION = config.APPLICATION_STATE_EXTENSION
58APPLICATION_NAME = config.__appname__
59SPLASH_SCREEN_PATH = config.SPLASH_SCREEN_PATH
60WELCOME_PANEL_ON = config.WELCOME_PANEL_ON
61SPLASH_SCREEN_WIDTH = config.SPLASH_SCREEN_WIDTH
62SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT
63SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME
64if not WELCOME_PANEL_ON:
65    WELCOME_PANEL_SHOW = False
66else:
67    WELCOME_PANEL_SHOW = True
68try:
69    DATALOADER_SHOW = custom_config.DATALOADER_SHOW
70    TOOLBAR_SHOW = custom_config.TOOLBAR_SHOW
71    FIXED_PANEL = custom_config.FIXED_PANEL
72    if WELCOME_PANEL_ON:
73        WELCOME_PANEL_SHOW = custom_config.WELCOME_PANEL_SHOW
74    PLOPANEL_WIDTH = custom_config.PLOPANEL_WIDTH
75    DATAPANEL_WIDTH = custom_config.DATAPANEL_WIDTH
76    GUIFRAME_WIDTH = custom_config.GUIFRAME_WIDTH
77    GUIFRAME_HEIGHT = custom_config.GUIFRAME_HEIGHT
78    CONTROL_WIDTH = custom_config.CONTROL_WIDTH
79    CONTROL_HEIGHT = custom_config.CONTROL_HEIGHT
80    DEFAULT_PERSPECTIVE = custom_config.DEFAULT_PERSPECTIVE
81    CLEANUP_PLOT = custom_config.CLEANUP_PLOT
82    # custom open_path
83    open_folder = custom_config.DEFAULT_OPEN_FOLDER
84    if open_folder is not None and os.path.isdir(open_folder):
85        DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder)
86    else:
87        DEFAULT_OPEN_FOLDER = get_app_dir()
88    SAS_OPENCL = custom_config.SAS_OPENCL
89except:
90    DATALOADER_SHOW = True
91    TOOLBAR_SHOW = True
92    FIXED_PANEL = True
93    WELCOME_PANEL_SHOW = False
94    PLOPANEL_WIDTH = config.PLOPANEL_WIDTH
95    DATAPANEL_WIDTH = config.DATAPANEL_WIDTH
96    GUIFRAME_WIDTH = config.GUIFRAME_WIDTH
97    GUIFRAME_HEIGHT = config.GUIFRAME_HEIGHT
98    CONTROL_WIDTH = -1
99    CONTROL_HEIGHT = -1
100    DEFAULT_PERSPECTIVE = None
101    CLEANUP_PLOT = False
102    DEFAULT_OPEN_FOLDER = get_app_dir()
103    DEFAULT_OPEN_FOLDER = PATH_APP
104    SAS_OPENCL = None
105DEFAULT_STYLE = config.DEFAULT_STYLE
106
107PLUGIN_STATE_EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS
108OPEN_SAVE_MENU = config.OPEN_SAVE_PROJECT_MENU
109VIEW_MENU = config.VIEW_MENU
110EDIT_MENU = config.EDIT_MENU
111extension_list = []
112if APPLICATION_STATE_EXTENSION is not None:
113    extension_list.append(APPLICATION_STATE_EXTENSION)
114EXTENSIONS = PLUGIN_STATE_EXTENSIONS + extension_list
115try:
116    PLUGINS_WLIST = '|'.join(config.PLUGINS_WLIST)
117except:
118    PLUGINS_WLIST = ''
119APPLICATION_WLIST = config.APPLICATION_WLIST
120IS_WIN = True
121IS_LINUX = False
122CLOSE_SHOW = True
123TIME_FACTOR = 2
124MDI_STYLE = wx.DEFAULT_FRAME_STYLE
125NOT_SO_GRAPH_LIST = ["BoxSum"]
126PARENT_FRAME = wx.MDIParentFrame
127CHILD_FRAME = wx.MDIChildFrame
128if sys.platform.count("win32") < 1:
129    IS_WIN = False
130    TIME_FACTOR = 2
131    if int(str(wx.__version__).split('.')[0]) == 2:
132        if int(str(wx.__version__).split('.')[1]) < 9:
133            CLOSE_SHOW = False
134    if sys.platform.count("darwin") < 1:
135        IS_LINUX = True
136        PARENT_FRAME = wx.Frame
137        CHILD_FRAME = wx.Frame
138
139class ViewerFrame(PARENT_FRAME):
140    """
141    Main application frame
142    """
143
144    def __init__(self, parent, title,
145                 size=(GUIFRAME_WIDTH, GUIFRAME_HEIGHT),
146                 gui_style=DEFAULT_STYLE,
147                 style=wx.DEFAULT_FRAME_STYLE,
148                 pos=wx.DefaultPosition):
149        """
150        Initialize the Frame object
151        """
152        PARENT_FRAME.__init__(self, parent=parent, title=title,
153                              pos=pos, size=size)
154        # title
155        self.title = title
156        self.__gui_style = gui_style
157        path = os.path.dirname(__file__)
158        temp_path = os.path.join(path, 'images')
159        ico_file = os.path.join(temp_path, 'ball.ico')
160        if os.path.isfile(ico_file):
161            self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
162        else:
163            temp_path = os.path.join(os.getcwd(), 'images')
164            ico_file = os.path.join(temp_path, 'ball.ico')
165            if os.path.isfile(ico_file):
166                self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
167            else:
168                ico_file = os.path.join(os.path.dirname(os.path.sys.path[0]),
169                                        'images', 'ball.ico')
170                if os.path.isfile(ico_file):
171                    self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
172        self.path = get_app_dir()
173        self.application_name = APPLICATION_NAME
174        # Application manager
175        self._input_file = None
176        self.app_manager = None
177        self._mgr = None
178        # add current perpsective
179        self._current_perspective = None
180        self._plotting_plugin = None
181        self._data_plugin = None
182        # Menu bar and item
183        self._menubar = None
184        self._file_menu = None
185        self._data_menu = None
186        self._view_menu = None
187        self._data_panel_menu = None
188        self._help_menu = None
189        self._tool_menu = None
190        self._applications_menu_pos = -1
191        self._applications_menu_name = None
192        self._applications_menu = None
193        self._edit_menu = None
194        self._toolbar_menu = None
195        self._save_appl_menu = None
196        # tool bar
197        self._toolbar = None
198        # Status bar
199        self.sb = None
200        # number of plugins
201        self._num_perspectives = 0
202        # plot duck cleanup option
203        self.cleanup_plots = CLEANUP_PLOT
204        # Find plug-ins
205        # Modify this so that we can specify the directory to look into
206        self.plugins = []
207        # add local plugin
208        self.plugins += self._get_local_plugins()
209        self.plugins += self._find_plugins()
210        # List of panels
211        self.panels = {}
212        # List of plot panels
213        self.plot_panels = {}
214        # default Graph number fot the plotpanel caption
215        self.graph_num = 0
216
217        # Default locations
218        self._default_save_location = DEFAULT_OPEN_FOLDER
219        # Welcome panel
220        self.defaultPanel = None
221        self.welcome_panel_class = None
222        # panel on focus
223        self.panel_on_focus = None
224        # control_panel on focus
225        self.cpanel_on_focus = None
226
227        self.loader = Loader()
228        # data manager
229        self.batch_on = False
230        from sas.sasgui.guiframe.data_manager import DataManager
231        self._data_manager = DataManager()
232        self._data_panel = None  # DataPanel(parent=self)
233        if self.panel_on_focus is not None:
234            self._data_panel.set_panel_on_focus(
235                self.panel_on_focus.window_caption)
236        # list of plot panels in schedule to full redraw
237        self.schedule = False
238        # self.callback = True
239        self._idle_count = 0
240        self.schedule_full_draw_list = []
241        self.idletimer = wx.CallLater(TIME_FACTOR, self._onDrawIdle)
242
243        self.batch_frame = GridFrame(parent=self)
244        self.batch_frame.Hide()
245        self.on_batch_selection(event=None)
246        self.add_icon()
247
248        # Register the close event so it calls our own method
249        wx.EVT_CLOSE(self, self.WindowClose)
250        # Register to status events
251        self.Bind(EVT_STATUS, self._on_status_event)
252        # Register add extra data on the same panel event on load
253        self.Bind(EVT_PANEL_ON_FOCUS, self.set_panel_on_focus)
254        self.Bind(EVT_APPEND_BOOKMARK, self.append_bookmark)
255        self.Bind(EVT_NEW_LOAD_DATA, self.on_load_data)
256        self.Bind(EVT_NEW_BATCH, self.on_batch_selection)
257        self.Bind(EVT_NEW_COLOR, self.on_color_selection)
258        self.Bind(EVT_CATEGORY, self.on_change_categories)
259        self.setup_custom_conf()
260        # Preferred window size
261        self._window_width, self._window_height = size
262
263    def add_icon(self):
264        """
265        get list of child and attempt to add the default icon
266        """
267
268        list_children = self.GetChildren()
269        for frame in list_children:
270            self.put_icon(frame)
271
272    def put_icon(self, frame):
273        """
274        Put icon on the tap of a panel
275        """
276        if hasattr(frame, "IsIconized"):
277            if not frame.IsIconized():
278                try:
279                    icon = self.GetIcon()
280                    frame.SetIcon(icon)
281                except:
282                    logger.error("ViewerFrame.put_icon: could not set icon")
283
284    def get_client_size(self):
285        """
286        return client size tuple
287        """
288        width, height = self.GetClientSizeTuple()
289        height -= 45
290        # Adjust toolbar height
291        toolbar = self.GetToolBar()
292        if toolbar is not None:
293            _, tb_h = toolbar.GetSizeTuple()
294            height -= tb_h
295        return width, height
296
297    def on_change_categories(self, evt):
298        # ILL
299        fitpanel = None
300        for item in self.plugins:
301            if hasattr(item, "get_panels"):
302                if hasattr(item, "fit_panel"):
303                    fitpanel = item.fit_panel
304
305        if fitpanel is not None:
306            for i in range(0, fitpanel.GetPageCount()):
307                fitpanel.GetPage(i)._populate_listbox()
308
309    def on_set_batch_result(self, data_outputs, data_inputs=None,
310                            plugin_name=""):
311        """
312        Display data into a grid in batch mode and show the grid
313        """
314        t = time.localtime(time.time())
315        time_str = time.strftime("%b %d %H;%M of %Y", t)
316        details = "File Generated by %s : %s" % (APPLICATION_NAME,
317                                                 str(plugin_name))
318        details += "on %s.\n" % time_str
319        ext = ".csv"
320        file_name = "Batch_" + str(plugin_name) + "_" + time_str + ext
321        file_name = self._default_save_location + str(file_name)
322
323        self.open_with_localapp(file_name=file_name,
324                                details=details,
325                                data_inputs=data_inputs,
326                                data_outputs=data_outputs)
327
328    def open_with_localapp(self, data_inputs=None, details="", file_name=None,
329                           data_outputs=None):
330        """
331        Display value of data into the application grid
332        :param data_inputs: dictionary of string and list of items
333        :param details: descriptive string
334        :param file_name: file name
335        :param data_outputs: Data outputs
336        """
337        self.batch_frame.set_data(data_inputs=data_inputs,
338                                  data_outputs=data_outputs,
339                                  details=details,
340                                  file_name=file_name)
341        self.show_batch_frame(None)
342
343    def on_read_batch_tofile(self, base):
344        """
345        Open a file dialog , extract the file to read and display values
346        into a grid
347        """
348        path = None
349        if self._default_save_location is None:
350            self._default_save_location = os.getcwd()
351        wildcard = "(*.csv; *.txt)|*.csv; *.txt"
352        dlg = wx.FileDialog(base,
353                            "Choose a file",
354                            self._default_save_location, "",
355                            wildcard)
356        if dlg.ShowModal() == wx.ID_OK:
357            path = dlg.GetPath()
358            if path is not None:
359                self._default_save_location = os.path.dirname(path)
360        dlg.Destroy()
361        try:
362            self.read_batch_tofile(file_name=path)
363        except:
364            msg = "Error occurred when reading the file; %s\n" % path
365            msg += "%s\n" % sys.exc_value
366            wx.PostEvent(self, StatusEvent(status=msg,
367                                           info="error"))
368
369    def read_batch_tofile(self, file_name):
370        """
371        Extract value from file name and Display them into a grid
372        """
373        if file_name is None or file_name.strip() == "":
374            return
375        data = {}
376        fd = open(file_name, 'r')
377        _, ext = os.path.splitext(file_name)
378        separator = None
379        if ext.lower() == ".csv":
380            separator = ","
381        fd_buffer = fd.read()
382        lines = fd_buffer.split('\n')
383        fd.close()
384        column_names_line = ""
385        index = None
386        details = ""
387        for index in range(len(lines)):
388            line = lines[index]
389            line.strip()
390            count = 0
391            if separator is None:
392                line.replace('\t', ' ')
393                # found the first line containing the label
394                col_name_toks = line.split()
395                for item in col_name_toks:
396                    if item.strip() != "":
397                        count += 1
398                    else:
399                        line = " "
400            elif line.find(separator) != -1:
401                if line.count(separator) >= 2:
402                    # found the first line containing the label
403                    col_name_toks = line.split(separator)
404                    for item in col_name_toks:
405                        if item.strip() != "":
406                            count += 1
407            else:
408                details += line
409            if count >= 2:
410                column_names_line = line
411                break
412
413        if column_names_line.strip() == "" or index is None:
414            return
415
416        col_name_toks = column_names_line.split(separator)
417        c_index = 0
418        for col_index in range(len(col_name_toks)):
419            c_name = col_name_toks[col_index]
420            if c_name.strip() != "":
421                # distinguish between column name and value
422                try:
423                    float(c_name)
424                    col_name = "Column %s" % str(col_index + 1)
425                    index_min = index
426                except:
427                    col_name = c_name
428                    index_min = index + 1
429                data[col_name] = [lines[row].split(separator)[c_index]
430                                  for row in range(index_min, len(lines) - 1)]
431                c_index += 1
432
433        self.open_with_localapp(data_outputs=data, data_inputs=None,
434                                file_name=file_name, details=details)
435
436    def write_batch_tofile(self, data, file_name, details=""):
437        """
438        Helper to write result from batch into cvs file
439        """
440        self._default_save_location = os.path.dirname(file_name)
441        name = os.path.basename(file_name)
442        if data is None or file_name is None or file_name.strip() == "":
443            return
444        _, ext = os.path.splitext(name)
445        try:
446            fd = open(file_name, 'w')
447        except Exception:
448            # On Permission denied: IOError
449            temp_dir = get_user_dir()
450            temp_file_name = os.path.join(temp_dir, name)
451            fd = open(temp_file_name, 'w')
452        separator = "\t"
453        if ext.lower() == ".csv":
454            separator = ","
455        fd.write(str(details))
456        for col_name in data.keys():
457            fd.write(str(col_name))
458            fd.write(separator)
459        fd.write('\n')
460        max_list = [len(value) for value in data.values()]
461        if len(max_list) == 0:
462            return
463        max_index = max(max_list)
464        index = 0
465        while index < max_index:
466            for value_list in data.values():
467                if index < len(value_list):
468                    fd.write(str(value_list[index]))
469                    fd.write(separator)
470                else:
471                    fd.write('')
472                    fd.write(separator)
473            fd.write('\n')
474            index += 1
475        fd.close()
476
477    def open_with_externalapp(self, data, file_name, details=""):
478        """
479        Display data in the another application , by default Excel
480        """
481        if not os.path.exists(file_name):
482            self.write_batch_tofile(data=data, file_name=file_name,
483                                    details=details)
484        try:
485            from win32com.client import Dispatch
486            excel_app = Dispatch('Excel.Application')
487            excel_app.Workbooks.Open(file_name)
488            excel_app.Visible = 1
489        except:
490            msg = "Error occured when calling Excel.\n"
491            msg += "Check that Excel installed in this machine or \n"
492            msg += "check that %s really exists.\n" % str(file_name)
493            wx.PostEvent(self, StatusEvent(status=msg,
494                                           info="error"))
495
496    def on_batch_selection(self, event=None):
497        """
498        :param event: contains parameter enable. When enable is set to True
499            the application is in Batch mode otherwise the application is
500            in Single mode.
501        """
502        if event is not None:
503            self.batch_on = event.enable
504        for plug in self.plugins:
505            plug.set_batch_selection(self.batch_on)
506
507    def on_color_selection(self, event):
508        """
509        :param event: contains parameters for id and color
510        """
511        color, event_id = event.color, event.id
512        for plug in self.plugins:
513            plug.add_color(color, event_id)
514
515    def setup_custom_conf(self):
516        """
517        Set up custom configuration if exists
518        """
519        if custom_config is None:
520            return
521
522        if not FIXED_PANEL:
523            self.__gui_style &= (~GUIFRAME.FIXED_PANEL)
524            self.__gui_style |= GUIFRAME.FLOATING_PANEL
525
526        if not DATALOADER_SHOW:
527            self.__gui_style &= (~GUIFRAME.MANAGER_ON)
528
529        if not TOOLBAR_SHOW:
530            self.__gui_style &= (~GUIFRAME.TOOLBAR_ON)
531
532        if WELCOME_PANEL_SHOW:
533            self.__gui_style |= GUIFRAME.WELCOME_PANEL_ON
534
535    def set_custom_default_perspective(self):
536        """
537        Set default starting perspective
538        """
539        if custom_config is None:
540            return
541        for plugin in self.plugins:
542            try:
543                if plugin.sub_menu == DEFAULT_PERSPECTIVE:
544
545                    plugin.on_perspective(event=None)
546                    frame = plugin.get_frame()
547                    frame.Show(True)
548                    # break
549                else:
550                    frame = plugin.get_frame()
551                    frame.Show(False)
552            except:
553                pass
554        return
555
556    def on_load_data(self, event):
557        """
558        received an event to trigger load from data plugin
559        """
560        if self._data_plugin is not None:
561            self._data_plugin.load_data(event)
562
563    def get_current_perspective(self):
564        """
565        return the current perspective
566        """
567        return self._current_perspective
568
569    def get_save_location(self):
570        """
571        return the _default_save_location
572        """
573        return self._default_save_location
574
575    def set_input_file(self, input_file):
576        """
577        :param input_file: file to read
578        """
579        self._input_file = input_file
580
581    def get_data_manager(self):
582        """
583        return the data manager.
584        """
585        return self._data_manager
586
587    def get_toolbar(self):
588        """
589        return the toolbar.
590        """
591        return self._toolbar
592
593    def set_panel_on_focus(self, event):
594        """
595        Store reference to the last panel on focus
596        update the toolbar if available
597        update edit menu if available
598        """
599        if event is not None:
600            self.panel_on_focus = event.panel
601        if self.panel_on_focus is not None:
602            # Disable save application if the current panel is in batch mode
603            try:
604                flag = self.panel_on_focus.get_save_flag()
605                if self._save_appl_menu is not None:
606                    self._save_appl_menu.Enable(flag)
607
608                if self.panel_on_focus not in self.plot_panels.values():
609                    for ID in self.panels.keys():
610                        if self.panel_on_focus != self.panels[ID]:
611                            self.panels[ID].on_kill_focus(None)
612
613                if self._data_panel is not None and \
614                                self.panel_on_focus is not None:
615                    self.set_panel_on_focus_helper()
616                    # update toolbar
617                    self._update_toolbar_helper()
618                    # update edit menu
619                    self.enable_edit_menu()
620            except wx._core.PyDeadObjectError:
621                pass
622
623    def disable_app_menu(self, p_panel=None):
624        """
625        Disables all menus in the menubar
626        """
627        return
628
629    def send_focus_to_datapanel(self, name):
630        """
631        Send focusing on ID to data explorer
632        """
633        if self._data_panel is not None:
634            self._data_panel.set_panel_on_focus(name)
635
636    def set_panel_on_focus_helper(self):
637        """
638        Helper for panel on focus with data_panel
639        """
640        caption = self.panel_on_focus.window_caption
641        self.send_focus_to_datapanel(caption)
642        # update combo
643        if self.panel_on_focus in self.plot_panels.values():
644            combo = self._data_panel.cb_plotpanel
645            combo_title = str(self.panel_on_focus.window_caption)
646            combo.SetStringSelection(combo_title)
647            combo.SetToolTip(wx.ToolTip(combo_title))
648        elif self.panel_on_focus != self._data_panel:
649            cpanel = self.panel_on_focus
650            if self.cpanel_on_focus != cpanel:
651                cpanel.on_tap_focus()
652                self.cpanel_on_focus = self.panel_on_focus
653
654    def reset_bookmark_menu(self, panel):
655        """
656        Reset Bookmark menu list
657
658        : param panel: a control panel or tap where the bookmark is
659        """
660        cpanel = panel
661        if self._toolbar is not None and cpanel._bookmark_flag:
662            for item in self._toolbar.get_bookmark_items():
663                self._toolbar.remove_bookmark_item(item)
664            self._toolbar.add_bookmark_default()
665            pos = 0
666            for bitem in cpanel.popUpMenu.GetMenuItems():
667                pos += 1
668                if pos < 3:
669                    continue
670                id = bitem.GetId()
671                label = bitem.GetLabel()
672                self._toolbar.append_bookmark_item(id, label)
673                wx.EVT_MENU(self, id, cpanel._back_to_bookmark)
674            self._toolbar.Realize()
675
676    def build_gui(self):
677        """
678        Build the GUI by setting up the toolbar, menu and layout.
679        """
680        # set tool bar
681        self._setup_tool_bar()
682
683        # Create the menu bar. To be filled later.
684        # WX 3.0 needs us to create the menu bar first.
685        self._menubar = wx.MenuBar()
686        if wx.VERSION_STRING >= '3.0.0.0':
687            self.SetMenuBar(self._menubar)
688        self._add_menu_file()
689        self._add_menu_edit()
690        self._add_menu_view()
691        self._add_menu_tool()
692        # Set up the layout
693        self._setup_layout()
694        self._add_menu_application()
695
696        # Set up the menu
697        self._add_current_plugin_menu()
698        self._add_help_menu()
699        # Append item from plugin under menu file if necessary
700        self._populate_file_menu()
701
702        if not wx.VERSION_STRING >= '3.0.0.0':
703            self.SetMenuBar(self._menubar)
704
705        try:
706            self.load_from_cmd(self._input_file)
707        except:
708            msg = "%s Cannot load file %s\n" % (str(APPLICATION_NAME),
709                                                str(self._input_file))
710            msg += str(sys.exc_value) + '\n'
711            logger.error(msg)
712        if self._data_panel is not None and len(self.plugins) > 0:
713            self._data_panel.fill_cbox_analysis(self.plugins)
714        self.post_init()
715        # Set Custom default
716        self.set_custom_default_perspective()
717        # Set up extra custom tool menu
718        self._setup_extra_custom()
719        self._check_update(None)
720
721    def _setup_extra_custom(self):
722        """
723        Set up toolbar and welcome view if needed
724        """
725        style = self.__gui_style & GUIFRAME.TOOLBAR_ON
726        if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()):
727            self._on_toggle_toolbar()
728
729        # Set Custom deafult start page
730        welcome_style = self.__gui_style & GUIFRAME.WELCOME_PANEL_ON
731        if welcome_style == GUIFRAME.WELCOME_PANEL_ON:
732            self.show_welcome_panel(None)
733
734    def _setup_layout(self):
735        """
736        Set up the layout
737        """
738        # Status bar
739        from sas.sasgui.guiframe.gui_statusbar import StatusBar
740        self.sb = StatusBar(self, wx.ID_ANY)
741        self.SetStatusBar(self.sb)
742        # Load panels
743        self._load_panels()
744
745    def SetStatusText(self, *args, **kwds):
746        """
747        """
748        number = self.sb.get_msg_position()
749        wx.Frame.SetStatusText(self, number=number, *args, **kwds)
750
751    def PopStatusText(self, *args, **kwds):
752        """
753        """
754        field = self.sb.get_msg_position()
755        wx.Frame.PopStatusText(self, field=field)
756
757    def PushStatusText(self, *args, **kwds):
758        """
759        .. todo:: No message is passed. What is this supposed to do?
760        """
761        field = self.sb.get_msg_position()
762        wx.Frame.PushStatusText(self, field=field,
763                                string=
764                                "FIXME - PushStatusText called without text")
765
766    def add_perspective(self, plugin):
767        """
768        Add a perspective if it doesn't already
769        exist.
770        """
771        self._num_perspectives += 1
772        is_loaded = False
773        for item in self.plugins:
774            item.set_batch_selection(self.batch_on)
775            if plugin.__class__ == item.__class__:
776                msg = "Plugin %s already loaded" % plugin.sub_menu
777                logger.info(msg)
778                is_loaded = True
779        if not is_loaded:
780            self.plugins.append(plugin)
781            msg = "Plugin %s appended" % plugin.sub_menu
782            logger.info(msg)
783
784    def _get_local_plugins(self):
785        """
786        get plugins local to guiframe and others
787        """
788        plugins = []
789        # import guiframe local plugins
790        # check if the style contain guiframe.dataloader
791        style1 = self.__gui_style & GUIFRAME.DATALOADER_ON
792        style2 = self.__gui_style & GUIFRAME.PLOTTING_ON
793        if style1 == GUIFRAME.DATALOADER_ON:
794            try:
795                from sas.sasgui.guiframe.local_perspectives.data_loader \
796                    import data_loader
797                self._data_plugin = data_loader.Plugin()
798                plugins.append(self._data_plugin)
799            except:
800                msg = "ViewerFrame._get_local_plugins:"
801                msg += "cannot import dataloader plugin.\n %s" % sys.exc_value
802                logger.error(msg)
803        if style2 == GUIFRAME.PLOTTING_ON:
804            try:
805                from sas.sasgui.guiframe.local_perspectives.plotting \
806                    import plotting
807                self._plotting_plugin = plotting.Plugin()
808                plugins.append(self._plotting_plugin)
809            except:
810                msg = "ViewerFrame._get_local_plugins:"
811                msg += "cannot import plotting plugin.\n %s" % sys.exc_value
812                logger.error(msg)
813
814        return plugins
815
816    def _find_plugins(self, dir="perspectives"):
817        """
818        Find available perspective plug-ins
819
820        :param dir: directory in which to look for plug-ins
821
822        :returns: list of plug-ins
823
824        """
825        plugins = []
826        # Go through files in panels directory
827        try:
828            if os.path.isdir(dir):
829                file_list = os.listdir(dir)
830            else:
831                file_list = []
832            # the default panel is the panel is the last plugin added
833            for item in file_list:
834                toks = os.path.splitext(os.path.basename(item))
835                name = ''
836                if not toks[0] == '__init__':
837                    if toks[1] == '.py' or toks[1] == '':
838                        name = toks[0]
839                    # check the validity of the module name parsed
840                    # before trying to import it
841                    if name is None or name.strip() == '':
842                        continue
843                    path = [os.path.abspath(dir)]
844                    file = None
845                    try:
846                        if toks[1] == '':
847                            mod_path = '.'.join([dir, name])
848                            module = __import__(mod_path, globals(),
849                                                locals(), [name])
850                        else:
851                            (file, path, info) = imp.find_module(name, path)
852                            module = imp.load_module(name, file, item, info)
853                        if hasattr(module, "PLUGIN_ID"):
854                            try:
855                                plugins.append(module.Plugin())
856                                msg = "Found plug-in: %s" % module.PLUGIN_ID
857                                logger.info(msg)
858                            except:
859                                msg = "Error accessing PluginPanel"
860                                msg += " in %s\n  %s" % (name, sys.exc_value)
861                                config.printEVT(msg)
862                    except:
863                        msg = "ViewerFrame._find_plugins: %s" % sys.exc_value
864                        logger.error(msg)
865                    finally:
866                        if file is not None:
867                            file.close()
868        except:
869            # Should raise and catch at a higher level and
870            # display error on status bar
871            logger.error(sys.exc_value)
872
873        return plugins
874
875    def _get_panels_size(self, p):
876        """
877        find the proper size of the current panel
878        get the proper panel width and height
879        """
880        self._window_width, self._window_height = self.get_client_size()
881        # Default size
882        if DATAPANEL_WIDTH < 0:
883            panel_width = int(self._window_width * 0.25)
884        else:
885            panel_width = DATAPANEL_WIDTH
886        panel_height = int(self._window_height)
887        if self._data_panel is not None and (p == self._data_panel):
888            return panel_width, panel_height
889        if hasattr(p, "CENTER_PANE") and p.CENTER_PANE:
890            panel_width = self._window_width * 0.45
891            if CONTROL_WIDTH > 0:
892                panel_width = CONTROL_WIDTH
893            if CONTROL_HEIGHT > 0:
894                panel_height = CONTROL_HEIGHT
895            return panel_width, panel_height
896        elif p == self.defaultPanel:
897            return self._window_width, panel_height
898        return panel_width, panel_height
899
900    def _load_panels(self):
901        """
902        Load all panels in the panels directory
903        """
904        # Look for plug-in panels
905        panels = []
906        if wx.VERSION_STRING >= '3.0.0.0':
907            mac_pos_y = 85
908        else:
909            mac_pos_y = 40
910        for item in self.plugins:
911            if hasattr(item, "get_panels"):
912                ps = item.get_panels(self)
913                panels.extend(ps)
914
915        # Set up welcome panel
916        # TODO: this needs serious simplification
917        if self.welcome_panel_class is not None:
918            welcome_panel = MDIFrame(self, None, 'None', (100, 200))
919            self.defaultPanel = self.welcome_panel_class(welcome_panel, -1,
920                                                         style=wx.RAISED_BORDER)
921            welcome_panel.set_panel(self.defaultPanel)
922            self.defaultPanel.set_frame(welcome_panel)
923            welcome_panel.Show(False)
924
925        self.panels["default"] = self.defaultPanel
926        size_t_bar = 70
927        if IS_LINUX:
928            size_t_bar = 115
929        if self.defaultPanel is not None:
930            w, h = self._get_panels_size(self.defaultPanel)
931            frame = self.defaultPanel.get_frame()
932            frame.SetSize((self._window_width, self._window_height))
933            if not IS_WIN:
934                frame.SetPosition((0, mac_pos_y + size_t_bar))
935            frame.Show(True)
936        # add data panel
937        win = MDIFrame(self, None, 'None', (100, 200))
938        data_panel = DataPanel(parent=win, id=-1)
939        win.set_panel(data_panel)
940        self.panels["data_panel"] = data_panel
941        self._data_panel = data_panel
942        d_panel_width, h = self._get_panels_size(self._data_panel)
943        win.SetSize((d_panel_width, h))
944        is_visible = self.__gui_style & \
945                     GUIFRAME.MANAGER_ON == GUIFRAME.MANAGER_ON
946        if IS_WIN:
947            win.SetPosition((0, 0))
948        else:
949            win.SetPosition((0, mac_pos_y + size_t_bar))
950        win.Show(is_visible)
951        # Add the panels to the AUI manager
952        for panel_class in panels:
953            frame = panel_class.get_frame()
954            wx_id = wx.NewId()
955            # Check whether we need to put this panel in the center pane
956            if hasattr(panel_class, "CENTER_PANE") and panel_class.CENTER_PANE:
957                w, h = self._get_panels_size(panel_class)
958                if panel_class.CENTER_PANE:
959                    self.panels[str(wx_id)] = panel_class
960                    _, pos_y = frame.GetPositionTuple()
961                    frame.SetPosition((d_panel_width + 1, pos_y))
962                    frame.SetSize((w, h))
963                    frame.Show(False)
964            elif panel_class == self._data_panel:
965                panel_class.frame.Show(is_visible)
966                continue
967            else:
968                self.panels[str(wx_id)] = panel_class
969                frame.SetSize((w, h))
970                frame.Show(False)
971            if IS_WIN:
972                frame.SetPosition((d_panel_width + 1, 0))
973            else:
974                frame.SetPosition((d_panel_width + 1, mac_pos_y + size_t_bar))
975
976        if not IS_WIN:
977            win_height = mac_pos_y
978            if IS_LINUX:
979                if wx.VERSION_STRING >= '3.0.0.0':
980                    win_height = mac_pos_y + 10
981                else:
982                    win_height = mac_pos_y + 55
983                self.SetMaxSize((-1, win_height))
984            else:
985                self.SetSize((self._window_width, win_height))
986
987    def update_data(self, prev_data, new_data):
988        """
989        Update the data.
990        """
991        prev_id, data_state = self._data_manager.update_data(
992                              prev_data=prev_data, new_data=new_data)
993
994        self._data_panel.remove_by_id(prev_id)
995        self._data_panel.load_data_list(data_state)
996
997    def update_theory(self, data_id, theory, state=None):
998        """
999        Update the theory
1000        """
1001        data_state = self._data_manager.update_theory(data_id=data_id,
1002                                                      theory=theory,
1003                                                      state=state)
1004        wx.CallAfter(self._data_panel.load_data_list, data_state)
1005
1006    def onfreeze(self, theory_id):
1007        """
1008        Saves theory/model and passes to data loader.
1009
1010        ..warning:: This seems to be the exact same code as the next
1011        function called simply freeze. This probably needs fixing
1012        """
1013        data_state_list = self._data_manager.freeze(theory_id)
1014        self._data_panel.load_data_list(list=data_state_list)
1015        for data_state in data_state_list.values():
1016            new_plot = data_state.get_data()
1017
1018            wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1019                                            title=new_plot.title))
1020
1021    def freeze(self, data_id, theory_id):
1022        """
1023        Saves theory/model and passes to data loader.
1024
1025        ..warning:: This seems to be the exact same code as the next
1026        function called simply freeze. This probably needs fixing
1027        """
1028        data_state_list = self._data_manager.freeze_theory(data_id=data_id,
1029                                                           theory_id=theory_id)
1030        self._data_panel.load_data_list(list=data_state_list)
1031        for data_state in data_state_list.values():
1032            new_plot = data_state.get_data()
1033            wx.PostEvent(self, NewPlotEvent(plot=new_plot,
1034                                            title=new_plot.title))
1035
1036    def delete_data(self, data):
1037        """
1038        Delete the data.
1039        """
1040        self._current_perspective.delete_data(data)
1041
1042    def get_context_menu(self, plotpanel=None):
1043        """
1044        Get the context menu items made available
1045        by the different plug-ins.
1046        This function is used by the plotting module
1047        """
1048        if plotpanel is None:
1049            return
1050        menu_list = []
1051        for item in self.plugins:
1052            menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
1053        return menu_list
1054
1055    def get_current_context_menu(self, plotpanel=None):
1056        """
1057        Get the context menu items made available
1058        by the current plug-in.
1059        This function is used by the plotting module
1060        """
1061        if plotpanel is None:
1062            return
1063        menu_list = []
1064        item = self._current_perspective
1065        if item is not None:
1066            menu_list.extend(item.get_context_menu(plotpanel=plotpanel))
1067        return menu_list
1068
1069    def on_panel_close(self, event):
1070        """
1071        Gets called when the close event for a panel runs.
1072        This will check which panel has been closed and
1073        delete it.
1074        """
1075        frame = event.GetEventObject()
1076        for ID in self.plot_panels.keys():
1077            if self.plot_panels[ID].window_name == frame.name:
1078                self.disable_app_menu(self.plot_panels[ID])
1079                self.delete_panel(ID)
1080                break
1081        if self.cpanel_on_focus is not None:
1082            self.cpanel_on_focus.SetFocus()
1083
1084    def popup_panel(self, p):
1085        """
1086        Add a panel object to the AUI manager
1087
1088        :param p: panel object to add to the AUI manager
1089
1090        :returns: ID of the event associated with the new panel [int]
1091
1092        """
1093        ID = wx.NewId()
1094        self.panels[str(ID)] = p
1095        # Check and set the size
1096        if PLOPANEL_WIDTH < 0:
1097            p_panel_width = int(self._window_width * 0.45)
1098        else:
1099            p_panel_width = PLOPANEL_WIDTH
1100        p_panel_height = int(p_panel_width * 0.76)
1101        p.frame.SetSize((p_panel_width, p_panel_height))
1102        self.graph_num += 1
1103        if p.window_caption.split()[0] in NOT_SO_GRAPH_LIST:
1104            windowcaption = p.window_caption
1105        else:
1106            windowcaption = 'Graph'
1107        windowname = p.window_name
1108
1109        # Append nummber
1110        captions = self._get_plotpanel_captions()
1111        # FIXME: Fix this awful loop
1112        while (1):
1113            caption = windowcaption + '%s' % str(self.graph_num)
1114            if caption not in captions:
1115                break
1116            self.graph_num += 1
1117            # protection from forever-loop: max num = 1000
1118            if self.graph_num > 1000:
1119                break
1120        if p.window_caption.split()[0] not in NOT_SO_GRAPH_LIST:
1121            p.window_caption = caption
1122        p.window_name = windowname + str(self.graph_num)
1123
1124        p.frame.SetTitle(p.window_caption)
1125        p.frame.name = p.window_name
1126        if not IS_WIN:
1127            p.frame.Center()
1128            x_pos, _ = p.frame.GetPositionTuple()
1129            p.frame.SetPosition((x_pos, 112))
1130        p.frame.Show(True)
1131
1132        # Register for showing/hiding the panel
1133        wx.EVT_MENU(self, ID, self.on_view)
1134        if p not in self.plot_panels.values() and p.group_id is not None:
1135            self.plot_panels[ID] = p
1136            if len(self.plot_panels) == 1:
1137                self.panel_on_focus = p
1138                self.set_panel_on_focus(None)
1139            if self._data_panel is not None and \
1140                            self._plotting_plugin is not None:
1141                ind = self._data_panel.cb_plotpanel.FindString('None')
1142                if ind != wx.NOT_FOUND:
1143                    self._data_panel.cb_plotpanel.Delete(ind)
1144                if caption not in self._data_panel.cb_plotpanel.GetItems():
1145                    self._data_panel.cb_plotpanel.Append(str(caption), p)
1146        return ID
1147
1148    def _get_plotpanel_captions(self):
1149        """
1150        Get all the plotpanel cations
1151
1152        : return: list of captions
1153        """
1154        captions = []
1155        for Id in self.plot_panels.keys():
1156            captions.append(self.plot_panels[Id].window_caption)
1157
1158        return captions
1159
1160    def _setup_tool_bar(self):
1161        """
1162        add toolbar to the frame
1163        """
1164        self._toolbar = GUIToolBar(self)
1165        # The legacy code doesn't work well for wx 3.0
1166        # but the old code produces better results with wx 2.8
1167        if not IS_WIN and wx.VERSION_STRING >= '3.0.0.0':
1168            sizer = wx.BoxSizer(wx.VERTICAL)
1169            sizer.Add(self._toolbar, 0, wx.EXPAND)
1170            self.SetSizer(sizer)
1171        else:
1172            self.SetToolBar(self._toolbar)
1173        self._update_toolbar_helper()
1174        self._on_toggle_toolbar(event=None)
1175
1176    def _update_toolbar_helper(self):
1177        """
1178        Helping to update the toolbar
1179        """
1180        application_name = 'No Selected Analysis'
1181        panel_name = 'No Panel on Focus'
1182        c_panel = self.cpanel_on_focus
1183        if self._toolbar is None:
1184            return
1185        if c_panel is not None:
1186            self.reset_bookmark_menu(self.cpanel_on_focus)
1187        if self._current_perspective is not None:
1188            application_name = self._current_perspective.sub_menu
1189        c_panel_state = c_panel
1190        if c_panel is not None:
1191            panel_name = c_panel.window_caption
1192            if not c_panel.IsShownOnScreen():
1193                c_panel_state = None
1194        self._toolbar.update_toolbar(c_panel_state)
1195        self._toolbar.update_button(application_name=application_name,
1196                                    panel_name=panel_name)
1197        self._toolbar.Realize()
1198
1199    def _add_menu_tool(self):
1200        """
1201        Tools menu
1202        Go through plug-ins and find tools to populate the tools menu
1203        """
1204        style = self.__gui_style & GUIFRAME.CALCULATOR_ON
1205        if style == GUIFRAME.CALCULATOR_ON:
1206            self._tool_menu = None
1207            for item in self.plugins:
1208                if hasattr(item, "get_tools"):
1209                    for tool in item.get_tools():
1210                        # Only create a menu if we have at least one tool
1211                        if self._tool_menu is None:
1212                            self._tool_menu = wx.Menu()
1213                        if tool[0].lower().count('python') > 0:
1214                            self._tool_menu.AppendSeparator()
1215                        id = wx.NewId()
1216                        self._tool_menu.Append(id, tool[0], tool[1])
1217                        wx.EVT_MENU(self, id, tool[2])
1218            if self._tool_menu is not None:
1219                self._menubar.Append(self._tool_menu, '&Tools')
1220
1221    def _add_current_plugin_menu(self):
1222        """
1223        add current plugin menu
1224        Look for plug-in menus
1225        Add available plug-in sub-menus.
1226        """
1227        if self._menubar is None or self._current_perspective is None \
1228                or self._menubar.GetMenuCount() == 0:
1229            return
1230        # replace or add a new menu for the current plugin
1231        pos = self._menubar.FindMenu(str(self._applications_menu_name))
1232        if pos == -1 and self._applications_menu_pos > 0:
1233            pos = self._applications_menu_pos
1234        if pos != -1:
1235            menu_list = self._current_perspective.populate_menu(self)
1236            if menu_list:
1237                for (menu, name) in menu_list:
1238                    self._menubar.Replace(pos, menu, name)
1239                    self._applications_menu_name = name
1240                self._applications_menu_pos = pos
1241            else:
1242                self._menubar.Remove(pos)
1243                self._applications_menu_name = None
1244                self._applications_menu_pos = -1
1245        else:
1246            menu_list = self._current_perspective.populate_menu(self)
1247            if menu_list:
1248                for (menu, name) in menu_list:
1249                    if self._applications_menu_pos == -1:
1250                        # Find the Analysis position and insert just after it
1251                        analysis_pos = self._menubar.FindMenu("Analysis")
1252                        if analysis_pos == -1:
1253                            self._menubar.Append(menu, name)
1254                            self._applications_menu_pos = -1
1255                        else:
1256                            self._menubar.Insert(analysis_pos+1, menu, name)
1257                            self._applications_menu_pos = analysis_pos + 1
1258                    else:
1259                        self._menubar.Insert(self._applications_menu_pos,
1260                                             menu, name)
1261                    self._applications_menu_name = name
1262
1263    def _on_marketplace_click(self, event):
1264        """
1265            Click event for the help menu item linking to the Marketplace.
1266        """
1267        import webbrowser
1268        webbrowser.open_new(config.marketplace_url)
1269
1270    def _add_help_menu(self):
1271        """
1272        add help menu to menu bar.  Includes welcome page, about page,
1273        tutorial PDF and documentation pages.
1274        """
1275        self._help_menu = wx.Menu()
1276
1277        wx_id = wx.NewId()
1278        self._help_menu.Append(wx_id, '&Documentation', '')
1279        wx.EVT_MENU(self, wx_id, self._onSphinxDocs)
1280
1281        if config._do_tutorial and (IS_WIN or sys.platform == 'darwin'):
1282            wx_id = wx.NewId()
1283            # Pluralised both occurences of 'Tutorial' in the line below
1284            # S King, Sep 2018
1285            self._help_menu.Append(wx_id, '&Tutorials', 'Software tutorials')
1286            wx.EVT_MENU(self, wx_id, self._onTutorial)
1287
1288        if config._do_acknowledge:
1289            wx_id = wx.NewId()
1290            self._help_menu.Append(wx_id, '&Acknowledge',
1291                                   'Acknowledging SasView')
1292            wx.EVT_MENU(self, wx_id, self._onAcknowledge)
1293
1294        if config._do_aboutbox:
1295            logger.info("Doing help menu")
1296            wx_id = wx.NewId()
1297            self._help_menu.Append(wx_id, '&About', 'Software information')
1298            wx.EVT_MENU(self, wx_id, self._onAbout)
1299
1300        if config.marketplace_url:
1301            wx_id = wx.NewId()
1302            self._help_menu.Append(wx_id, '&Model marketplace', '')
1303            wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
1304
1305        # Checking for updates
1306        wx_id = wx.NewId()
1307        self._help_menu.Append(wx_id, '&Check for update',
1308                               'Check for the latest version of %s' %
1309                               config.__appname__)
1310        wx.EVT_MENU(self, wx_id, self._check_update)
1311        self._menubar.Append(self._help_menu, '&Help')
1312
1313    def _add_menu_view(self):
1314        """
1315        add menu items under view menu
1316        """
1317        if not VIEW_MENU:
1318            return
1319        self._view_menu = wx.Menu()
1320
1321        wx_id = wx.NewId()
1322        hint = "Display the Grid Window for batch results etc."
1323        self._view_menu.Append(wx_id, '&Show Grid Window', hint)
1324        wx.EVT_MENU(self, wx_id, self.show_batch_frame)
1325
1326        self._view_menu.AppendSeparator()
1327        style = self.__gui_style & GUIFRAME.MANAGER_ON
1328        wx_id = wx.NewId()
1329        self._data_panel_menu = self._view_menu.Append(wx_id,
1330                                                       '&Show Data Explorer',
1331                                                       '')
1332        wx.EVT_MENU(self, wx_id, self.show_data_panel)
1333        if style == GUIFRAME.MANAGER_ON:
1334            self._data_panel_menu.SetText('Hide Data Explorer')
1335        else:
1336            self._data_panel_menu.SetText('Show Data Explorer')
1337
1338        self._view_menu.AppendSeparator()
1339        wx_id = wx.NewId()
1340        style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
1341        if style1 == GUIFRAME.TOOLBAR_ON:
1342            self._toolbar_menu = self._view_menu.Append(wx_id, '&Hide Toolbar',
1343                                                        '')
1344        else:
1345            self._toolbar_menu = self._view_menu.Append(wx_id, '&Show Toolbar',
1346                                                        '')
1347        wx.EVT_MENU(self, wx_id, self._on_toggle_toolbar)
1348
1349        if custom_config is not None:
1350            self._view_menu.AppendSeparator()
1351            wx_id = wx.NewId()
1352            hint_ss = "Select the current/default configuration "
1353            hint_ss += "as a startup setting"
1354            preference_menu = self._view_menu.Append(wx_id, 'Startup Setting',
1355                                                     hint_ss)
1356            wx.EVT_MENU(self, wx_id, self._on_preference_menu)
1357
1358        wx_id = wx.NewId()
1359        self._view_menu.AppendSeparator()
1360        self._view_menu.Append(wx_id, 'Category Manager',
1361                               'Edit model categories')
1362        wx.EVT_MENU(self, wx_id, self._on_category_manager)
1363
1364        self._menubar.Append(self._view_menu, '&View')
1365
1366    def show_batch_frame(self, event=None):
1367        """
1368        show the grid of result
1369        """
1370        # Show(False) before Show(True) in order to bring it to the front
1371        self.batch_frame.Show(False)
1372        self.batch_frame.Show(True)
1373
1374    def on_category_panel(self, event):
1375        """
1376        On cat panel
1377        """
1378        self._on_category_manager(event)
1379
1380    def _on_category_manager(self, event):
1381        """
1382        Category manager frame
1383        """
1384        frame = CategoryManager(self, -1, 'Model Category Manager')
1385        icon = self.GetIcon()
1386        frame.SetIcon(icon)
1387
1388    def _on_preference_menu(self, event):
1389        """
1390        Build a panel to allow to edit Mask
1391        """
1392        from sas.sasgui.guiframe.startup_configuration \
1393            import StartupConfiguration as ConfDialog
1394
1395        dialog = ConfDialog(parent=self, gui=self.__gui_style)
1396        result = dialog.ShowModal()
1397        if result == wx.ID_OK:
1398            dialog.write_custom_config()
1399            # post event for info
1400            wx.PostEvent(self, StatusEvent(status="Wrote custom configuration",
1401                                           info='info'))
1402        dialog.Destroy()
1403
1404    def _add_menu_application(self):
1405        """
1406        # Attach a menu item for each defined perspective or application.
1407        # Only add the perspective menu if there are more than one perspectives
1408        add menu application
1409        """
1410        if self._num_perspectives > 1:
1411            plug_data_count = False
1412            plug_no_data_count = False
1413            self._applications_menu = wx.Menu()
1414            pos = 0
1415            separator = self._applications_menu.AppendSeparator()
1416            for plug in self.plugins:
1417                if len(plug.get_perspective()) > 0:
1418                    id = wx.NewId()
1419                    if plug.use_data():
1420                        self._applications_menu.InsertCheckItem(pos, id,
1421                                                                plug.sub_menu,
1422                                    "Switch to analysis: %s" % plug.sub_menu)
1423                        plug_data_count = True
1424                        pos += 1
1425                    else:
1426                        plug_no_data_count = True
1427                        self._applications_menu.AppendCheckItem(id,
1428                                                                plug.sub_menu,
1429                            "Switch to analysis: %s" % plug.sub_menu)
1430                    wx.EVT_MENU(self, id, plug.on_perspective)
1431
1432            if not plug_data_count or not plug_no_data_count:
1433                self._applications_menu.RemoveItem(separator)
1434            # Windows introduces a "Window" menu item during the layout process
1435            # somehow.  We want it to be next to the last item with Help as
1436            # last. However Analysis gets stuck after Window in normal ordering
1437            # so force it to be next after the Tools menu item.  Should we add
1438            # another menu item will need to check if this is still where we
1439            # want Analysis.  This is NOT an issue on the Mac which does not
1440            # have the extra Window menu item.
1441            #      March 2016 Code Camp  -- PDB
1442            Tools_pos = self._menubar.FindMenu("Tools")
1443            self._menubar.Insert(Tools_pos+1, self._applications_menu,
1444                                 '&Analysis')
1445            self._check_applications_menu()
1446
1447    def _populate_file_menu(self):
1448        """
1449        Insert menu item under file menu
1450        """
1451        for plugin in self.plugins:
1452            if len(plugin.populate_file_menu()) > 0:
1453                for item in plugin.populate_file_menu():
1454                    m_name, m_hint, m_handler = item
1455                    wx_id = wx.NewId()
1456                    self._file_menu.Append(wx_id, m_name, m_hint)
1457                    wx.EVT_MENU(self, wx_id, m_handler)
1458                self._file_menu.AppendSeparator()
1459
1460        style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1461        if OPEN_SAVE_MENU:
1462            wx_id = wx.NewId()
1463            hint_load_file = "read all analysis states saved previously"
1464            self._save_appl_menu = self._file_menu.Append(wx_id,
1465                                                          '&Open Project',
1466                                                          hint_load_file)
1467            wx.EVT_MENU(self, wx_id, self._on_open_state_project)
1468
1469        if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1470            # some menu of plugin to be seen under file menu
1471            hint_load_file = "Read a status files and load"
1472            hint_load_file += " them into the analysis"
1473            wx_id = wx.NewId()
1474            self._save_appl_menu = self._file_menu.Append(wx_id,
1475                                                          '&Open Analysis',
1476                                                          hint_load_file)
1477            wx.EVT_MENU(self, wx_id, self._on_open_state_application)
1478        if OPEN_SAVE_MENU:
1479            self._file_menu.AppendSeparator()
1480            wx_id = wx.NewId()
1481            self._file_menu.Append(wx_id, '&Save Project',
1482                                   'Save the state of the whole analysis')
1483            wx.EVT_MENU(self, wx_id, self._on_save_project)
1484        if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1485            wx_id = wx.NewId()
1486            txt = '&Save Analysis'
1487            txt2 = 'Save state of the current active analysis panel'
1488            self._save_appl_menu = self._file_menu.Append(wx_id, txt, txt2)
1489            wx.EVT_MENU(self, wx_id, self._on_save_application)
1490        if not sys.platform == 'darwin':
1491            self._file_menu.AppendSeparator()
1492            wx_id = wx.NewId()
1493            self._file_menu.Append(wx_id, '&Quit', 'Exit')
1494            wx.EVT_MENU(self, wx_id, self.Close)
1495
1496    def _add_menu_file(self):
1497        """
1498        add menu file
1499        """
1500        # File menu
1501        self._file_menu = wx.Menu()
1502        # Add sub menus
1503        self._menubar.Append(self._file_menu, '&File')
1504
1505    def _add_menu_edit(self):
1506        """
1507        add menu edit
1508        """
1509        if not EDIT_MENU:
1510            return
1511        # Edit Menu
1512        self._edit_menu = wx.Menu()
1513        self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
1514                               'Undo the previous action')
1515        wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
1516        self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
1517                               'Redo the previous action')
1518        wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
1519        self._edit_menu.AppendSeparator()
1520        self._edit_menu.Append(GUIFRAME_ID.COPY_ID, '&Copy Params',
1521                               'Copy parameter values')
1522        wx.EVT_MENU(self, GUIFRAME_ID.COPY_ID, self.on_copy_panel)
1523        self._edit_menu.Append(GUIFRAME_ID.PASTE_ID, '&Paste Params',
1524                               'Paste parameter values')
1525        wx.EVT_MENU(self, GUIFRAME_ID.PASTE_ID, self.on_paste_panel)
1526
1527        self._edit_menu.AppendSeparator()
1528
1529        self._edit_menu_copyas = wx.Menu()
1530        # Sub menu for Copy As...
1531        self._edit_menu_copyas.Append(GUIFRAME_ID.COPYEX_ID,
1532                                      'Copy current tab to Excel',
1533                                      'Copy parameter values in tabular format')
1534        wx.EVT_MENU(self, GUIFRAME_ID.COPYEX_ID, self.on_copy_panel)
1535
1536        self._edit_menu_copyas.Append(GUIFRAME_ID.COPYLAT_ID,
1537                                      'Copy current tab to LaTeX',
1538                                      'Copy parameter values in tabular format')
1539        wx.EVT_MENU(self, GUIFRAME_ID.COPYLAT_ID, self.on_copy_panel)
1540
1541        self._edit_menu.AppendMenu(GUIFRAME_ID.COPYAS_ID, 'Copy Params as...',
1542                                   self._edit_menu_copyas,
1543                                   'Copy parameter values in various formats')
1544
1545        self._edit_menu.AppendSeparator()
1546
1547        self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report Results',
1548                               'Preview current panel')
1549        wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1550
1551        self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',
1552                               'Reset current panel')
1553        wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1554
1555        self._menubar.Append(self._edit_menu, '&Edit')
1556        self.enable_edit_menu()
1557
1558    def get_style(self):
1559        """
1560        Return the gui style
1561        """
1562        return self.__gui_style
1563
1564    def _add_menu_data(self):
1565        """
1566        Add menu item item data to menu bar
1567        """
1568        if self._data_plugin is not None:
1569            menu_list = self._data_plugin.populate_menu(self)
1570            if menu_list:
1571                for (menu, name) in menu_list:
1572                    self._menubar.Append(menu, name)
1573
1574    def _on_toggle_toolbar(self, event=None):
1575        """
1576        hide or show toolbar
1577        """
1578        if self._toolbar is None:
1579            return
1580        if self._toolbar.IsShown():
1581            if self._toolbar_menu is not None:
1582                self._toolbar_menu.SetItemLabel('Show Toolbar')
1583            self._toolbar.Hide()
1584        else:
1585            if self._toolbar_menu is not None:
1586                self._toolbar_menu.SetItemLabel('Hide Toolbar')
1587            self._toolbar.Show()
1588        self._toolbar.Realize()
1589
1590    def _on_status_event(self, evt):
1591        """
1592        Display status message
1593        """
1594        # This CallAfter fixes many crashes on MAC.
1595        wx.CallAfter(self.sb.set_status, evt)
1596
1597    def on_view(self, evt):
1598        """
1599        A panel was selected to be shown. If it's not already
1600        shown, display it.
1601
1602        :param evt: menu event
1603
1604        """
1605        panel_id = str(evt.GetId())
1606        self.on_set_plot_focus(self.panels[panel_id])
1607        wx.CallLater(5 * TIME_FACTOR, self.set_schedule(True))
1608        self.set_plot_unfocus()
1609
1610    def show_welcome_panel(self, event):
1611        """
1612        Display the welcome panel
1613        """
1614        if self.defaultPanel is None:
1615            return
1616        frame = self.panels['default'].get_frame()
1617        if frame is None:
1618            return
1619        # Show default panel
1620        if not frame.IsShown():
1621            frame.Show(True)
1622
1623    def on_close_welcome_panel(self):
1624        """
1625        Close the welcome panel
1626        """
1627        if self.defaultPanel is None:
1628            return
1629        default_panel = self.panels["default"].frame
1630        if default_panel.IsShown():
1631            default_panel.Show(False)
1632
1633    def delete_panel(self, uid):
1634        """
1635        delete panel given uid
1636        """
1637        ID = str(uid)
1638        config.printEVT("delete_panel: %s" % ID)
1639        if ID in self.panels.keys():
1640            self.panel_on_focus = None
1641            panel = self.panels[ID]
1642
1643            if hasattr(panel, "connect"):
1644                panel.connect.disconnect()
1645            self._plotting_plugin.delete_panel(panel.group_id)
1646
1647            if panel in self.schedule_full_draw_list:
1648                self.schedule_full_draw_list.remove(panel)
1649
1650            # delete uid number not str(uid)
1651            if ID in self.plot_panels.keys():
1652                del self.plot_panels[ID]
1653            if ID in self.panels.keys():
1654                del self.panels[ID]
1655        else:
1656            logger.error("delete_panel: No such plot id as %s" % ID)
1657
1658    def create_gui_data(self, data, path=None):
1659        """
1660        """
1661        return self._data_manager.create_gui_data(data, path)
1662
1663    def get_data(self, path):
1664        """
1665        """
1666        log_msg = ''
1667        basename = os.path.basename(path)
1668        _, extension = os.path.splitext(basename)
1669        if extension.lower() not in EXTENSIONS:
1670            log_msg = "File Loader cannot "
1671            log_msg += "load: %s\n" % str(basename)
1672            log_msg += "Try Data opening...."
1673            logger.error(log_msg)
1674            return
1675
1676        # reading a state file
1677        for plug in self.plugins:
1678            reader, ext = plug.get_extensions()
1679            if reader is not None:
1680                # read the state of the single plugin
1681                if extension == ext:
1682                    reader.read(path)
1683                    return
1684                elif extension == APPLICATION_STATE_EXTENSION:
1685                    try:
1686                        reader.read(path)
1687                    except:
1688                        msg = "DataLoader Error: Encounted Non-ASCII character"
1689                        msg += "\n(%s)" % sys.exc_value
1690                        wx.PostEvent(self, StatusEvent(status=msg,
1691                                                       info="error",
1692                                                       type="stop"))
1693                        return
1694
1695        style = self.__gui_style & GUIFRAME.MANAGER_ON
1696        if style == GUIFRAME.MANAGER_ON:
1697            if self._data_panel is not None:
1698                self._data_panel.frame.Show(True)
1699
1700    def load_from_cmd(self, path):
1701        """
1702        load data from cmd or application
1703        """
1704        if path is None:
1705            return
1706        else:
1707            path = os.path.abspath(path)
1708            if not os.path.isfile(path) and not os.path.isdir(path):
1709                return
1710
1711            if os.path.isdir(path):
1712                self.load_folder(path)
1713                return
1714
1715        basename = os.path.basename(path)
1716        _, extension = os.path.splitext(basename)
1717        if extension.lower() not in EXTENSIONS:
1718            self.load_data(path)
1719        else:
1720            self.load_state(path)
1721
1722        self._default_save_location = os.path.dirname(path)
1723
1724    def load_state(self, path, is_project=False):
1725        """
1726        load data from command line or application
1727        """
1728        if path and (path is not None) and os.path.isfile(path):
1729            basename = os.path.basename(path)
1730            if APPLICATION_STATE_EXTENSION is not None \
1731                    and basename.endswith(APPLICATION_STATE_EXTENSION):
1732                if is_project:
1733                    for ID in self.plot_panels.keys():
1734                        panel = self.plot_panels[ID]
1735                        panel.on_close(None)
1736            self.get_data(path)
1737            wx.PostEvent(self, StatusEvent(status="Completed loading."))
1738        else:
1739            wx.PostEvent(self, StatusEvent(status=" "))
1740
1741    def load_data(self, path):
1742        """
1743        load data from command line
1744        """
1745        if not os.path.isfile(path):
1746            return
1747        basename = os.path.basename(path)
1748        _, extension = os.path.splitext(basename)
1749        if extension.lower() in EXTENSIONS:
1750            log_msg = "Data Loader cannot "
1751            log_msg += "load: %s\n" % str(path)
1752            log_msg += "Try File opening ...."
1753            logger.error(log_msg)
1754            return
1755        log_msg = ''
1756        output = {}
1757        error_message = ""
1758        try:
1759            logger.info("Loading Data...:\n" + str(path) + "\n")
1760            temp = self.loader.load(path)
1761            if temp.__class__.__name__ == "list":
1762                for item in temp:
1763                    data = self.create_gui_data(item, path)
1764                    output[data.id] = data
1765            else:
1766                data = self.create_gui_data(temp, path)
1767                output[data.id] = data
1768
1769            self.add_data(data_list=output)
1770        except:
1771            error_message = "Error while loading"
1772            error_message += " Data from cmd:\n %s\n" % str(path)
1773            error_message += str(sys.exc_value) + "\n"
1774            logger.error(error_message)
1775
1776    def load_folder(self, path):
1777        """
1778        Load entire folder
1779        """
1780        if not os.path.isdir(path):
1781            return
1782        if self._data_plugin is None:
1783            return
1784        try:
1785            if path is not None:
1786                self._default_save_location = os.path.dirname(path)
1787                file_list = self._data_plugin.get_file_path(path)
1788                self._data_plugin.get_data(file_list)
1789            else:
1790                return
1791        except:
1792            error_message = "Error while loading"
1793            error_message += " Data folder from cmd:\n %s\n" % str(path)
1794            error_message += str(sys.exc_value) + "\n"
1795            logger.error(error_message)
1796
1797    def _on_open_state_application(self, event):
1798        """
1799        """
1800        path = None
1801        if self._default_save_location is None:
1802            self._default_save_location = os.getcwd()
1803        wx.PostEvent(self, StatusEvent(status="Loading Analysis file..."))
1804        plug_wlist = self._on_open_state_app_helper()
1805        dlg = wx.FileDialog(self,
1806                            "Choose a file",
1807                            self._default_save_location, "",
1808                            plug_wlist)
1809        if dlg.ShowModal() == wx.ID_OK:
1810            path = dlg.GetPath()
1811            if path is not None:
1812                self._default_save_location = os.path.dirname(path)
1813        dlg.Destroy()
1814        self.load_state(path=path)
1815
1816    def _on_open_state_app_helper(self):
1817        """
1818        Helps '_on_open_state_application()' to find the extension of
1819        the current perspective/application
1820        """
1821        # No current perspective or no extension attr
1822        if self._current_perspective is None:
1823            return PLUGINS_WLIST
1824        try:
1825            # Find the extension of the perspective
1826            # and get that as 1st item in list
1827            ind = None
1828            app_ext = self._current_perspective._extensions
1829            plug_wlist = config.PLUGINS_WLIST
1830            for ext in set(plug_wlist):
1831                if ext.count(app_ext) > 0:
1832                    ind = ext
1833                    break
1834            # Found the extension
1835            if ind is not None:
1836                plug_wlist.remove(ind)
1837                plug_wlist.insert(0, ind)
1838                try:
1839                    plug_wlist = '|'.join(plug_wlist)
1840                except:
1841                    plug_wlist = ''
1842
1843        except:
1844            plug_wlist = PLUGINS_WLIST
1845
1846        return plug_wlist
1847
1848    def _on_open_state_project(self, event):
1849        """
1850        Load in a .svs project file after removing all data from SasView
1851        """
1852        path = None
1853        if self._default_save_location is None:
1854            self._default_save_location = os.getcwd()
1855        msg = "This operation will set remove all data, plots and analyses from"
1856        msg += " SasView before loading the project. Do you wish to continue?"
1857        msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK | wx.CANCEL)
1858        if msg_box.ShowModal() == wx.ID_OK:
1859            self._data_panel.selection_cbox.SetValue('Select all Data')
1860            self._data_panel._on_selection_type(None)
1861            for _, theory_dict in self._data_panel.list_cb_theory.iteritems():
1862                for key, value in theory_dict.iteritems():
1863                    item, _, _ = value
1864                    item.Check(True)
1865
1866            wx.PostEvent(self, StatusEvent(status="Loading Project file..."))
1867            dlg = wx.FileDialog(self, "Choose a file",
1868                                self._default_save_location, "",
1869                                APPLICATION_WLIST)
1870            if dlg.ShowModal() == wx.ID_OK:
1871                path = dlg.GetPath()
1872            if path is not None:
1873                self._default_save_location = os.path.dirname(path)
1874                dlg.Destroy()
1875                # Reset to a base state
1876                self._on_reset_state()
1877                self._data_panel.on_remove(None, False)
1878                # Load the project file
1879                self.load_state(path=path, is_project=True)
1880
1881    def _on_reset_state(self):
1882        """
1883        Resets SasView to its freshly opened state.
1884        :return: None
1885        """
1886        # Reset all plugins to their base state
1887        self._data_panel.set_panel_on_focus()
1888        # Remove all loaded data
1889        for plugin in self.plugins:
1890            plugin.clear_panel()
1891        # Reset plot number to 0
1892        self.graph_num = 0
1893
1894    def _on_save_application(self, event):
1895        """
1896        save the state of the current active application
1897        """
1898        if self.cpanel_on_focus is not None:
1899            try:
1900                wx.PostEvent(self,
1901                             StatusEvent(status="Saving Analysis file..."))
1902                self.cpanel_on_focus.on_save(event)
1903                wx.PostEvent(self,
1904                             StatusEvent(status="Completed saving."))
1905            except Exception:
1906                msg = "Error occurred while saving: "
1907                msg += traceback.format_exc()
1908                msg += "To save, the application panel should have a data set.."
1909                wx.PostEvent(self, StatusEvent(status=msg))
1910
1911    def _on_save_project(self, event):
1912        """
1913        save the state of the SasView as *.svs
1914        """
1915        if self._current_perspective is None:
1916            return
1917        wx.PostEvent(self, StatusEvent(status="Saving Project file..."))
1918        path = None
1919        extension = '*' + APPLICATION_STATE_EXTENSION
1920        dlg = wx.FileDialog(self, "Save Project file",
1921                            self._default_save_location, "sasview_proj",
1922                            extension,
1923                            wx.SAVE)
1924        if dlg.ShowModal() == wx.ID_OK:
1925            path = dlg.GetPath()
1926            self._default_save_location = os.path.dirname(path)
1927        else:
1928            return None
1929        dlg.Destroy()
1930        try:
1931            if path is None:
1932                return
1933            # default cansas xml doc
1934            doc = None
1935            for panel in self.panels.values():
1936                temp = panel.save_project(doc)
1937                if temp is not None:
1938                    doc = temp
1939
1940            # Write the XML document
1941            extens = APPLICATION_STATE_EXTENSION
1942            fName = os.path.splitext(path)[0] + extens
1943            if doc is not None:
1944                fd = open(fName, 'w')
1945                fd.write(doc.toprettyxml())
1946                fd.close()
1947                wx.PostEvent(self, StatusEvent(status="Completed Saving."))
1948            else:
1949                msg = "Error occurred while saving the project: "
1950                msg += "To save, at least one application panel "
1951                msg += "should have a data set "
1952                msg += "and model selected. "
1953                msg += "No project was saved to %s" % (str(path))
1954                logger.warning(msg)
1955                wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1956        except Exception:
1957            msg = "Error occurred while saving: "
1958            msg += traceback.format_exc()
1959            msg += "To save, at least one application panel "
1960            msg += "should have a data set.."
1961            wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1962
1963    def on_save_helper(self, doc, reader, panel, path):
1964        """
1965        Save state into a file
1966        """
1967        if reader is not None:
1968            # case of a panel with multi-pages
1969            if hasattr(panel, "opened_pages"):
1970                for _, page in panel.opened_pages.iteritems():
1971                    data = page.get_data()
1972                    # state must be cloned
1973                    state = page.get_state().clone()
1974                    if data is not None:
1975                        new_doc = reader.write_toXML(data, state)
1976                        if doc is not None and hasattr(doc, "firstChild"):
1977                            child = new_doc.firstChild.firstChild
1978                            doc.firstChild.appendChild(child)
1979                        else:
1980                            doc = new_doc
1981            # case of only a panel
1982            else:
1983                data = panel.get_data()
1984                state = panel.get_state()
1985                if data is not None:
1986                    new_doc = reader.write_toXML(data, state)
1987                    if doc is not None and hasattr(doc, "firstChild"):
1988                        child = new_doc.firstChild.firstChild
1989                        doc.firstChild.appendChild(child)
1990                    else:
1991                        doc = new_doc
1992        return doc
1993
1994    def quit_guiframe(self):
1995        """
1996        Pop up message to make sure the user wants to quit the application
1997        """
1998        message = "\nDo you really want to exit this application?        \n\n"
1999        dial = wx.MessageDialog(self, message, 'Confirm Exit',
2000                                wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION)
2001        if dial.ShowModal() == wx.ID_YES:
2002            return True
2003        else:
2004            return False
2005
2006    def WindowClose(self, event=None):
2007        """
2008        Quit the application from x icon
2009        """
2010        flag = self.quit_guiframe()
2011        if flag:
2012            _pylab_helpers.Gcf.figs = {}
2013            self.Close()
2014
2015    def Close(self, event=None):
2016        """
2017        Quit the application
2018        """
2019        #IF SAS_OPENCL is set, settings are stored in the custom config file
2020        self._write_opencl_config_file()
2021        logger.info(" --- SasView session was closed --- \n")
2022        wx.Exit()
2023        sys.exit()
2024
2025    def _write_opencl_config_file(self):
2026        """
2027        Writes OpenCL settings to custom config file, so they can be remmbered
2028        from session to session
2029        """
2030        if custom_config is not None:
2031            sas_opencl = os.environ.get("SAS_OPENCL")
2032            new_config_lines = []
2033            config_file = open(custom_config.__file__)
2034            config_lines = config_file.readlines()
2035            for line in config_lines:
2036                if "SAS_OPENCL" in line:
2037                    if sas_opencl:
2038                        new_config_lines.append("SAS_OPENCL = \"" + sas_opencl
2039                                                + "\"\n")
2040                    else:
2041                        new_config_lines.append("SAS_OPENCL = \"None\"\n")
2042                else:
2043                    new_config_lines.append(line)
2044            config_file.close()
2045
2046            #If custom_config is None, settings will not be remmbered
2047            new_config_file = open(custom_config.__file__,"w")
2048            new_config_file.writelines(new_config_lines)
2049            new_config_file.close()
2050        else:
2051            logger.info("Failed to save OPENCL settings in custom config file")
2052
2053
2054    def _check_update(self, event=None):
2055        """
2056        Check with the deployment server whether a new version
2057        of the application is available.
2058        A thread is started for the connecting with the server. The thread calls
2059        a call-back method when the current version number has been obtained.
2060        """
2061        version_info = {"version": "0.0.0"}
2062        c = Connection(config.__update_URL__, config.UPDATE_TIMEOUT)
2063        response = c.connect()
2064        if response is not None:
2065            try:
2066                content = response.read().strip()
2067                logger.info("Connected to www.sasview.org. Latest version: %s", content)
2068                version_info = json.loads(content)
2069            except:
2070                logger.info("Failed to connect to www.sasview.org")
2071        self._process_version(version_info, standalone=event is None)
2072
2073
2074    def _process_version(self, version_info, standalone=True):
2075        """
2076        Call-back method for the process of checking for updates.
2077        This methods is called by a VersionThread object once the current
2078        version number has been obtained. If the check is being done in the
2079        background, the user will not be notified unless there's an update.
2080
2081        :param version: version string
2082        :param standalone: True of the update is being checked in
2083           the background, False otherwise.
2084
2085        """
2086        try:
2087            version = version_info["version"]
2088            if version == "0.0.0":
2089                msg = "Could not connect to the application server."
2090                msg += " Please try again later."
2091                self.SetStatusText(msg)
2092            elif cmp(version, config.__version__) > 0:
2093                msg = "Version %s is available! " % str(version)
2094                if not standalone:
2095                    import webbrowser
2096                    if "download_url" in version_info:
2097                        webbrowser.open(version_info["download_url"])
2098                    else:
2099                        webbrowser.open(config.__download_page__)
2100                else:
2101                    msg += "See the help menu to download it."
2102                self.SetStatusText(msg)
2103            else:
2104                if not standalone:
2105                    msg = "You have the latest version"
2106                    msg += " of %s" % str(config.__appname__)
2107                    self.SetStatusText(msg)
2108        except:
2109            msg = "guiframe: could not get latest application"
2110            msg += " version number\n  %s" % sys.exc_value
2111            logger.error(msg)
2112            if not standalone:
2113                msg = "Could not connect to the application server."
2114                msg += " Please try again later."
2115                self.SetStatusText(msg)
2116
2117    def _onAcknowledge(self, evt):
2118        """
2119        Pop up the acknowledge dialog
2120
2121        :param evt: menu event
2122
2123        """
2124        if config._do_acknowledge:
2125            import sas.sasgui.guiframe.acknowledgebox as AcknowledgeBox
2126            dialog = AcknowledgeBox.DialogAcknowledge(None, -1, "")
2127            dialog.ShowModal()
2128
2129    def _onAbout(self, evt):
2130        """
2131        Pop up the about dialog
2132
2133        :param evt: menu event
2134
2135        """
2136        if config._do_aboutbox:
2137            import sas.sasgui.guiframe.aboutbox as AboutBox
2138            dialog = AboutBox.DialogAbout(None, -1, "")
2139            dialog.ShowModal()
2140
2141    def _onTutorial(self, evt):
2142        """
2143        Pop up the tutorial dialog
2144
2145        :param evt: menu event
2146
2147        """
2148        # Action changed from that in 2.x/3.x/4.0.x/4.1.x
2149        # Help >> Tutorial used to bring up a pdf of the
2150        # original 2.x tutorial.
2151        # Code below, implemented from 4.2.0, redirects
2152        # action to the Tutorials page of the help
2153        # documentation to give access to all available
2154        # tutorials
2155        # S King, Sep 2018
2156
2157        from documentation_window import DocumentationWindow
2158        _TreeLocation = "user/tutorial.html"
2159        DocumentationWindow(self, -1, _TreeLocation, "",
2160                            "SasView Documentation")
2161
2162    def _onSphinxDocs(self, evt):
2163        """
2164        Bring up Sphinx Documentation at top level whenever the menu item
2165        'documentation' is clicked. Calls DocumentationWindow with the top
2166        level path of "index.html"
2167
2168        :param evt: menu event
2169        """
2170        # Running SasView "in-place" using run.py means the docs will be in a
2171        # different place than they would otherwise.
2172        from documentation_window import DocumentationWindow
2173        _TreeLocation = "user/user.html"
2174        DocumentationWindow(self, -1, _TreeLocation, "",
2175                            "SasView Documentation")
2176
2177    def set_manager(self, manager):
2178        """
2179        Sets the application manager for this frame
2180
2181        :param manager: frame manager
2182        """
2183        self.app_manager = manager
2184
2185    def post_init(self):
2186        """
2187        This initialization method is called after the GUI
2188        has been created and all plug-ins loaded. It calls
2189        the post_init() method of each plug-in (if it exists)
2190        so that final initialization can be done.
2191        """
2192        for item in self.plugins:
2193            if hasattr(item, "post_init"):
2194                item.post_init()
2195
2196    def set_perspective(self, panels):
2197        """
2198        Sets the perspective of the GUI.
2199        Opens all the panels in the list, and closes
2200        all the others.
2201
2202        :param panels: list of panels
2203        """
2204        for item in self.panels.keys():
2205            # Check whether this is a sticky panel
2206            if hasattr(self.panels[item], "ALWAYS_ON"):
2207                if self.panels[item].ALWAYS_ON:
2208                    continue
2209            if self.panels[item] is None:
2210                continue
2211            if self.panels[item].window_name in panels:
2212                frame = self.panels[item].get_frame()
2213                if not frame.IsShown():
2214                    frame.Show(True)
2215            else:
2216                # always show the data panel if enable
2217                style = self.__gui_style & GUIFRAME.MANAGER_ON
2218                if (style == GUIFRAME.MANAGER_ON) \
2219                        and self.panels[item] == self._data_panel:
2220                    if 'data_panel' in self.panels.keys():
2221                        frame = self.panels['data_panel'].get_frame()
2222                        if frame is None:
2223                            continue
2224                        flag = frame.IsShown()
2225                        frame.Show(flag)
2226                else:
2227                    frame = self.panels[item].get_frame()
2228                    if frame is None:
2229                        continue
2230
2231                    if frame.IsShown():
2232                        frame.Show(False)
2233
2234    def show_data_panel(self, event=None, action=True):
2235        """
2236        show the data panel
2237        """
2238        if self._data_panel_menu is None:
2239            return
2240        label = self._data_panel_menu.GetText()
2241        pane = self.panels["data_panel"]
2242        frame = pane.get_frame()
2243        if label == 'Show Data Explorer':
2244            if action:
2245                frame.Show(True)
2246            self.__gui_style = self.__gui_style | GUIFRAME.MANAGER_ON
2247            self._data_panel_menu.SetText('Hide Data Explorer')
2248        else:
2249            if action:
2250                frame.Show(False)
2251            self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
2252            self._data_panel_menu.SetText('Show Data Explorer')
2253
2254    def add_data_helper(self, data_list):
2255        """
2256        """
2257        if self._data_manager is not None:
2258            self._data_manager.add_data(data_list)
2259
2260    def add_data(self, data_list):
2261        """
2262        receive a dictionary of data from loader
2263        store them its data manager if possible
2264        send to data the current active perspective if the data panel
2265        is not active.
2266        :param data_list: dictionary of data's ID and value Data
2267        """
2268        # Store data into manager
2269        self.add_data_helper(data_list)
2270        # set data in the data panel
2271        if self._data_panel is not None:
2272            data_state = self._data_manager.get_data_state(data_list.keys())
2273            self._data_panel.load_data_list(data_state)
2274        # if the data panel is shown wait for the user to press a button
2275        # to send data to the current perspective. if the panel is not
2276        # show  automatically send the data to the current perspective
2277        style = self.__gui_style & GUIFRAME.MANAGER_ON
2278        if style == GUIFRAME.MANAGER_ON:
2279            # wait for button press from the data panel to set_data
2280            if self._data_panel is not None:
2281                self._data_panel.frame.Show(True)
2282        else:
2283            # automatically send that to the current perspective
2284            self.set_data(data_id=data_list.keys())
2285
2286    def set_data(self, data_id, theory_id=None):
2287        """
2288        set data to current perspective
2289        """
2290        list_data, _ = self._data_manager.get_by_id(data_id)
2291        if self._current_perspective is not None:
2292            self._current_perspective.set_data(list_data.values())
2293
2294        else:
2295            msg = "Guiframe does not have a current perspective"
2296            logger.info(msg)
2297
2298    def set_theory(self, state_id, theory_id=None):
2299        """
2300        """
2301        _, list_theory = self._data_manager.get_by_id(theory_id)
2302        if self._current_perspective is not None:
2303            try:
2304                self._current_perspective.set_theory(list_theory.values())
2305            except:
2306                msg = "Guiframe set_theory: \n" + str(sys.exc_value)
2307                logger.info(msg)
2308                wx.PostEvent(self, StatusEvent(status=msg, info="error"))
2309        else:
2310            msg = "Guiframe does not have a current perspective"
2311            logger.info(msg)
2312
2313    def plot_data(self, state_id, data_id=None,
2314                  theory_id=None, append=False):
2315        """
2316        send a list of data to plot
2317        """
2318        data_list, _ = self._data_manager.get_by_id(data_id)
2319        _, temp_list_theory = self._data_manager.get_by_id(theory_id)
2320        total_plot_list = data_list.values()
2321        for item in temp_list_theory.values():
2322            theory_data, theory_state = item
2323            total_plot_list.append(theory_data)
2324        GROUP_ID = wx.NewId()
2325        for new_plot in total_plot_list:
2326            if append:
2327                if self.panel_on_focus is None:
2328                    message = "cannot append plot. No plot panel on focus!"
2329                    message += "please click on any available plot to set focus"
2330                    wx.PostEvent(self, StatusEvent(status=message,
2331                                                   info='warning'))
2332                    return
2333                else:
2334                    if self.enable_add_data(new_plot):
2335                        new_plot.group_id = self.panel_on_focus.group_id
2336                    else:
2337                        message = "Only 1D Data can be append to"
2338                        message += " plot panel containing 1D data.\n"
2339                        message += "%s not be appended.\n" % str(new_plot.name)
2340                        message += "try new plot option.\n"
2341                        wx.PostEvent(self, StatusEvent(status=message,
2342                                                       info='warning'))
2343            else:
2344                # if not append then new plot
2345                from sas.sasgui.guiframe.dataFitting import Data2D
2346                if issubclass(Data2D, new_plot.__class__):
2347                    # for 2 D always plot in a separated new plot
2348                    new_plot.group_id = wx.NewId()
2349                else:
2350                    # plot all 1D in a new plot
2351                    new_plot.group_id = GROUP_ID
2352            title = "PLOT " + str(new_plot.title)
2353            wx.PostEvent(self, NewPlotEvent(plot=new_plot,
2354                                            title=title,
2355                                            group_id=new_plot.group_id))
2356
2357    def remove_data(self, data_id, theory_id=None):
2358        """
2359        Delete data state if data_id is provide
2360        delete theory created with data of id data_id if theory_id is provide
2361        if delete all true: delete the all state
2362        else delete theory
2363        """
2364        temp = data_id + theory_id
2365        for plug in self.plugins:
2366            plug.delete_data(temp)
2367        data_list, _ = self._data_manager.get_by_id(data_id)
2368        _, temp_list_theory = self._data_manager.get_by_id(theory_id)
2369        total_plot_list = data_list.values()
2370        for item in temp_list_theory.values():
2371            theory_data, theory_state = item
2372            total_plot_list.append(theory_data)
2373        for new_plot in total_plot_list:
2374            for group_id in new_plot.list_group_id:
2375                wx.PostEvent(self, NewPlotEvent(id=new_plot.id,
2376                                                group_id=group_id,
2377                                                action='remove'))
2378                wx.CallAfter(self._remove_res_plot, new_plot.id)
2379        self._data_manager.delete_data(data_id=data_id,
2380                                       theory_id=theory_id)
2381
2382    def _remove_res_plot(self, id):
2383        """
2384        Try to remove corresponding res plot
2385
2386        : param id: id of the data
2387        """
2388        try:
2389            wx.PostEvent(self, NewPlotEvent(id=("res" + str(id)),
2390                                            group_id=("res" + str(id)),
2391                                            action='remove'))
2392        except:
2393            logger.error(sys.exc_value)
2394
2395    def save_data1d(self, data, fname):
2396        """
2397        Save data dialog
2398        """
2399        default_name = fname
2400        wildcard = "Text files (*.txt)|*.txt|"\
2401                    "CanSAS 1D files(*.xml)|*.xml"
2402        path = None
2403        dlg = wx.FileDialog(self, "Choose a file",
2404                            self._default_save_location,
2405                            default_name, wildcard, wx.SAVE)
2406
2407        if dlg.ShowModal() == wx.ID_OK:
2408            path = dlg.GetPath()
2409            # ext_num = 0 for .txt, ext_num = 1 for .xml
2410            # This is MAC Fix
2411            ext_num = dlg.GetFilterIndex()
2412            if ext_num == 0:
2413                ext_format = '.txt'
2414            else:
2415                ext_format = '.xml'
2416            path = os.path.splitext(path)[0] + ext_format
2417            mypath = os.path.basename(path)
2418
2419            # Instantiate a loader
2420            loader = Loader()
2421            ext_format = ".txt"
2422            if os.path.splitext(mypath)[1].lower() == ext_format:
2423                # Make sure the ext included in the file name
2424                # especially on MAC
2425                fName = os.path.splitext(path)[0] + ext_format
2426                self._onsaveTXT(data, fName)
2427            ext_format = ".xml"
2428            if os.path.splitext(mypath)[1].lower() == ext_format:
2429                # Make sure the ext included in the file name
2430                # especially on MAC
2431                fName = os.path.splitext(path)[0] + ext_format
2432                loader.save(fName, data, ext_format)
2433            try:
2434                self._default_save_location = os.path.dirname(path)
2435            except:
2436                pass
2437        dlg.Destroy()
2438
2439    def _onsaveTXT(self, data, path):
2440        """
2441        Save file as txt
2442
2443        .. todo:: Refactor and remove this method. See 'TODO' in _onSave.
2444        """
2445        if path is not None:
2446            out = open(path, 'w')
2447            has_errors = True
2448            if data.dy is None or data.dy == []:
2449                has_errors = False
2450            # Sanity check
2451            if has_errors:
2452                try:
2453                    if len(data.y) != len(data.dy):
2454                        has_errors = False
2455                except:
2456                    has_errors = False
2457            if has_errors:
2458                if data.dx is not None and data.dx != []:
2459                    out.write("<X>   <Y>   <dY>   <dX>\n")
2460                else:
2461                    out.write("<X>   <Y>   <dY>\n")
2462            else:
2463                out.write("<X>   <Y>\n")
2464
2465            for i in range(len(data.x)):
2466                if has_errors:
2467                    if data.dx is not None and data.dx != []:
2468                        if data.dx[i] is not None:
2469                            out.write("%g  %g  %g  %g\n" % (data.x[i],
2470                                                            data.y[i],
2471                                                            data.dy[i],
2472                                                            data.dx[i]))
2473                        else:
2474                            out.write("%g  %g  %g\n" % (data.x[i],
2475                                                        data.y[i],
2476                                                        data.dy[i]))
2477                    else:
2478                        out.write("%g  %g  %g\n" % (data.x[i],
2479                                                    data.y[i],
2480                                                    data.dy[i]))
2481                else:
2482                    out.write("%g  %g\n" % (data.x[i],
2483                                            data.y[i]))
2484            out.close()
2485
2486    def show_data1d(self, data, name):
2487        """
2488        Show data dialog
2489        """
2490        try:
2491            xmin = min(data.x)
2492            ymin = min(data.y)
2493        except:
2494            msg = "Unable to find min/max of \n data named %s" % \
2495                        data.filename
2496            wx.PostEvent(self, StatusEvent(status=msg,
2497                                           info="error"))
2498            raise ValueError, msg
2499        # text = str(data)
2500        text = data.__str__()
2501        text += 'Data Min Max:\n'
2502        text += 'X_min = %s:  X_max = %s\n' % (xmin, max(data.x))
2503        text += 'Y_min = %s:  Y_max = %s\n' % (ymin, max(data.y))
2504        if data.dy is not None:
2505            text += 'dY_min = %s:  dY_max = %s\n' % (min(data.dy), max(data.dy))
2506        text += '\nData Points:\n'
2507        x_st = "X"
2508        for index in range(len(data.x)):
2509            if data.dy is not None and len(data.dy) > index:
2510                dy_val = data.dy[index]
2511            else:
2512                dy_val = 0.0
2513            if data.dx is not None and len(data.dx) > index:
2514                dx_val = data.dx[index]
2515            else:
2516                dx_val = 0.0
2517            if data.dxl is not None and len(data.dxl) > index:
2518                if index == 0:
2519                    x_st = "Xl"
2520                dx_val = data.dxl[index]
2521            elif data.dxw is not None and len(data.dxw) > index:
2522                if index == 0:
2523                    x_st = "Xw"
2524                dx_val = data.dxw[index]
2525
2526            if index == 0:
2527                text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st
2528            text += "%s \t%s \t%s \t%s \t%s\n" % (index,
2529                                                  data.x[index],
2530                                                  data.y[index],
2531                                                  dy_val,
2532                                                  dx_val)
2533        from pdfview import TextFrame
2534        frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2535        # put icon
2536        self.put_icon(frame)
2537        frame.Show(True)
2538
2539    def save_data2d(self, data, fname):
2540        """
2541        Save data2d dialog
2542        """
2543        default_name = fname
2544        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT"
2545        dlg = wx.FileDialog(self, "Choose a file",
2546                            self._default_save_location,
2547                            default_name, wildcard, wx.SAVE)
2548
2549        if dlg.ShowModal() == wx.ID_OK:
2550            path = dlg.GetPath()
2551            # ext_num = 0 for .txt, ext_num = 1 for .xml
2552            # This is MAC Fix
2553            ext_num = dlg.GetFilterIndex()
2554            if ext_num == 0:
2555                ext_format = '.dat'
2556            else:
2557                ext_format = ''
2558            path = os.path.splitext(path)[0] + ext_format
2559            mypath = os.path.basename(path)
2560
2561            # Instantiate a loader
2562            loader = Loader()
2563
2564            ext_format = ".dat"
2565            if os.path.splitext(mypath)[1].lower() == ext_format:
2566                # Make sure the ext included in the file name
2567                # especially on MAC
2568                fileName = os.path.splitext(path)[0] + ext_format
2569                loader.save(fileName, data, ext_format)
2570            try:
2571                self._default_save_location = os.path.dirname(path)
2572            except:
2573                pass
2574        dlg.Destroy()
2575
2576    def show_data2d(self, data, name):
2577        """
2578        Show data dialog
2579        """
2580        wx.PostEvent(self, StatusEvent(status="Gathering Data2D Info.",
2581                                       type='start'))
2582        text = data.__str__()
2583        text += 'Data Min Max:\n'
2584        text += 'I_min = %s\n' % min(data.data)
2585        text += 'I_max = %s\n\n' % max(data.data)
2586        text += 'Data (First 2501) Points:\n'
2587        text += 'Data columns include err(I).\n'
2588        text += 'ASCII data starts here.\n'
2589        text += "<index> \t<Qx> \t<Qy> \t<I> \t<dI> \t<dQparal> \t<dQperp>\n"
2590        di_val = 0.0
2591        dx_val = 0.0
2592        dy_val = 0.0
2593        len_data = len(data.qx_data)
2594        for index in xrange(0, len_data):
2595            x_val = data.qx_data[index]
2596            y_val = data.qy_data[index]
2597            i_val = data.data[index]
2598            if data.err_data is not None:
2599                di_val = data.err_data[index]
2600            if data.dqx_data is not None:
2601                dx_val = data.dqx_data[index]
2602            if data.dqy_data is not None:
2603                dy_val = data.dqy_data[index]
2604
2605            text += "%s \t%s \t%s \t%s \t%s \t%s \t%s\n" % (index,
2606                                                            x_val,
2607                                                            y_val,
2608                                                            i_val,
2609                                                            di_val,
2610                                                            dx_val,
2611                                                            dy_val)
2612            # Takes too long time for typical data2d: Break here
2613            if index >= 2500:
2614                text += ".............\n"
2615                break
2616
2617        from pdfview import TextFrame
2618        frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2619        # put icon
2620        self.put_icon(frame)
2621        frame.Show(True)
2622        wx.PostEvent(self, StatusEvent(status="Data2D Info Displayed",
2623                                       type='stop'))
2624
2625    def set_current_perspective(self, perspective):
2626        """
2627        set the current active perspective
2628        """
2629        self._current_perspective = perspective
2630        name = "No current analysis selected"
2631        if self._current_perspective is not None:
2632            self._add_current_plugin_menu()
2633            for panel in self.panels.values():
2634                if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
2635                    for name in self._current_perspective.get_perspective():
2636                        frame = panel.get_frame()
2637                        if frame is not None:
2638                            if name == panel.window_name:
2639                                panel.on_set_focus(event=None)
2640                                frame.Show(True)
2641                            else:
2642                                frame.Show(False)
2643            name = self._current_perspective.sub_menu
2644            if self._data_panel is not None:
2645                self._data_panel.set_active_perspective(name)
2646                self._check_applications_menu()
2647            # Set the SasView title
2648            self._set_title_name(name)
2649
2650    def _set_title_name(self, name):
2651        """
2652        Set the SasView title w/ the current application name
2653
2654        : param name: application name [string]
2655        """
2656        # Set SanView Window title w/ application anme
2657        title = self.title + "  - " + name + " -"
2658        self.SetTitle(title)
2659
2660    def _check_applications_menu(self):
2661        """
2662        check the menu of the current application
2663        """
2664        if self._applications_menu is not None:
2665            for menu in self._applications_menu.GetMenuItems():
2666                if self._current_perspective is not None:
2667                    name = self._current_perspective.sub_menu
2668                    if menu.IsCheckable():
2669                        if menu.GetLabel() == name:
2670                            menu.Check(True)
2671                        else:
2672                            menu.Check(False)
2673
2674    def enable_add_data(self, new_plot):
2675        """
2676        Enable append data on a plot panel
2677        """
2678
2679        if self.panel_on_focus \
2680                not in self._plotting_plugin.plot_panels.values():
2681            return
2682        check = "Theory1D"
2683        is_theory = len(self.panel_on_focus.plots) <= 1 and \
2684            self.panel_on_focus.plots.values()[0].__class__.__name__ == check
2685
2686        is_data2d = hasattr(new_plot, 'data')
2687
2688        is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2689            and self.panel_on_focus.group_id is not None
2690        has_meta_data = hasattr(new_plot, 'meta_data')
2691
2692        # disable_add_data if the data is being recovered from  a saved state
2693        is_state_data = False
2694        if has_meta_data:
2695            if 'invstate' in new_plot.meta_data:
2696                is_state_data = True
2697            if 'prstate' in new_plot.meta_data:
2698                is_state_data = True
2699            if 'fitstate' in new_plot.meta_data:
2700                is_state_data = True
2701
2702        return is_data1d and not is_data2d and not is_theory \
2703               and not is_state_data
2704
2705    def check_multimode(self, perspective=None):
2706        """
2707        Check the perspective have batch mode capablitity
2708        """
2709        if perspective is None or self._data_panel is None:
2710            return
2711        flag = perspective.get_batch_capable()
2712        flag_on = perspective.batch_on
2713        if flag:
2714            self._data_panel.rb_single_mode.SetValue(not flag_on)
2715            self._data_panel.rb_batch_mode.SetValue(flag_on)
2716        else:
2717            self._data_panel.rb_single_mode.SetValue(True)
2718            self._data_panel.rb_batch_mode.SetValue(False)
2719        self._data_panel.rb_single_mode.Enable(flag)
2720        self._data_panel.rb_batch_mode.Enable(flag)
2721
2722    def enable_edit_menu(self):
2723        """
2724        enable menu item under edit menu depending on the panel on focus
2725        """
2726        if self.cpanel_on_focus is not None and self._edit_menu is not None:
2727            flag = self.cpanel_on_focus.get_undo_flag()
2728            self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2729            flag = self.cpanel_on_focus.get_redo_flag()
2730            self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2731            flag = self.cpanel_on_focus.get_copy_flag()
2732            self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2733            flag = self.cpanel_on_focus.get_paste_flag()
2734            self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2735
2736            # Copy menu
2737            flag = self.cpanel_on_focus.get_copy_flag()
2738            self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYEX_ID, flag)
2739            self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYLAT_ID, flag)
2740
2741            flag = self.cpanel_on_focus.get_preview_flag()
2742            self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2743            flag = self.cpanel_on_focus.get_reset_flag()
2744            self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2745        else:
2746            flag = False
2747            self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2748            self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2749            self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2750            self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2751            self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2752            self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2753
2754    def on_undo_panel(self, event=None):
2755        """
2756        undo previous action of the last panel on focus if possible
2757        """
2758        if self.cpanel_on_focus is not None:
2759            self.cpanel_on_focus.on_undo(event)
2760
2761    def on_redo_panel(self, event=None):
2762        """
2763        redo the last cancel action done on the last panel on focus
2764        """
2765        if self.cpanel_on_focus is not None:
2766            self.cpanel_on_focus.on_redo(event)
2767
2768    def on_copy_panel(self, event=None):
2769        """
2770        copy the last panel on focus if possible
2771        """
2772        if self.cpanel_on_focus is not None:
2773            self.cpanel_on_focus.on_copy(event)
2774
2775    def on_paste_panel(self, event=None):
2776        """
2777        paste clipboard to the last panel on focus
2778        """
2779        if self.cpanel_on_focus is not None:
2780            self.cpanel_on_focus.on_paste(event)
2781
2782    def on_bookmark_panel(self, event=None):
2783        """
2784        bookmark panel
2785        """
2786        if self.cpanel_on_focus is not None:
2787            self.cpanel_on_focus.on_bookmark(event)
2788
2789    def append_bookmark(self, event=None):
2790        """
2791        Bookmark available information of the panel on focus
2792        """
2793        self._toolbar.append_bookmark(event)
2794
2795    def on_save_panel(self, event=None):
2796        """
2797        save possible information on the current panel
2798        """
2799        if self.cpanel_on_focus is not None:
2800            self.cpanel_on_focus.on_save(event)
2801
2802    def on_preview_panel(self, event=None):
2803        """
2804        preview information on the panel on focus
2805        """
2806        if self.cpanel_on_focus is not None:
2807            self.cpanel_on_focus.on_preview(event)
2808
2809    def on_print_panel(self, event=None):
2810        """
2811        print available information on the last panel on focus
2812        """
2813        if self.cpanel_on_focus is not None:
2814            self.cpanel_on_focus.on_print(event)
2815
2816    def on_zoom_panel(self, event=None):
2817        """
2818        zoom on the current panel if possible
2819        """
2820        if self.cpanel_on_focus is not None:
2821            self.cpanel_on_focus.on_zoom(event)
2822
2823    def on_zoom_in_panel(self, event=None):
2824        """
2825        zoom in of the panel on focus
2826        """
2827        if self.cpanel_on_focus is not None:
2828            self.cpanel_on_focus.on_zoom_in(event)
2829
2830    def on_zoom_out_panel(self, event=None):
2831        """
2832        zoom out on the panel on focus
2833        """
2834        if self.cpanel_on_focus is not None:
2835            self.cpanel_on_focus.on_zoom_out(event)
2836
2837    def on_drag_panel(self, event=None):
2838        """
2839        drag apply to the panel on focus
2840        """
2841        if self.cpanel_on_focus is not None:
2842            self.cpanel_on_focus.on_drag(event)
2843
2844    def on_reset_panel(self, event=None):
2845        """
2846        reset the current panel
2847        """
2848        if self.cpanel_on_focus is not None:
2849            self.cpanel_on_focus.on_reset(event)
2850
2851    def on_change_caption(self, name, old_caption, new_caption):
2852        """
2853        Change the panel caption
2854
2855        :param name: window_name of the pane
2856        :param old_caption: current caption [string]
2857        :param new_caption: new caption [string]
2858        """
2859        # wx.aui.AuiPaneInfo
2860        pane_info = self.get_paneinfo(old_caption)
2861        # update the data_panel.cb_plotpanel
2862        if 'data_panel' in self.panels.keys():
2863            # remove from data_panel combobox
2864            data_panel = self.panels["data_panel"]
2865            if data_panel.cb_plotpanel is not None:
2866                # Check if any panel has the same caption
2867                has_newstring = data_panel.cb_plotpanel.FindString(
2868                    str(new_caption))
2869                caption = new_caption
2870                if has_newstring != wx.NOT_FOUND:
2871                    captions = self._get_plotpanel_captions()
2872                    # Append nummber
2873                    inc = 1
2874                    # FIXME: fix this terrible loop
2875                    while (1):
2876                        caption = new_caption + '_%s' % str(inc)
2877                        if caption not in captions:
2878                            break
2879                        inc += 1
2880                    # notify to users
2881                    msg = "Found Same Title: Added '_%s'" % str(inc)
2882                    wx.PostEvent(self, StatusEvent(status=msg))
2883                # update data_panel cb
2884                pos = data_panel.cb_plotpanel.FindString(str(old_caption))
2885                if pos != wx.NOT_FOUND:
2886                    data_panel.cb_plotpanel.SetString(pos, caption)
2887                    data_panel.cb_plotpanel.SetStringSelection(caption)
2888        # New Caption
2889        pane_info.SetTitle(caption)
2890        return caption
2891
2892    def get_paneinfo(self, name):
2893        """
2894        Get pane Caption from window_name
2895
2896        :param name: window_name in AuiPaneInfo
2897        :returns: AuiPaneInfo of the name
2898        """
2899        for panel in self.plot_panels.values():
2900            if panel.frame.GetTitle() == name:
2901                return panel.frame
2902        return None
2903
2904    def enable_undo(self):
2905        """
2906        enable undo related control
2907        """
2908        if self.cpanel_on_focus is not None:
2909            self._toolbar.enable_undo(self.cpanel_on_focus)
2910
2911    def enable_redo(self):
2912        """
2913        enable redo
2914        """
2915        if self.cpanel_on_focus is not None:
2916            self._toolbar.enable_redo(self.cpanel_on_focus)
2917
2918    def enable_copy(self):
2919        """
2920        enable copy related control
2921        """
2922        if self.cpanel_on_focus is not None:
2923            self._toolbar.enable_copy(self.cpanel_on_focus)
2924
2925    def enable_paste(self):
2926        """
2927        enable paste
2928        """
2929        if self.cpanel_on_focus is not None:
2930            self._toolbar.enable_paste(self.cpanel_on_focus)
2931
2932    def enable_bookmark(self):
2933        """
2934        Bookmark
2935        """
2936        if self.cpanel_on_focus is not None:
2937            self._toolbar.enable_bookmark(self.cpanel_on_focus)
2938
2939    def enable_save(self):
2940        """
2941        save
2942        """
2943        if self.cpanel_on_focus is not None:
2944            self._toolbar.enable_save(self.cpanel_on_focus)
2945
2946    def enable_preview(self):
2947        """
2948        preview
2949        """
2950        if self.cpanel_on_focus is not None:
2951            self._toolbar.enable_preview(self.cpanel_on_focus)
2952
2953    def enable_print(self):
2954        """
2955        print
2956        """
2957        if self.cpanel_on_focus is not None:
2958            self._toolbar.enable_print(self.cpanel_on_focus)
2959
2960    def enable_zoom(self):
2961        """
2962        zoom
2963        """
2964        if self.cpanel_on_focus is not None:
2965            self._toolbar.enable_zoom(self.panel_on_focus)
2966
2967    def enable_zoom_in(self):
2968        """
2969        zoom in
2970        """
2971        if self.cpanel_on_focus is not None:
2972            self._toolbar.enable_zoom_in(self.panel_on_focus)
2973
2974    def enable_zoom_out(self):
2975        """
2976        zoom out
2977        """
2978        if self.cpanel_on_focus is not None:
2979            self._toolbar.enable_zoom_out(self.panel_on_focus)
2980
2981    def enable_drag(self, event=None):
2982        """
2983        drag
2984        """
2985        # Not implemeted
2986
2987    def enable_reset(self):
2988        """
2989        reset the current panel
2990        """
2991        if self.cpanel_on_focus is not None:
2992            self._toolbar.enable_reset(self.panel_on_focus)
2993
2994    def get_toolbar_height(self):
2995        """
2996        """
2997        size_y = 0
2998        if self.GetToolBar() is not None and self.GetToolBar().IsShown():
2999            if not IS_LINUX:
3000                _, size_y = self.GetToolBar().GetSizeTuple()
3001        return size_y
3002
3003    def set_schedule_full_draw(self, panel=None, func='del'):
3004        """
3005        Add/subtract the schedule full draw list with the panel given
3006
3007        :param panel: plot panel
3008        :param func: append or del [string]
3009        """
3010
3011        # append this panel in the schedule list if not in yet
3012        if func == 'append':
3013            if panel not in self.schedule_full_draw_list:
3014                self.schedule_full_draw_list.append(panel)
3015        # remove this panel from schedule list
3016        elif func == 'del':
3017            if len(self.schedule_full_draw_list) > 0:
3018                if panel in self.schedule_full_draw_list:
3019                    self.schedule_full_draw_list.remove(panel)
3020
3021        # reset the schdule
3022        if len(self.schedule_full_draw_list) == 0:
3023            self.schedule = False
3024        else:
3025            self.schedule = True
3026
3027    def full_draw(self):
3028        """
3029        Draw the panels with axes in the schedule to full dwar list
3030        """
3031
3032        count = len(self.schedule_full_draw_list)
3033        # if not self.schedule:
3034        if count < 1:
3035            self.set_schedule(False)
3036            return
3037
3038        else:
3039            ind = 0
3040            # if any of the panel is shown do full_draw
3041            for panel in self.schedule_full_draw_list:
3042                ind += 1
3043                if panel.frame.IsShown():
3044                    break
3045                # otherwise, return
3046                if ind == count:
3047                    return
3048        # Simple redraw only for a panel shown
3049
3050        def f_draw(panel):
3051            """
3052            Draw A panel in the full draw list
3053            """
3054            try:
3055                # This checking of GetCapture is to stop redrawing
3056                # while any panel is capture.
3057                frame = panel.frame
3058
3059                if not frame.GetCapture():
3060                    # draw if possible
3061                    panel.set_resizing(False)
3062                    # panel.Show(True)
3063                    panel.draw_plot()
3064                # Check if the panel is not shown
3065                flag = frame.IsShown()
3066                frame.Show(flag)
3067            except:
3068                pass
3069
3070        # Draw all panels
3071        if count == 1:
3072            f_draw(self.schedule_full_draw_list[0])
3073        else:
3074            map(f_draw, self.schedule_full_draw_list)
3075        # Reset the attr
3076        if len(self.schedule_full_draw_list) == 0:
3077            self.set_schedule(False)
3078        else:
3079            self.set_schedule(True)
3080
3081    def set_schedule(self, schedule=False):
3082        """
3083        Set schedule
3084        """
3085        self.schedule = schedule
3086
3087    def get_schedule(self):
3088        """
3089        Get schedule
3090        """
3091        return self.schedule
3092
3093    def on_set_plot_focus(self, panel):
3094        """
3095        Set focus on a plot panel
3096        """
3097        if panel is None:
3098            return
3099        # self.set_plot_unfocus()
3100        panel.on_set_focus(None)
3101        # set focusing panel
3102        self.panel_on_focus = panel
3103        self.set_panel_on_focus(None)
3104
3105    def set_plot_unfocus(self):
3106        """
3107        Un focus all plot panels
3108        """
3109        for plot in self.plot_panels.values():
3110            plot.on_kill_focus(None)
3111
3112    def get_window_size(self):
3113        """
3114        Get window size
3115
3116        :returns: size
3117        :rtype: tuple
3118        """
3119        width, height = self.GetSizeTuple()
3120        if not IS_WIN:
3121            # Subtract toolbar height to get real window side
3122            if self._toolbar.IsShown():
3123                height -= 45
3124        return (width, height)
3125
3126    def _onDrawIdle(self, *args, **kwargs):
3127        """
3128        ReDraw with axes
3129        """
3130        try:
3131            # check if it is time to redraw
3132            if self.GetCapture() is None:
3133                # Draw plot, changes resizing too
3134                self.full_draw()
3135        except:
3136            pass
3137
3138        # restart idle
3139        self._redraw_idle(*args, **kwargs)
3140
3141    def _redraw_idle(self, *args, **kwargs):
3142        """
3143        Restart Idle
3144        """
3145        # restart idle
3146        self.idletimer.Restart(100 * TIME_FACTOR, *args, **kwargs)
3147
3148
3149class DefaultPanel(wx.Panel, PanelBase):
3150    """
3151    Defines the API for a panels to work with
3152    the GUI manager
3153    """
3154    # Internal nickname for the window, used by the AUI manager
3155    window_name = "default"
3156    # Name to appear on the window title bar
3157    window_caption = "Welcome panel"
3158    # Flag to tell the AUI manager to put this panel in the center pane
3159    CENTER_PANE = True
3160
3161    def __init__(self, parent, *args, **kwds):
3162        wx.Panel.__init__(self, parent, *args, **kwds)
3163        PanelBase.__init__(self, parent)
3164
3165
3166class SasViewApp(wx.App):
3167    """
3168    SasView application
3169    """
3170    def OnInit(self):
3171        """
3172        When initialised
3173        """
3174        pos, size, self.is_max = self.window_placement((GUIFRAME_WIDTH,
3175                                                        GUIFRAME_HEIGHT))
3176        self.frame = ViewerFrame(parent=None,
3177                                 title=APPLICATION_NAME,
3178                                 pos=pos,
3179                                 gui_style=DEFAULT_STYLE,
3180                                 size=size)
3181        self.frame.Hide()
3182        if not IS_WIN:
3183            self.frame.EnableCloseButton(False)
3184        self.s_screen = None
3185
3186        try:
3187            self.open_file()
3188        except:
3189            msg = "%s Could not load " % str(APPLICATION_NAME)
3190            msg += "input file from command line.\n"
3191            logger.error(msg)
3192        # Display a splash screen on top of the frame.
3193        try:
3194            if os.path.isfile(SPLASH_SCREEN_PATH):
3195                self.s_screen = \
3196                    self.display_splash_screen(parent=self.frame,
3197                                               path=SPLASH_SCREEN_PATH)
3198            else:
3199                self.frame.Show()
3200        except:
3201            if self.s_screen is not None:
3202                self.s_screen.Close()
3203            msg = "Cannot display splash screen\n"
3204            msg += str(sys.exc_value)
3205            logger.error(msg)
3206            self.frame.Show()
3207
3208        self.SetTopWindow(self.frame)
3209
3210        return True
3211
3212    def maximize_win(self):
3213        """
3214        Maximize the window after the frame shown
3215        """
3216        if self.is_max:
3217            if self.frame.IsShown():
3218                # Max window size
3219                self.frame.Maximize(self.is_max)
3220
3221    def open_file(self):
3222        """
3223        open a state file at the start of the application
3224        """
3225        input_file = None
3226        if len(sys.argv) >= 2:
3227            cmd = sys.argv[0].lower()
3228            basename = os.path.basename(cmd)
3229            app_base = str(APPLICATION_NAME).lower()
3230            if os.path.isfile(cmd) or basename.lower() == app_base:
3231                app_py = app_base + '.py'
3232                app_exe = app_base + '.exe'
3233                app_app = app_base + '.app'
3234                if basename.lower() in [app_py, app_exe, app_app, app_base]:
3235                    data_base = sys.argv[1]
3236                    input_file = os.path.normpath(os.path.join(get_app_dir(),
3237                                                               data_base))
3238        if input_file is None:
3239            return
3240        if self.frame is not None:
3241            self.frame.set_input_file(input_file=input_file)
3242
3243    def clean_plugin_models(self, path):
3244        """
3245        Delete plugin models  in app folder
3246
3247        :param path: path of the plugin_models folder in app
3248        """
3249        # do it only the first time app loaded
3250        # delete unused model folder
3251        model_folder = os.path.join(get_app_dir(), path)
3252        if os.path.exists(model_folder) and os.path.isdir(model_folder):
3253            if len(os.listdir(model_folder)) > 0:
3254                try:
3255                    for filename in os.listdir(model_folder):
3256                        file_path = os.path.join(model_folder, filename)
3257                        if os.path.isfile(file_path):
3258                            os.remove(file_path)
3259                except:
3260                    logger.error("gui_manager.clean_plugin_models:\n  %s"
3261                                  % sys.exc_value)
3262
3263    def set_manager(self, manager):
3264        """
3265        Sets a reference to the application manager
3266        of the GUI manager (Frame)
3267        """
3268        self.frame.set_manager(manager)
3269
3270    def build_gui(self):
3271        """
3272        Build the GUI
3273        """
3274        # try to load file at the start
3275        self.open_file()
3276        self.frame.build_gui()
3277
3278    def set_welcome_panel(self, panel_class):
3279        """
3280        Set the welcome panel
3281
3282        :param panel_class: class of the welcome panel to be instantiated
3283
3284        """
3285        self.frame.welcome_panel_class = panel_class
3286
3287    def add_perspective(self, perspective):
3288        """
3289        Manually add a perspective to the application GUI
3290        """
3291        self.frame.add_perspective(perspective)
3292
3293    def window_placement(self, size):
3294        """
3295        Determines the position and size of the application frame such that it
3296        fits on the user's screen without obstructing (or being obstructed by)
3297        the Windows task bar.  The maximum initial size in pixels is bounded by
3298        WIDTH x HEIGHT.  For most monitors, the application
3299        will be centered on the screen; for very large monitors it will be
3300        placed on the left side of the screen.
3301        """
3302        is_maximized = False
3303        # Get size of screen without
3304        for screenCount in range(wx.Display().GetCount()):
3305            screen = wx.Display(screenCount)
3306            if screen.IsPrimary():
3307                displayRect = screen.GetClientArea()
3308                break
3309
3310        posX, posY, displayWidth, displayHeight = displayRect
3311        customWidth, customHeight = size
3312
3313        # If the custom size is default, set 90% of the screen size
3314        if customWidth <= 0 and customHeight <= 0:
3315            if customWidth == 0 and customHeight == 0:
3316                is_maximized = True
3317            customWidth = displayWidth * 0.9
3318            customHeight = displayHeight * 0.9
3319        else:
3320            # If the custom screen is bigger than the
3321            # window screen than make maximum size
3322            if customWidth > displayWidth:
3323                customWidth = displayWidth
3324            if customHeight > displayHeight:
3325                customHeight = displayHeight
3326
3327        # Note that when running Linux and using an Xming (X11) server on a PC
3328        # with a dual  monitor configuration, the reported display size may be
3329        # that of both monitors combined with an incorrect display count of 1.
3330        # To avoid displaying this app across both monitors, we check for
3331        # screen 'too big'.  If so, we assume a smaller width which means the
3332        # application will be placed towards the left hand side of the screen.
3333
3334        # If dual screen registered as 1 screen. Make width half.
3335        # MAC just follows the default behavior of pos
3336        if IS_WIN:
3337            if displayWidth > (displayHeight * 2):
3338                if customWidth == displayWidth:
3339                    customWidth = displayWidth / 2
3340                # and set the position to be the corner of the screen.
3341                posX = 0
3342                posY = 0
3343
3344            # Make the position the middle of the screen. (Not 0,0)
3345            else:
3346                posX = (displayWidth - customWidth) / 2
3347                posY = (displayHeight - customHeight) / 2
3348        # Return the suggested position and size for the application frame.
3349        return (posX, posY), (customWidth, customHeight), is_maximized
3350
3351    def display_splash_screen(self, parent,
3352                              path=SPLASH_SCREEN_PATH):
3353        """Displays the splash screen.  It will exactly cover the main frame."""
3354
3355        # Prepare the picture.  On a 2GHz intel cpu, this takes about a second.
3356        image = wx.Image(path, wx.BITMAP_TYPE_PNG)
3357        image.Rescale(SPLASH_SCREEN_WIDTH,
3358                      SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
3359        bm = image.ConvertToBitmap()
3360
3361        # Create and show the splash screen.  It will disappear only when the
3362        # program has entered the event loop AND either the timeout has expired
3363        # or the user has left clicked on the screen.  Thus any processing
3364        # performed in this routine (including sleeping) or processing in the
3365        # calling routine (including doing imports) will prevent the splash
3366        # screen from disappearing.
3367        #
3368        # Note that on Linux, the timeout appears to occur immediately in which
3369        # case the splash screen disappears upon entering the event loop.
3370        s_screen = wx.SplashScreen(bitmap=bm,
3371                                   splashStyle=(wx.SPLASH_TIMEOUT |
3372                                                wx.SPLASH_CENTRE_ON_SCREEN),
3373                                   style=(wx.SIMPLE_BORDER |
3374                                          wx.FRAME_NO_TASKBAR |
3375                                          wx.FRAME_FLOAT_ON_PARENT),
3376                                   milliseconds=SS_MAX_DISPLAY_TIME,
3377                                   parent=parent,
3378                                   id=wx.ID_ANY)
3379        from sas.sasgui.guiframe.gui_statusbar import SPageStatusbar
3380        statusBar = SPageStatusbar(s_screen)
3381        s_screen.SetStatusBar(statusBar)
3382        s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
3383        s_screen.Show()
3384        return s_screen
3385
3386    def on_close_splash_screen(self, event):
3387        """
3388        When the splash screen is closed.
3389        """
3390        self.frame.Show(True)
3391        event.Skip()
3392        self.maximize_win()
3393
3394
3395class MDIFrame(CHILD_FRAME):
3396    """
3397    Frame for panels
3398    """
3399    def __init__(self, parent, panel, title="Untitled", size=(300, 200)):
3400        """
3401        comment
3402        :param parent: parent panel/container
3403        """
3404        # Initialize the Frame object
3405        CHILD_FRAME.__init__(self, parent=parent, id=wx.ID_ANY,
3406                             title=title, size=size)
3407        self.parent = parent
3408        self.name = "Untitled"
3409        self.batch_on = self.parent.batch_on
3410        self.panel = panel
3411        if panel is not None:
3412            self.set_panel(panel)
3413        self.Show(False)
3414
3415    def show_data_panel(self, action):
3416        """
3417        Turns on the data panel
3418
3419        The the data panel is optional.  Most of its functions can be
3420        performed from the menu bar and from the plots.
3421        """
3422        self.parent.show_data_panel(action)
3423
3424    def set_panel(self, panel):
3425        """
3426        """
3427        self.panel = panel
3428        self.name = panel.window_name
3429        self.SetTitle(panel.window_caption)
3430        self.SetHelpText(panel.help_string)
3431        width, height = self.parent._get_panels_size(panel)
3432        if hasattr(panel, "CENTER_PANE") and panel.CENTER_PANE:
3433            width *= 0.6
3434        self.SetSize((width, height))
3435        self.parent.put_icon(self)
3436        self.Bind(wx.EVT_SET_FOCUS, self.set_panel_focus)
3437        self.Bind(wx.EVT_CLOSE, self.OnClose)
3438        self.Show(False)
3439
3440    def set_panel_focus(self, event):
3441        """
3442        """
3443        if self.parent.panel_on_focus != self.panel:
3444            self.panel.SetFocus()
3445            self.parent.panel_on_focus = self.panel
3446
3447    def OnClose(self, event):
3448        """
3449        On Close event
3450        """
3451        self.panel.on_close(event)
3452
3453if __name__ == "__main__":
3454    app = SasViewApp(0)
3455    app.MainLoop()
Note: See TracBrowser for help on using the repository browser.