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

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since b963b20 was b963b20, checked in by Paul Kienzle <pkienzle@…>, 6 years ago

pull config out of sas.sasgui so it can be used without reference to wx

  • Property mode set to 100644
File size: 126.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            self._help_menu.Append(wx_id, '&Tutorial', 'Software tutorial')
1284            wx.EVT_MENU(self, wx_id, self._onTutorial)
1285
1286        if config._do_acknowledge:
1287            wx_id = wx.NewId()
1288            self._help_menu.Append(wx_id, '&Acknowledge',
1289                                   'Acknowledging SasView')
1290            wx.EVT_MENU(self, wx_id, self._onAcknowledge)
1291
1292        if config._do_aboutbox:
1293            logger.info("Doing help menu")
1294            wx_id = wx.NewId()
1295            self._help_menu.Append(wx_id, '&About', 'Software information')
1296            wx.EVT_MENU(self, wx_id, self._onAbout)
1297
1298        if config.marketplace_url:
1299            wx_id = wx.NewId()
1300            self._help_menu.Append(wx_id, '&Model marketplace', '')
1301            wx.EVT_MENU(self, wx_id, self._on_marketplace_click)
1302
1303        # Checking for updates
1304        wx_id = wx.NewId()
1305        self._help_menu.Append(wx_id, '&Check for update',
1306                               'Check for the latest version of %s' %
1307                               config.__appname__)
1308        wx.EVT_MENU(self, wx_id, self._check_update)
1309        self._menubar.Append(self._help_menu, '&Help')
1310
1311    def _add_menu_view(self):
1312        """
1313        add menu items under view menu
1314        """
1315        if not VIEW_MENU:
1316            return
1317        self._view_menu = wx.Menu()
1318
1319        wx_id = wx.NewId()
1320        hint = "Display the Grid Window for batch results etc."
1321        self._view_menu.Append(wx_id, '&Show Grid Window', hint)
1322        wx.EVT_MENU(self, wx_id, self.show_batch_frame)
1323
1324        self._view_menu.AppendSeparator()
1325        style = self.__gui_style & GUIFRAME.MANAGER_ON
1326        wx_id = wx.NewId()
1327        self._data_panel_menu = self._view_menu.Append(wx_id,
1328                                                       '&Show Data Explorer',
1329                                                       '')
1330        wx.EVT_MENU(self, wx_id, self.show_data_panel)
1331        if style == GUIFRAME.MANAGER_ON:
1332            self._data_panel_menu.SetText('Hide Data Explorer')
1333        else:
1334            self._data_panel_menu.SetText('Show Data Explorer')
1335
1336        self._view_menu.AppendSeparator()
1337        wx_id = wx.NewId()
1338        style1 = self.__gui_style & GUIFRAME.TOOLBAR_ON
1339        if style1 == GUIFRAME.TOOLBAR_ON:
1340            self._toolbar_menu = self._view_menu.Append(wx_id, '&Hide Toolbar',
1341                                                        '')
1342        else:
1343            self._toolbar_menu = self._view_menu.Append(wx_id, '&Show Toolbar',
1344                                                        '')
1345        wx.EVT_MENU(self, wx_id, self._on_toggle_toolbar)
1346
1347        if custom_config is not None:
1348            self._view_menu.AppendSeparator()
1349            wx_id = wx.NewId()
1350            hint_ss = "Select the current/default configuration "
1351            hint_ss += "as a startup setting"
1352            preference_menu = self._view_menu.Append(wx_id, 'Startup Setting',
1353                                                     hint_ss)
1354            wx.EVT_MENU(self, wx_id, self._on_preference_menu)
1355
1356        wx_id = wx.NewId()
1357        self._view_menu.AppendSeparator()
1358        self._view_menu.Append(wx_id, 'Category Manager',
1359                               'Edit model categories')
1360        wx.EVT_MENU(self, wx_id, self._on_category_manager)
1361
1362        self._menubar.Append(self._view_menu, '&View')
1363
1364    def show_batch_frame(self, event=None):
1365        """
1366        show the grid of result
1367        """
1368        # Show(False) before Show(True) in order to bring it to the front
1369        self.batch_frame.Show(False)
1370        self.batch_frame.Show(True)
1371
1372    def on_category_panel(self, event):
1373        """
1374        On cat panel
1375        """
1376        self._on_category_manager(event)
1377
1378    def _on_category_manager(self, event):
1379        """
1380        Category manager frame
1381        """
1382        frame = CategoryManager(self, -1, 'Model Category Manager')
1383        icon = self.GetIcon()
1384        frame.SetIcon(icon)
1385
1386    def _on_preference_menu(self, event):
1387        """
1388        Build a panel to allow to edit Mask
1389        """
1390        from sas.sasgui.guiframe.startup_configuration \
1391            import StartupConfiguration as ConfDialog
1392
1393        dialog = ConfDialog(parent=self, gui=self.__gui_style)
1394        result = dialog.ShowModal()
1395        if result == wx.ID_OK:
1396            dialog.write_custom_config()
1397            # post event for info
1398            wx.PostEvent(self, StatusEvent(status="Wrote custom configuration",
1399                                           info='info'))
1400        dialog.Destroy()
1401
1402    def _add_menu_application(self):
1403        """
1404        # Attach a menu item for each defined perspective or application.
1405        # Only add the perspective menu if there are more than one perspectives
1406        add menu application
1407        """
1408        if self._num_perspectives > 1:
1409            plug_data_count = False
1410            plug_no_data_count = False
1411            self._applications_menu = wx.Menu()
1412            pos = 0
1413            separator = self._applications_menu.AppendSeparator()
1414            for plug in self.plugins:
1415                if len(plug.get_perspective()) > 0:
1416                    id = wx.NewId()
1417                    if plug.use_data():
1418                        self._applications_menu.InsertCheckItem(pos, id,
1419                                                                plug.sub_menu,
1420                                    "Switch to analysis: %s" % plug.sub_menu)
1421                        plug_data_count = True
1422                        pos += 1
1423                    else:
1424                        plug_no_data_count = True
1425                        self._applications_menu.AppendCheckItem(id,
1426                                                                plug.sub_menu,
1427                            "Switch to analysis: %s" % plug.sub_menu)
1428                    wx.EVT_MENU(self, id, plug.on_perspective)
1429
1430            if not plug_data_count or not plug_no_data_count:
1431                self._applications_menu.RemoveItem(separator)
1432            # Windows introduces a "Window" menu item during the layout process
1433            # somehow.  We want it to be next to the last item with Help as
1434            # last. However Analysis gets stuck after Window in normal ordering
1435            # so force it to be next after the Tools menu item.  Should we add
1436            # another menu item will need to check if this is still where we
1437            # want Analysis.  This is NOT an issue on the Mac which does not
1438            # have the extra Window menu item.
1439            #      March 2016 Code Camp  -- PDB
1440            Tools_pos = self._menubar.FindMenu("Tools")
1441            self._menubar.Insert(Tools_pos+1, self._applications_menu,
1442                                 '&Analysis')
1443            self._check_applications_menu()
1444
1445    def _populate_file_menu(self):
1446        """
1447        Insert menu item under file menu
1448        """
1449        for plugin in self.plugins:
1450            if len(plugin.populate_file_menu()) > 0:
1451                for item in plugin.populate_file_menu():
1452                    m_name, m_hint, m_handler = item
1453                    wx_id = wx.NewId()
1454                    self._file_menu.Append(wx_id, m_name, m_hint)
1455                    wx.EVT_MENU(self, wx_id, m_handler)
1456                self._file_menu.AppendSeparator()
1457
1458        style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
1459        if OPEN_SAVE_MENU:
1460            wx_id = wx.NewId()
1461            hint_load_file = "read all analysis states saved previously"
1462            self._save_appl_menu = self._file_menu.Append(wx_id,
1463                                                          '&Open Project',
1464                                                          hint_load_file)
1465            wx.EVT_MENU(self, wx_id, self._on_open_state_project)
1466
1467        if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1468            # some menu of plugin to be seen under file menu
1469            hint_load_file = "Read a status files and load"
1470            hint_load_file += " them into the analysis"
1471            wx_id = wx.NewId()
1472            self._save_appl_menu = self._file_menu.Append(wx_id,
1473                                                          '&Open Analysis',
1474                                                          hint_load_file)
1475            wx.EVT_MENU(self, wx_id, self._on_open_state_application)
1476        if OPEN_SAVE_MENU:
1477            self._file_menu.AppendSeparator()
1478            wx_id = wx.NewId()
1479            self._file_menu.Append(wx_id, '&Save Project',
1480                                   'Save the state of the whole analysis')
1481            wx.EVT_MENU(self, wx_id, self._on_save_project)
1482        if style1 == GUIFRAME.MULTIPLE_APPLICATIONS:
1483            wx_id = wx.NewId()
1484            txt = '&Save Analysis'
1485            txt2 = 'Save state of the current active analysis panel'
1486            self._save_appl_menu = self._file_menu.Append(wx_id, txt, txt2)
1487            wx.EVT_MENU(self, wx_id, self._on_save_application)
1488        if not sys.platform == 'darwin':
1489            self._file_menu.AppendSeparator()
1490            wx_id = wx.NewId()
1491            self._file_menu.Append(wx_id, '&Quit', 'Exit')
1492            wx.EVT_MENU(self, wx_id, self.Close)
1493
1494    def _add_menu_file(self):
1495        """
1496        add menu file
1497        """
1498        # File menu
1499        self._file_menu = wx.Menu()
1500        # Add sub menus
1501        self._menubar.Append(self._file_menu, '&File')
1502
1503    def _add_menu_edit(self):
1504        """
1505        add menu edit
1506        """
1507        if not EDIT_MENU:
1508            return
1509        # Edit Menu
1510        self._edit_menu = wx.Menu()
1511        self._edit_menu.Append(GUIFRAME_ID.UNDO_ID, '&Undo',
1512                               'Undo the previous action')
1513        wx.EVT_MENU(self, GUIFRAME_ID.UNDO_ID, self.on_undo_panel)
1514        self._edit_menu.Append(GUIFRAME_ID.REDO_ID, '&Redo',
1515                               'Redo the previous action')
1516        wx.EVT_MENU(self, GUIFRAME_ID.REDO_ID, self.on_redo_panel)
1517        self._edit_menu.AppendSeparator()
1518        self._edit_menu.Append(GUIFRAME_ID.COPY_ID, '&Copy Params',
1519                               'Copy parameter values')
1520        wx.EVT_MENU(self, GUIFRAME_ID.COPY_ID, self.on_copy_panel)
1521        self._edit_menu.Append(GUIFRAME_ID.PASTE_ID, '&Paste Params',
1522                               'Paste parameter values')
1523        wx.EVT_MENU(self, GUIFRAME_ID.PASTE_ID, self.on_paste_panel)
1524
1525        self._edit_menu.AppendSeparator()
1526
1527        self._edit_menu_copyas = wx.Menu()
1528        # Sub menu for Copy As...
1529        self._edit_menu_copyas.Append(GUIFRAME_ID.COPYEX_ID,
1530                                      'Copy current tab to Excel',
1531                                      'Copy parameter values in tabular format')
1532        wx.EVT_MENU(self, GUIFRAME_ID.COPYEX_ID, self.on_copy_panel)
1533
1534        self._edit_menu_copyas.Append(GUIFRAME_ID.COPYLAT_ID,
1535                                      'Copy current tab to LaTeX',
1536                                      'Copy parameter values in tabular format')
1537        wx.EVT_MENU(self, GUIFRAME_ID.COPYLAT_ID, self.on_copy_panel)
1538
1539        self._edit_menu.AppendMenu(GUIFRAME_ID.COPYAS_ID, 'Copy Params as...',
1540                                   self._edit_menu_copyas,
1541                                   'Copy parameter values in various formats')
1542
1543        self._edit_menu.AppendSeparator()
1544
1545        self._edit_menu.Append(GUIFRAME_ID.PREVIEW_ID, '&Report Results',
1546                               'Preview current panel')
1547        wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel)
1548
1549        self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',
1550                               'Reset current panel')
1551        wx.EVT_MENU(self, GUIFRAME_ID.RESET_ID, self.on_reset_panel)
1552
1553        self._menubar.Append(self._edit_menu, '&Edit')
1554        self.enable_edit_menu()
1555
1556    def get_style(self):
1557        """
1558        Return the gui style
1559        """
1560        return self.__gui_style
1561
1562    def _add_menu_data(self):
1563        """
1564        Add menu item item data to menu bar
1565        """
1566        if self._data_plugin is not None:
1567            menu_list = self._data_plugin.populate_menu(self)
1568            if menu_list:
1569                for (menu, name) in menu_list:
1570                    self._menubar.Append(menu, name)
1571
1572    def _on_toggle_toolbar(self, event=None):
1573        """
1574        hide or show toolbar
1575        """
1576        if self._toolbar is None:
1577            return
1578        if self._toolbar.IsShown():
1579            if self._toolbar_menu is not None:
1580                self._toolbar_menu.SetItemLabel('Show Toolbar')
1581            self._toolbar.Hide()
1582        else:
1583            if self._toolbar_menu is not None:
1584                self._toolbar_menu.SetItemLabel('Hide Toolbar')
1585            self._toolbar.Show()
1586        self._toolbar.Realize()
1587
1588    def _on_status_event(self, evt):
1589        """
1590        Display status message
1591        """
1592        # This CallAfter fixes many crashes on MAC.
1593        wx.CallAfter(self.sb.set_status, evt)
1594
1595    def on_view(self, evt):
1596        """
1597        A panel was selected to be shown. If it's not already
1598        shown, display it.
1599
1600        :param evt: menu event
1601
1602        """
1603        panel_id = str(evt.GetId())
1604        self.on_set_plot_focus(self.panels[panel_id])
1605        wx.CallLater(5 * TIME_FACTOR, self.set_schedule(True))
1606        self.set_plot_unfocus()
1607
1608    def show_welcome_panel(self, event):
1609        """
1610        Display the welcome panel
1611        """
1612        if self.defaultPanel is None:
1613            return
1614        frame = self.panels['default'].get_frame()
1615        if frame is None:
1616            return
1617        # Show default panel
1618        if not frame.IsShown():
1619            frame.Show(True)
1620
1621    def on_close_welcome_panel(self):
1622        """
1623        Close the welcome panel
1624        """
1625        if self.defaultPanel is None:
1626            return
1627        default_panel = self.panels["default"].frame
1628        if default_panel.IsShown():
1629            default_panel.Show(False)
1630
1631    def delete_panel(self, uid):
1632        """
1633        delete panel given uid
1634        """
1635        ID = str(uid)
1636        config.printEVT("delete_panel: %s" % ID)
1637        if ID in self.panels.keys():
1638            self.panel_on_focus = None
1639            panel = self.panels[ID]
1640
1641            if hasattr(panel, "connect"):
1642                panel.connect.disconnect()
1643            self._plotting_plugin.delete_panel(panel.group_id)
1644
1645            if panel in self.schedule_full_draw_list:
1646                self.schedule_full_draw_list.remove(panel)
1647
1648            # delete uid number not str(uid)
1649            if ID in self.plot_panels.keys():
1650                del self.plot_panels[ID]
1651            if ID in self.panels.keys():
1652                del self.panels[ID]
1653        else:
1654            logger.error("delete_panel: No such plot id as %s" % ID)
1655
1656    def create_gui_data(self, data, path=None):
1657        """
1658        """
1659        return self._data_manager.create_gui_data(data, path)
1660
1661    def get_data(self, path):
1662        """
1663        """
1664        log_msg = ''
1665        basename = os.path.basename(path)
1666        _, extension = os.path.splitext(basename)
1667        if extension.lower() not in EXTENSIONS:
1668            log_msg = "File Loader cannot "
1669            log_msg += "load: %s\n" % str(basename)
1670            log_msg += "Try Data opening...."
1671            logger.error(log_msg)
1672            return
1673
1674        # reading a state file
1675        for plug in self.plugins:
1676            reader, ext = plug.get_extensions()
1677            if reader is not None:
1678                # read the state of the single plugin
1679                if extension == ext:
1680                    reader.read(path)
1681                    return
1682                elif extension == APPLICATION_STATE_EXTENSION:
1683                    try:
1684                        reader.read(path)
1685                    except:
1686                        msg = "DataLoader Error: Encounted Non-ASCII character"
1687                        msg += "\n(%s)" % sys.exc_value
1688                        wx.PostEvent(self, StatusEvent(status=msg,
1689                                                       info="error",
1690                                                       type="stop"))
1691                        return
1692
1693        style = self.__gui_style & GUIFRAME.MANAGER_ON
1694        if style == GUIFRAME.MANAGER_ON:
1695            if self._data_panel is not None:
1696                self._data_panel.frame.Show(True)
1697
1698    def load_from_cmd(self, path):
1699        """
1700        load data from cmd or application
1701        """
1702        if path is None:
1703            return
1704        else:
1705            path = os.path.abspath(path)
1706            if not os.path.isfile(path) and not os.path.isdir(path):
1707                return
1708
1709            if os.path.isdir(path):
1710                self.load_folder(path)
1711                return
1712
1713        basename = os.path.basename(path)
1714        _, extension = os.path.splitext(basename)
1715        if extension.lower() not in EXTENSIONS:
1716            self.load_data(path)
1717        else:
1718            self.load_state(path)
1719
1720        self._default_save_location = os.path.dirname(path)
1721
1722    def load_state(self, path, is_project=False):
1723        """
1724        load data from command line or application
1725        """
1726        if path and (path is not None) and os.path.isfile(path):
1727            basename = os.path.basename(path)
1728            if APPLICATION_STATE_EXTENSION is not None \
1729                    and basename.endswith(APPLICATION_STATE_EXTENSION):
1730                if is_project:
1731                    for ID in self.plot_panels.keys():
1732                        panel = self.plot_panels[ID]
1733                        panel.on_close(None)
1734            self.get_data(path)
1735            wx.PostEvent(self, StatusEvent(status="Completed loading."))
1736        else:
1737            wx.PostEvent(self, StatusEvent(status=" "))
1738
1739    def load_data(self, path):
1740        """
1741        load data from command line
1742        """
1743        if not os.path.isfile(path):
1744            return
1745        basename = os.path.basename(path)
1746        _, extension = os.path.splitext(basename)
1747        if extension.lower() in EXTENSIONS:
1748            log_msg = "Data Loader cannot "
1749            log_msg += "load: %s\n" % str(path)
1750            log_msg += "Try File opening ...."
1751            logger.error(log_msg)
1752            return
1753        log_msg = ''
1754        output = {}
1755        error_message = ""
1756        try:
1757            logger.info("Loading Data...:\n" + str(path) + "\n")
1758            temp = self.loader.load(path)
1759            if temp.__class__.__name__ == "list":
1760                for item in temp:
1761                    data = self.create_gui_data(item, path)
1762                    output[data.id] = data
1763            else:
1764                data = self.create_gui_data(temp, path)
1765                output[data.id] = data
1766
1767            self.add_data(data_list=output)
1768        except:
1769            error_message = "Error while loading"
1770            error_message += " Data from cmd:\n %s\n" % str(path)
1771            error_message += str(sys.exc_value) + "\n"
1772            logger.error(error_message)
1773
1774    def load_folder(self, path):
1775        """
1776        Load entire folder
1777        """
1778        if not os.path.isdir(path):
1779            return
1780        if self._data_plugin is None:
1781            return
1782        try:
1783            if path is not None:
1784                self._default_save_location = os.path.dirname(path)
1785                file_list = self._data_plugin.get_file_path(path)
1786                self._data_plugin.get_data(file_list)
1787            else:
1788                return
1789        except:
1790            error_message = "Error while loading"
1791            error_message += " Data folder from cmd:\n %s\n" % str(path)
1792            error_message += str(sys.exc_value) + "\n"
1793            logger.error(error_message)
1794
1795    def _on_open_state_application(self, event):
1796        """
1797        """
1798        path = None
1799        if self._default_save_location is None:
1800            self._default_save_location = os.getcwd()
1801        wx.PostEvent(self, StatusEvent(status="Loading Analysis file..."))
1802        plug_wlist = self._on_open_state_app_helper()
1803        dlg = wx.FileDialog(self,
1804                            "Choose a file",
1805                            self._default_save_location, "",
1806                            plug_wlist)
1807        if dlg.ShowModal() == wx.ID_OK:
1808            path = dlg.GetPath()
1809            if path is not None:
1810                self._default_save_location = os.path.dirname(path)
1811        dlg.Destroy()
1812        self.load_state(path=path)
1813
1814    def _on_open_state_app_helper(self):
1815        """
1816        Helps '_on_open_state_application()' to find the extension of
1817        the current perspective/application
1818        """
1819        # No current perspective or no extension attr
1820        if self._current_perspective is None:
1821            return PLUGINS_WLIST
1822        try:
1823            # Find the extension of the perspective
1824            # and get that as 1st item in list
1825            ind = None
1826            app_ext = self._current_perspective._extensions
1827            plug_wlist = config.PLUGINS_WLIST
1828            for ext in set(plug_wlist):
1829                if ext.count(app_ext) > 0:
1830                    ind = ext
1831                    break
1832            # Found the extension
1833            if ind is not None:
1834                plug_wlist.remove(ind)
1835                plug_wlist.insert(0, ind)
1836                try:
1837                    plug_wlist = '|'.join(plug_wlist)
1838                except:
1839                    plug_wlist = ''
1840
1841        except:
1842            plug_wlist = PLUGINS_WLIST
1843
1844        return plug_wlist
1845
1846    def _on_open_state_project(self, event):
1847        """
1848        Load in a .svs project file after removing all data from SasView
1849        """
1850        path = None
1851        if self._default_save_location is None:
1852            self._default_save_location = os.getcwd()
1853        msg = "This operation will set remove all data, plots and analyses from"
1854        msg += " SasView before loading the project. Do you wish to continue?"
1855        msg_box = wx.MessageDialog(None, msg, 'Warning', wx.OK | wx.CANCEL)
1856        if msg_box.ShowModal() == wx.ID_OK:
1857            self._data_panel.selection_cbox.SetValue('Select all Data')
1858            self._data_panel._on_selection_type(None)
1859            for _, theory_dict in self._data_panel.list_cb_theory.iteritems():
1860                for key, value in theory_dict.iteritems():
1861                    item, _, _ = value
1862                    item.Check(True)
1863
1864            wx.PostEvent(self, StatusEvent(status="Loading Project file..."))
1865            dlg = wx.FileDialog(self, "Choose a file",
1866                                self._default_save_location, "",
1867                                APPLICATION_WLIST)
1868            if dlg.ShowModal() == wx.ID_OK:
1869                path = dlg.GetPath()
1870            if path is not None:
1871                self._default_save_location = os.path.dirname(path)
1872                dlg.Destroy()
1873                # Reset to a base state
1874                self._on_reset_state()
1875                self._data_panel.on_remove(None, False)
1876                # Load the project file
1877                self.load_state(path=path, is_project=True)
1878
1879    def _on_reset_state(self):
1880        """
1881        Resets SasView to its freshly opened state.
1882        :return: None
1883        """
1884        # Reset all plugins to their base state
1885        self._data_panel.set_panel_on_focus()
1886        # Remove all loaded data
1887        for plugin in self.plugins:
1888            plugin.clear_panel()
1889        # Reset plot number to 0
1890        self.graph_num = 0
1891
1892    def _on_save_application(self, event):
1893        """
1894        save the state of the current active application
1895        """
1896        if self.cpanel_on_focus is not None:
1897            try:
1898                wx.PostEvent(self,
1899                             StatusEvent(status="Saving Analysis file..."))
1900                self.cpanel_on_focus.on_save(event)
1901                wx.PostEvent(self,
1902                             StatusEvent(status="Completed saving."))
1903            except Exception:
1904                msg = "Error occurred while saving: "
1905                msg += traceback.format_exc()
1906                msg += "To save, the application panel should have a data set.."
1907                wx.PostEvent(self, StatusEvent(status=msg))
1908
1909    def _on_save_project(self, event):
1910        """
1911        save the state of the SasView as *.svs
1912        """
1913        if self._current_perspective is None:
1914            return
1915        wx.PostEvent(self, StatusEvent(status="Saving Project file..."))
1916        path = None
1917        extension = '*' + APPLICATION_STATE_EXTENSION
1918        dlg = wx.FileDialog(self, "Save Project file",
1919                            self._default_save_location, "sasview_proj",
1920                            extension,
1921                            wx.SAVE)
1922        if dlg.ShowModal() == wx.ID_OK:
1923            path = dlg.GetPath()
1924            self._default_save_location = os.path.dirname(path)
1925        else:
1926            return None
1927        dlg.Destroy()
1928        try:
1929            if path is None:
1930                return
1931            # default cansas xml doc
1932            doc = None
1933            for panel in self.panels.values():
1934                temp = panel.save_project(doc)
1935                if temp is not None:
1936                    doc = temp
1937
1938            # Write the XML document
1939            extens = APPLICATION_STATE_EXTENSION
1940            fName = os.path.splitext(path)[0] + extens
1941            if doc is not None:
1942                fd = open(fName, 'w')
1943                fd.write(doc.toprettyxml())
1944                fd.close()
1945                wx.PostEvent(self, StatusEvent(status="Completed Saving."))
1946            else:
1947                msg = "Error occurred while saving the project: "
1948                msg += "To save, at least one application panel "
1949                msg += "should have a data set "
1950                msg += "and model selected. "
1951                msg += "No project was saved to %s" % (str(path))
1952                logger.warning(msg)
1953                wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1954        except Exception:
1955            msg = "Error occurred while saving: "
1956            msg += traceback.format_exc()
1957            msg += "To save, at least one application panel "
1958            msg += "should have a data set.."
1959            wx.PostEvent(self, StatusEvent(status=msg, info="error"))
1960
1961    def on_save_helper(self, doc, reader, panel, path):
1962        """
1963        Save state into a file
1964        """
1965        if reader is not None:
1966            # case of a panel with multi-pages
1967            if hasattr(panel, "opened_pages"):
1968                for _, page in panel.opened_pages.iteritems():
1969                    data = page.get_data()
1970                    # state must be cloned
1971                    state = page.get_state().clone()
1972                    if data is not None:
1973                        new_doc = reader.write_toXML(data, state)
1974                        if doc is not None and hasattr(doc, "firstChild"):
1975                            child = new_doc.firstChild.firstChild
1976                            doc.firstChild.appendChild(child)
1977                        else:
1978                            doc = new_doc
1979            # case of only a panel
1980            else:
1981                data = panel.get_data()
1982                state = panel.get_state()
1983                if data is not None:
1984                    new_doc = reader.write_toXML(data, state)
1985                    if doc is not None and hasattr(doc, "firstChild"):
1986                        child = new_doc.firstChild.firstChild
1987                        doc.firstChild.appendChild(child)
1988                    else:
1989                        doc = new_doc
1990        return doc
1991
1992    def quit_guiframe(self):
1993        """
1994        Pop up message to make sure the user wants to quit the application
1995        """
1996        message = "\nDo you really want to exit this application?        \n\n"
1997        dial = wx.MessageDialog(self, message, 'Confirm Exit',
1998                                wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION)
1999        if dial.ShowModal() == wx.ID_YES:
2000            return True
2001        else:
2002            return False
2003
2004    def WindowClose(self, event=None):
2005        """
2006        Quit the application from x icon
2007        """
2008        flag = self.quit_guiframe()
2009        if flag:
2010            _pylab_helpers.Gcf.figs = {}
2011            self.Close()
2012
2013    def Close(self, event=None):
2014        """
2015        Quit the application
2016        """
2017        #IF SAS_OPENCL is set, settings are stored in the custom config file
2018        self._write_opencl_config_file()
2019        logger.info(" --- SasView session was closed --- \n")
2020        wx.Exit()
2021        sys.exit()
2022
2023    def _write_opencl_config_file(self):
2024        """
2025        Writes OpenCL settings to custom config file, so they can be remmbered
2026        from session to session
2027        """
2028        if custom_config is not None:
2029            sas_opencl = os.environ.get("SAS_OPENCL")
2030            new_config_lines = []
2031            config_file = open(custom_config.__file__)
2032            config_lines = config_file.readlines()
2033            for line in config_lines:
2034                if "SAS_OPENCL" in line:
2035                    if sas_opencl:
2036                        new_config_lines.append("SAS_OPENCL = \"" + sas_opencl
2037                                                + "\"\n")
2038                    else:
2039                        new_config_lines.append("SAS_OPENCL = \"None\"\n")
2040                else:
2041                    new_config_lines.append(line)
2042            config_file.close()
2043
2044            #If custom_config is None, settings will not be remmbered
2045            new_config_file = open(custom_config.__file__,"w")
2046            new_config_file.writelines(new_config_lines)
2047            new_config_file.close()
2048        else:
2049            logger.info("Failed to save OPENCL settings in custom config file")
2050
2051
2052    def _check_update(self, event=None):
2053        """
2054        Check with the deployment server whether a new version
2055        of the application is available.
2056        A thread is started for the connecting with the server. The thread calls
2057        a call-back method when the current version number has been obtained.
2058        """
2059        version_info = {"version": "0.0.0"}
2060        c = Connection(config.__update_URL__, config.UPDATE_TIMEOUT)
2061        response = c.connect()
2062        if response is not None:
2063            try:
2064                content = response.read().strip()
2065                logger.info("Connected to www.sasview.org. Latest version: %s", content)
2066                version_info = json.loads(content)
2067            except:
2068                logger.info("Failed to connect to www.sasview.org")
2069        self._process_version(version_info, standalone=event is None)
2070
2071
2072    def _process_version(self, version_info, standalone=True):
2073        """
2074        Call-back method for the process of checking for updates.
2075        This methods is called by a VersionThread object once the current
2076        version number has been obtained. If the check is being done in the
2077        background, the user will not be notified unless there's an update.
2078
2079        :param version: version string
2080        :param standalone: True of the update is being checked in
2081           the background, False otherwise.
2082
2083        """
2084        try:
2085            version = version_info["version"]
2086            if version == "0.0.0":
2087                msg = "Could not connect to the application server."
2088                msg += " Please try again later."
2089                self.SetStatusText(msg)
2090            elif cmp(version, config.__version__) > 0:
2091                msg = "Version %s is available! " % str(version)
2092                if not standalone:
2093                    import webbrowser
2094                    if "download_url" in version_info:
2095                        webbrowser.open(version_info["download_url"])
2096                    else:
2097                        webbrowser.open(config.__download_page__)
2098                else:
2099                    msg += "See the help menu to download it."
2100                self.SetStatusText(msg)
2101            else:
2102                if not standalone:
2103                    msg = "You have the latest version"
2104                    msg += " of %s" % str(config.__appname__)
2105                    self.SetStatusText(msg)
2106        except:
2107            msg = "guiframe: could not get latest application"
2108            msg += " version number\n  %s" % sys.exc_value
2109            logger.error(msg)
2110            if not standalone:
2111                msg = "Could not connect to the application server."
2112                msg += " Please try again later."
2113                self.SetStatusText(msg)
2114
2115    def _onAcknowledge(self, evt):
2116        """
2117        Pop up the acknowledge dialog
2118
2119        :param evt: menu event
2120
2121        """
2122        if config._do_acknowledge:
2123            import sas.sasgui.guiframe.acknowledgebox as AcknowledgeBox
2124            dialog = AcknowledgeBox.DialogAcknowledge(None, -1, "")
2125            dialog.ShowModal()
2126
2127    def _onAbout(self, evt):
2128        """
2129        Pop up the about dialog
2130
2131        :param evt: menu event
2132
2133        """
2134        if config._do_aboutbox:
2135            import sas.sasgui.guiframe.aboutbox as AboutBox
2136            dialog = AboutBox.DialogAbout(None, -1, "")
2137            dialog.ShowModal()
2138
2139    def _onTutorial(self, evt):
2140        """
2141        Pop up the tutorial dialog
2142
2143        :param evt: menu event
2144
2145        """
2146        if config._do_tutorial:
2147            path = config.TUTORIAL_PATH
2148            if IS_WIN:
2149                try:
2150                    from sas.sasgui.guiframe.pdfview import PDFFrame
2151                    dialog = PDFFrame(None, -1, "Tutorial", path)
2152                    # put icon
2153                    self.put_icon(dialog)
2154                    dialog.Show(True)
2155                except:
2156                    logger.error("Error in _onTutorial: %s" % sys.exc_value)
2157                    try:
2158                        # Try an alternate method
2159                        logger.error(
2160                            "Could not open the tutorial pdf, trying xhtml2pdf")
2161                        from xhtml2pdf import pisa
2162                        pisa.startViewer(path)
2163                    except:
2164                        logger.error(
2165                            "Could not open the tutorial pdf with xhtml2pdf")
2166                        msg = "This feature requires 'PDF Viewer'\n"
2167                        wx.MessageBox(msg, 'Error')
2168            else:
2169                try:
2170                    command = "open '%s'" % path
2171                    os.system(command)
2172                except:
2173                    try:
2174                        # Try an alternate method
2175                        logger.error(
2176                            "Could not open the tutorial pdf, trying xhtml2pdf")
2177                        from xhtml2pdf import pisa
2178                        pisa.startViewer(path)
2179                    except:
2180                        logger.error(
2181                            "Could not open the tutorial pdf with xhtml2pdf")
2182                        msg = "This feature requires the Preview application\n"
2183                        wx.MessageBox(msg, 'Error')
2184
2185    def _onSphinxDocs(self, evt):
2186        """
2187        Bring up Sphinx Documentation at top level whenever the menu item
2188        'documentation' is clicked. Calls DocumentationWindow with the top
2189        level path of "index.html"
2190
2191        :param evt: menu event
2192        """
2193        # Running SasView "in-place" using run.py means the docs will be in a
2194        # different place than they would otherwise.
2195        from documentation_window import DocumentationWindow
2196        _TreeLocation = "user/user.html"
2197        DocumentationWindow(self, -1, _TreeLocation, "",
2198                            "SasView Documentation")
2199
2200    def set_manager(self, manager):
2201        """
2202        Sets the application manager for this frame
2203
2204        :param manager: frame manager
2205        """
2206        self.app_manager = manager
2207
2208    def post_init(self):
2209        """
2210        This initialization method is called after the GUI
2211        has been created and all plug-ins loaded. It calls
2212        the post_init() method of each plug-in (if it exists)
2213        so that final initialization can be done.
2214        """
2215        for item in self.plugins:
2216            if hasattr(item, "post_init"):
2217                item.post_init()
2218
2219    def set_perspective(self, panels):
2220        """
2221        Sets the perspective of the GUI.
2222        Opens all the panels in the list, and closes
2223        all the others.
2224
2225        :param panels: list of panels
2226        """
2227        for item in self.panels.keys():
2228            # Check whether this is a sticky panel
2229            if hasattr(self.panels[item], "ALWAYS_ON"):
2230                if self.panels[item].ALWAYS_ON:
2231                    continue
2232            if self.panels[item] is None:
2233                continue
2234            if self.panels[item].window_name in panels:
2235                frame = self.panels[item].get_frame()
2236                if not frame.IsShown():
2237                    frame.Show(True)
2238            else:
2239                # always show the data panel if enable
2240                style = self.__gui_style & GUIFRAME.MANAGER_ON
2241                if (style == GUIFRAME.MANAGER_ON) \
2242                        and self.panels[item] == self._data_panel:
2243                    if 'data_panel' in self.panels.keys():
2244                        frame = self.panels['data_panel'].get_frame()
2245                        if frame is None:
2246                            continue
2247                        flag = frame.IsShown()
2248                        frame.Show(flag)
2249                else:
2250                    frame = self.panels[item].get_frame()
2251                    if frame is None:
2252                        continue
2253
2254                    if frame.IsShown():
2255                        frame.Show(False)
2256
2257    def show_data_panel(self, event=None, action=True):
2258        """
2259        show the data panel
2260        """
2261        if self._data_panel_menu is None:
2262            return
2263        label = self._data_panel_menu.GetText()
2264        pane = self.panels["data_panel"]
2265        frame = pane.get_frame()
2266        if label == 'Show Data Explorer':
2267            if action:
2268                frame.Show(True)
2269            self.__gui_style = self.__gui_style | GUIFRAME.MANAGER_ON
2270            self._data_panel_menu.SetText('Hide Data Explorer')
2271        else:
2272            if action:
2273                frame.Show(False)
2274            self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON)
2275            self._data_panel_menu.SetText('Show Data Explorer')
2276
2277    def add_data_helper(self, data_list):
2278        """
2279        """
2280        if self._data_manager is not None:
2281            self._data_manager.add_data(data_list)
2282
2283    def add_data(self, data_list):
2284        """
2285        receive a dictionary of data from loader
2286        store them its data manager if possible
2287        send to data the current active perspective if the data panel
2288        is not active.
2289        :param data_list: dictionary of data's ID and value Data
2290        """
2291        # Store data into manager
2292        self.add_data_helper(data_list)
2293        # set data in the data panel
2294        if self._data_panel is not None:
2295            data_state = self._data_manager.get_data_state(data_list.keys())
2296            self._data_panel.load_data_list(data_state)
2297        # if the data panel is shown wait for the user to press a button
2298        # to send data to the current perspective. if the panel is not
2299        # show  automatically send the data to the current perspective
2300        style = self.__gui_style & GUIFRAME.MANAGER_ON
2301        if style == GUIFRAME.MANAGER_ON:
2302            # wait for button press from the data panel to set_data
2303            if self._data_panel is not None:
2304                self._data_panel.frame.Show(True)
2305        else:
2306            # automatically send that to the current perspective
2307            self.set_data(data_id=data_list.keys())
2308
2309    def set_data(self, data_id, theory_id=None):
2310        """
2311        set data to current perspective
2312        """
2313        list_data, _ = self._data_manager.get_by_id(data_id)
2314        if self._current_perspective is not None:
2315            self._current_perspective.set_data(list_data.values())
2316
2317        else:
2318            msg = "Guiframe does not have a current perspective"
2319            logger.info(msg)
2320
2321    def set_theory(self, state_id, theory_id=None):
2322        """
2323        """
2324        _, list_theory = self._data_manager.get_by_id(theory_id)
2325        if self._current_perspective is not None:
2326            try:
2327                self._current_perspective.set_theory(list_theory.values())
2328            except:
2329                msg = "Guiframe set_theory: \n" + str(sys.exc_value)
2330                logger.info(msg)
2331                wx.PostEvent(self, StatusEvent(status=msg, info="error"))
2332        else:
2333            msg = "Guiframe does not have a current perspective"
2334            logger.info(msg)
2335
2336    def plot_data(self, state_id, data_id=None,
2337                  theory_id=None, append=False):
2338        """
2339        send a list of data to plot
2340        """
2341        data_list, _ = self._data_manager.get_by_id(data_id)
2342        _, temp_list_theory = self._data_manager.get_by_id(theory_id)
2343        total_plot_list = data_list.values()
2344        for item in temp_list_theory.values():
2345            theory_data, theory_state = item
2346            total_plot_list.append(theory_data)
2347        GROUP_ID = wx.NewId()
2348        for new_plot in total_plot_list:
2349            if append:
2350                if self.panel_on_focus is None:
2351                    message = "cannot append plot. No plot panel on focus!"
2352                    message += "please click on any available plot to set focus"
2353                    wx.PostEvent(self, StatusEvent(status=message,
2354                                                   info='warning'))
2355                    return
2356                else:
2357                    if self.enable_add_data(new_plot):
2358                        new_plot.group_id = self.panel_on_focus.group_id
2359                    else:
2360                        message = "Only 1D Data can be append to"
2361                        message += " plot panel containing 1D data.\n"
2362                        message += "%s not be appended.\n" % str(new_plot.name)
2363                        message += "try new plot option.\n"
2364                        wx.PostEvent(self, StatusEvent(status=message,
2365                                                       info='warning'))
2366            else:
2367                # if not append then new plot
2368                from sas.sasgui.guiframe.dataFitting import Data2D
2369                if issubclass(Data2D, new_plot.__class__):
2370                    # for 2 D always plot in a separated new plot
2371                    new_plot.group_id = wx.NewId()
2372                else:
2373                    # plot all 1D in a new plot
2374                    new_plot.group_id = GROUP_ID
2375            title = "PLOT " + str(new_plot.title)
2376            wx.PostEvent(self, NewPlotEvent(plot=new_plot,
2377                                            title=title,
2378                                            group_id=new_plot.group_id))
2379
2380    def remove_data(self, data_id, theory_id=None):
2381        """
2382        Delete data state if data_id is provide
2383        delete theory created with data of id data_id if theory_id is provide
2384        if delete all true: delete the all state
2385        else delete theory
2386        """
2387        temp = data_id + theory_id
2388        for plug in self.plugins:
2389            plug.delete_data(temp)
2390        data_list, _ = self._data_manager.get_by_id(data_id)
2391        _, temp_list_theory = self._data_manager.get_by_id(theory_id)
2392        total_plot_list = data_list.values()
2393        for item in temp_list_theory.values():
2394            theory_data, theory_state = item
2395            total_plot_list.append(theory_data)
2396        for new_plot in total_plot_list:
2397            for group_id in new_plot.list_group_id:
2398                wx.PostEvent(self, NewPlotEvent(id=new_plot.id,
2399                                                group_id=group_id,
2400                                                action='remove'))
2401                wx.CallAfter(self._remove_res_plot, new_plot.id)
2402        self._data_manager.delete_data(data_id=data_id,
2403                                       theory_id=theory_id)
2404
2405    def _remove_res_plot(self, id):
2406        """
2407        Try to remove corresponding res plot
2408
2409        : param id: id of the data
2410        """
2411        try:
2412            wx.PostEvent(self, NewPlotEvent(id=("res" + str(id)),
2413                                            group_id=("res" + str(id)),
2414                                            action='remove'))
2415        except:
2416            logger.error(sys.exc_value)
2417
2418    def save_data1d(self, data, fname):
2419        """
2420        Save data dialog
2421        """
2422        default_name = fname
2423        wildcard = "Text files (*.txt)|*.txt|"\
2424                    "CanSAS 1D files(*.xml)|*.xml"
2425        path = None
2426        dlg = wx.FileDialog(self, "Choose a file",
2427                            self._default_save_location,
2428                            default_name, wildcard, wx.SAVE)
2429
2430        if dlg.ShowModal() == wx.ID_OK:
2431            path = dlg.GetPath()
2432            # ext_num = 0 for .txt, ext_num = 1 for .xml
2433            # This is MAC Fix
2434            ext_num = dlg.GetFilterIndex()
2435            if ext_num == 0:
2436                ext_format = '.txt'
2437            else:
2438                ext_format = '.xml'
2439            path = os.path.splitext(path)[0] + ext_format
2440            mypath = os.path.basename(path)
2441
2442            # Instantiate a loader
2443            loader = Loader()
2444            ext_format = ".txt"
2445            if os.path.splitext(mypath)[1].lower() == ext_format:
2446                # Make sure the ext included in the file name
2447                # especially on MAC
2448                fName = os.path.splitext(path)[0] + ext_format
2449                self._onsaveTXT(data, fName)
2450            ext_format = ".xml"
2451            if os.path.splitext(mypath)[1].lower() == ext_format:
2452                # Make sure the ext included in the file name
2453                # especially on MAC
2454                fName = os.path.splitext(path)[0] + ext_format
2455                loader.save(fName, data, ext_format)
2456            try:
2457                self._default_save_location = os.path.dirname(path)
2458            except:
2459                pass
2460        dlg.Destroy()
2461
2462    def _onsaveTXT(self, data, path):
2463        """
2464        Save file as txt
2465
2466        .. todo:: Refactor and remove this method. See 'TODO' in _onSave.
2467        """
2468        if path is not None:
2469            out = open(path, 'w')
2470            has_errors = True
2471            if data.dy is None or data.dy == []:
2472                has_errors = False
2473            # Sanity check
2474            if has_errors:
2475                try:
2476                    if len(data.y) != len(data.dy):
2477                        has_errors = False
2478                except:
2479                    has_errors = False
2480            if has_errors:
2481                if data.dx is not None and data.dx != []:
2482                    out.write("<X>   <Y>   <dY>   <dX>\n")
2483                else:
2484                    out.write("<X>   <Y>   <dY>\n")
2485            else:
2486                out.write("<X>   <Y>\n")
2487
2488            for i in range(len(data.x)):
2489                if has_errors:
2490                    if data.dx is not None and data.dx != []:
2491                        if data.dx[i] is not None:
2492                            out.write("%g  %g  %g  %g\n" % (data.x[i],
2493                                                            data.y[i],
2494                                                            data.dy[i],
2495                                                            data.dx[i]))
2496                        else:
2497                            out.write("%g  %g  %g\n" % (data.x[i],
2498                                                        data.y[i],
2499                                                        data.dy[i]))
2500                    else:
2501                        out.write("%g  %g  %g\n" % (data.x[i],
2502                                                    data.y[i],
2503                                                    data.dy[i]))
2504                else:
2505                    out.write("%g  %g\n" % (data.x[i],
2506                                            data.y[i]))
2507            out.close()
2508
2509    def show_data1d(self, data, name):
2510        """
2511        Show data dialog
2512        """
2513        try:
2514            xmin = min(data.x)
2515            ymin = min(data.y)
2516        except:
2517            msg = "Unable to find min/max of \n data named %s" % \
2518                        data.filename
2519            wx.PostEvent(self, StatusEvent(status=msg,
2520                                           info="error"))
2521            raise ValueError, msg
2522        # text = str(data)
2523        text = data.__str__()
2524        text += 'Data Min Max:\n'
2525        text += 'X_min = %s:  X_max = %s\n' % (xmin, max(data.x))
2526        text += 'Y_min = %s:  Y_max = %s\n' % (ymin, max(data.y))
2527        if data.dy is not None:
2528            text += 'dY_min = %s:  dY_max = %s\n' % (min(data.dy), max(data.dy))
2529        text += '\nData Points:\n'
2530        x_st = "X"
2531        for index in range(len(data.x)):
2532            if data.dy is not None and len(data.dy) > index:
2533                dy_val = data.dy[index]
2534            else:
2535                dy_val = 0.0
2536            if data.dx is not None and len(data.dx) > index:
2537                dx_val = data.dx[index]
2538            else:
2539                dx_val = 0.0
2540            if data.dxl is not None and len(data.dxl) > index:
2541                if index == 0:
2542                    x_st = "Xl"
2543                dx_val = data.dxl[index]
2544            elif data.dxw is not None and len(data.dxw) > index:
2545                if index == 0:
2546                    x_st = "Xw"
2547                dx_val = data.dxw[index]
2548
2549            if index == 0:
2550                text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st
2551            text += "%s \t%s \t%s \t%s \t%s\n" % (index,
2552                                                  data.x[index],
2553                                                  data.y[index],
2554                                                  dy_val,
2555                                                  dx_val)
2556        from pdfview import TextFrame
2557        frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2558        # put icon
2559        self.put_icon(frame)
2560        frame.Show(True)
2561
2562    def save_data2d(self, data, fname):
2563        """
2564        Save data2d dialog
2565        """
2566        default_name = fname
2567        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT"
2568        dlg = wx.FileDialog(self, "Choose a file",
2569                            self._default_save_location,
2570                            default_name, wildcard, wx.SAVE)
2571
2572        if dlg.ShowModal() == wx.ID_OK:
2573            path = dlg.GetPath()
2574            # ext_num = 0 for .txt, ext_num = 1 for .xml
2575            # This is MAC Fix
2576            ext_num = dlg.GetFilterIndex()
2577            if ext_num == 0:
2578                ext_format = '.dat'
2579            else:
2580                ext_format = ''
2581            path = os.path.splitext(path)[0] + ext_format
2582            mypath = os.path.basename(path)
2583
2584            # Instantiate a loader
2585            loader = Loader()
2586
2587            ext_format = ".dat"
2588            if os.path.splitext(mypath)[1].lower() == ext_format:
2589                # Make sure the ext included in the file name
2590                # especially on MAC
2591                fileName = os.path.splitext(path)[0] + ext_format
2592                loader.save(fileName, data, ext_format)
2593            try:
2594                self._default_save_location = os.path.dirname(path)
2595            except:
2596                pass
2597        dlg.Destroy()
2598
2599    def show_data2d(self, data, name):
2600        """
2601        Show data dialog
2602        """
2603        wx.PostEvent(self, StatusEvent(status="Gathering Data2D Info.",
2604                                       type='start'))
2605        text = data.__str__()
2606        text += 'Data Min Max:\n'
2607        text += 'I_min = %s\n' % min(data.data)
2608        text += 'I_max = %s\n\n' % max(data.data)
2609        text += 'Data (First 2501) Points:\n'
2610        text += 'Data columns include err(I).\n'
2611        text += 'ASCII data starts here.\n'
2612        text += "<index> \t<Qx> \t<Qy> \t<I> \t<dI> \t<dQparal> \t<dQperp>\n"
2613        di_val = 0.0
2614        dx_val = 0.0
2615        dy_val = 0.0
2616        len_data = len(data.qx_data)
2617        for index in xrange(0, len_data):
2618            x_val = data.qx_data[index]
2619            y_val = data.qy_data[index]
2620            i_val = data.data[index]
2621            if data.err_data is not None:
2622                di_val = data.err_data[index]
2623            if data.dqx_data is not None:
2624                dx_val = data.dqx_data[index]
2625            if data.dqy_data is not None:
2626                dy_val = data.dqy_data[index]
2627
2628            text += "%s \t%s \t%s \t%s \t%s \t%s \t%s\n" % (index,
2629                                                            x_val,
2630                                                            y_val,
2631                                                            i_val,
2632                                                            di_val,
2633                                                            dx_val,
2634                                                            dy_val)
2635            # Takes too long time for typical data2d: Break here
2636            if index >= 2500:
2637                text += ".............\n"
2638                break
2639
2640        from pdfview import TextFrame
2641        frame = TextFrame(None, -1, "Data Info: %s" % data.name, text)
2642        # put icon
2643        self.put_icon(frame)
2644        frame.Show(True)
2645        wx.PostEvent(self, StatusEvent(status="Data2D Info Displayed",
2646                                       type='stop'))
2647
2648    def set_current_perspective(self, perspective):
2649        """
2650        set the current active perspective
2651        """
2652        self._current_perspective = perspective
2653        name = "No current analysis selected"
2654        if self._current_perspective is not None:
2655            self._add_current_plugin_menu()
2656            for panel in self.panels.values():
2657                if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE:
2658                    for name in self._current_perspective.get_perspective():
2659                        frame = panel.get_frame()
2660                        if frame is not None:
2661                            if name == panel.window_name:
2662                                panel.on_set_focus(event=None)
2663                                frame.Show(True)
2664                            else:
2665                                frame.Show(False)
2666            name = self._current_perspective.sub_menu
2667            if self._data_panel is not None:
2668                self._data_panel.set_active_perspective(name)
2669                self._check_applications_menu()
2670            # Set the SasView title
2671            self._set_title_name(name)
2672
2673    def _set_title_name(self, name):
2674        """
2675        Set the SasView title w/ the current application name
2676
2677        : param name: application name [string]
2678        """
2679        # Set SanView Window title w/ application anme
2680        title = self.title + "  - " + name + " -"
2681        self.SetTitle(title)
2682
2683    def _check_applications_menu(self):
2684        """
2685        check the menu of the current application
2686        """
2687        if self._applications_menu is not None:
2688            for menu in self._applications_menu.GetMenuItems():
2689                if self._current_perspective is not None:
2690                    name = self._current_perspective.sub_menu
2691                    if menu.IsCheckable():
2692                        if menu.GetLabel() == name:
2693                            menu.Check(True)
2694                        else:
2695                            menu.Check(False)
2696
2697    def enable_add_data(self, new_plot):
2698        """
2699        Enable append data on a plot panel
2700        """
2701
2702        if self.panel_on_focus \
2703                not in self._plotting_plugin.plot_panels.values():
2704            return
2705        check = "Theory1D"
2706        is_theory = len(self.panel_on_focus.plots) <= 1 and \
2707            self.panel_on_focus.plots.values()[0].__class__.__name__ == check
2708
2709        is_data2d = hasattr(new_plot, 'data')
2710
2711        is_data1d = self.panel_on_focus.__class__.__name__ == "ModelPanel1D"\
2712            and self.panel_on_focus.group_id is not None
2713        has_meta_data = hasattr(new_plot, 'meta_data')
2714
2715        # disable_add_data if the data is being recovered from  a saved state
2716        is_state_data = False
2717        if has_meta_data:
2718            if 'invstate' in new_plot.meta_data:
2719                is_state_data = True
2720            if 'prstate' in new_plot.meta_data:
2721                is_state_data = True
2722            if 'fitstate' in new_plot.meta_data:
2723                is_state_data = True
2724
2725        return is_data1d and not is_data2d and not is_theory \
2726               and not is_state_data
2727
2728    def check_multimode(self, perspective=None):
2729        """
2730        Check the perspective have batch mode capablitity
2731        """
2732        if perspective is None or self._data_panel is None:
2733            return
2734        flag = perspective.get_batch_capable()
2735        flag_on = perspective.batch_on
2736        if flag:
2737            self._data_panel.rb_single_mode.SetValue(not flag_on)
2738            self._data_panel.rb_batch_mode.SetValue(flag_on)
2739        else:
2740            self._data_panel.rb_single_mode.SetValue(True)
2741            self._data_panel.rb_batch_mode.SetValue(False)
2742        self._data_panel.rb_single_mode.Enable(flag)
2743        self._data_panel.rb_batch_mode.Enable(flag)
2744
2745    def enable_edit_menu(self):
2746        """
2747        enable menu item under edit menu depending on the panel on focus
2748        """
2749        if self.cpanel_on_focus is not None and self._edit_menu is not None:
2750            flag = self.cpanel_on_focus.get_undo_flag()
2751            self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2752            flag = self.cpanel_on_focus.get_redo_flag()
2753            self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2754            flag = self.cpanel_on_focus.get_copy_flag()
2755            self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2756            flag = self.cpanel_on_focus.get_paste_flag()
2757            self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2758
2759            # Copy menu
2760            flag = self.cpanel_on_focus.get_copy_flag()
2761            self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYEX_ID, flag)
2762            self._edit_menu_copyas.Enable(GUIFRAME_ID.COPYLAT_ID, flag)
2763
2764            flag = self.cpanel_on_focus.get_preview_flag()
2765            self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2766            flag = self.cpanel_on_focus.get_reset_flag()
2767            self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2768        else:
2769            flag = False
2770            self._edit_menu.Enable(GUIFRAME_ID.UNDO_ID, flag)
2771            self._edit_menu.Enable(GUIFRAME_ID.REDO_ID, flag)
2772            self._edit_menu.Enable(GUIFRAME_ID.COPY_ID, flag)
2773            self._edit_menu.Enable(GUIFRAME_ID.PASTE_ID, flag)
2774            self._edit_menu.Enable(GUIFRAME_ID.PREVIEW_ID, flag)
2775            self._edit_menu.Enable(GUIFRAME_ID.RESET_ID, flag)
2776
2777    def on_undo_panel(self, event=None):
2778        """
2779        undo previous action of the last panel on focus if possible
2780        """
2781        if self.cpanel_on_focus is not None:
2782            self.cpanel_on_focus.on_undo(event)
2783
2784    def on_redo_panel(self, event=None):
2785        """
2786        redo the last cancel action done on the last panel on focus
2787        """
2788        if self.cpanel_on_focus is not None:
2789            self.cpanel_on_focus.on_redo(event)
2790
2791    def on_copy_panel(self, event=None):
2792        """
2793        copy the last panel on focus if possible
2794        """
2795        if self.cpanel_on_focus is not None:
2796            self.cpanel_on_focus.on_copy(event)
2797
2798    def on_paste_panel(self, event=None):
2799        """
2800        paste clipboard to the last panel on focus
2801        """
2802        if self.cpanel_on_focus is not None:
2803            self.cpanel_on_focus.on_paste(event)
2804
2805    def on_bookmark_panel(self, event=None):
2806        """
2807        bookmark panel
2808        """
2809        if self.cpanel_on_focus is not None:
2810            self.cpanel_on_focus.on_bookmark(event)
2811
2812    def append_bookmark(self, event=None):
2813        """
2814        Bookmark available information of the panel on focus
2815        """
2816        self._toolbar.append_bookmark(event)
2817
2818    def on_save_panel(self, event=None):
2819        """
2820        save possible information on the current panel
2821        """
2822        if self.cpanel_on_focus is not None:
2823            self.cpanel_on_focus.on_save(event)
2824
2825    def on_preview_panel(self, event=None):
2826        """
2827        preview information on the panel on focus
2828        """
2829        if self.cpanel_on_focus is not None:
2830            self.cpanel_on_focus.on_preview(event)
2831
2832    def on_print_panel(self, event=None):
2833        """
2834        print available information on the last panel on focus
2835        """
2836        if self.cpanel_on_focus is not None:
2837            self.cpanel_on_focus.on_print(event)
2838
2839    def on_zoom_panel(self, event=None):
2840        """
2841        zoom on the current panel if possible
2842        """
2843        if self.cpanel_on_focus is not None:
2844            self.cpanel_on_focus.on_zoom(event)
2845
2846    def on_zoom_in_panel(self, event=None):
2847        """
2848        zoom in of the panel on focus
2849        """
2850        if self.cpanel_on_focus is not None:
2851            self.cpanel_on_focus.on_zoom_in(event)
2852
2853    def on_zoom_out_panel(self, event=None):
2854        """
2855        zoom out on the panel on focus
2856        """
2857        if self.cpanel_on_focus is not None:
2858            self.cpanel_on_focus.on_zoom_out(event)
2859
2860    def on_drag_panel(self, event=None):
2861        """
2862        drag apply to the panel on focus
2863        """
2864        if self.cpanel_on_focus is not None:
2865            self.cpanel_on_focus.on_drag(event)
2866
2867    def on_reset_panel(self, event=None):
2868        """
2869        reset the current panel
2870        """
2871        if self.cpanel_on_focus is not None:
2872            self.cpanel_on_focus.on_reset(event)
2873
2874    def on_change_caption(self, name, old_caption, new_caption):
2875        """
2876        Change the panel caption
2877
2878        :param name: window_name of the pane
2879        :param old_caption: current caption [string]
2880        :param new_caption: new caption [string]
2881        """
2882        # wx.aui.AuiPaneInfo
2883        pane_info = self.get_paneinfo(old_caption)
2884        # update the data_panel.cb_plotpanel
2885        if 'data_panel' in self.panels.keys():
2886            # remove from data_panel combobox
2887            data_panel = self.panels["data_panel"]
2888            if data_panel.cb_plotpanel is not None:
2889                # Check if any panel has the same caption
2890                has_newstring = data_panel.cb_plotpanel.FindString(
2891                    str(new_caption))
2892                caption = new_caption
2893                if has_newstring != wx.NOT_FOUND:
2894                    captions = self._get_plotpanel_captions()
2895                    # Append nummber
2896                    inc = 1
2897                    # FIXME: fix this terrible loop
2898                    while (1):
2899                        caption = new_caption + '_%s' % str(inc)
2900                        if caption not in captions:
2901                            break
2902                        inc += 1
2903                    # notify to users
2904                    msg = "Found Same Title: Added '_%s'" % str(inc)
2905                    wx.PostEvent(self, StatusEvent(status=msg))
2906                # update data_panel cb
2907                pos = data_panel.cb_plotpanel.FindString(str(old_caption))
2908                if pos != wx.NOT_FOUND:
2909                    data_panel.cb_plotpanel.SetString(pos, caption)
2910                    data_panel.cb_plotpanel.SetStringSelection(caption)
2911        # New Caption
2912        pane_info.SetTitle(caption)
2913        return caption
2914
2915    def get_paneinfo(self, name):
2916        """
2917        Get pane Caption from window_name
2918
2919        :param name: window_name in AuiPaneInfo
2920        :returns: AuiPaneInfo of the name
2921        """
2922        for panel in self.plot_panels.values():
2923            if panel.frame.GetTitle() == name:
2924                return panel.frame
2925        return None
2926
2927    def enable_undo(self):
2928        """
2929        enable undo related control
2930        """
2931        if self.cpanel_on_focus is not None:
2932            self._toolbar.enable_undo(self.cpanel_on_focus)
2933
2934    def enable_redo(self):
2935        """
2936        enable redo
2937        """
2938        if self.cpanel_on_focus is not None:
2939            self._toolbar.enable_redo(self.cpanel_on_focus)
2940
2941    def enable_copy(self):
2942        """
2943        enable copy related control
2944        """
2945        if self.cpanel_on_focus is not None:
2946            self._toolbar.enable_copy(self.cpanel_on_focus)
2947
2948    def enable_paste(self):
2949        """
2950        enable paste
2951        """
2952        if self.cpanel_on_focus is not None:
2953            self._toolbar.enable_paste(self.cpanel_on_focus)
2954
2955    def enable_bookmark(self):
2956        """
2957        Bookmark
2958        """
2959        if self.cpanel_on_focus is not None:
2960            self._toolbar.enable_bookmark(self.cpanel_on_focus)
2961
2962    def enable_save(self):
2963        """
2964        save
2965        """
2966        if self.cpanel_on_focus is not None:
2967            self._toolbar.enable_save(self.cpanel_on_focus)
2968
2969    def enable_preview(self):
2970        """
2971        preview
2972        """
2973        if self.cpanel_on_focus is not None:
2974            self._toolbar.enable_preview(self.cpanel_on_focus)
2975
2976    def enable_print(self):
2977        """
2978        print
2979        """
2980        if self.cpanel_on_focus is not None:
2981            self._toolbar.enable_print(self.cpanel_on_focus)
2982
2983    def enable_zoom(self):
2984        """
2985        zoom
2986        """
2987        if self.cpanel_on_focus is not None:
2988            self._toolbar.enable_zoom(self.panel_on_focus)
2989
2990    def enable_zoom_in(self):
2991        """
2992        zoom in
2993        """
2994        if self.cpanel_on_focus is not None:
2995            self._toolbar.enable_zoom_in(self.panel_on_focus)
2996
2997    def enable_zoom_out(self):
2998        """
2999        zoom out
3000        """
3001        if self.cpanel_on_focus is not None:
3002            self._toolbar.enable_zoom_out(self.panel_on_focus)
3003
3004    def enable_drag(self, event=None):
3005        """
3006        drag
3007        """
3008        # Not implemeted
3009
3010    def enable_reset(self):
3011        """
3012        reset the current panel
3013        """
3014        if self.cpanel_on_focus is not None:
3015            self._toolbar.enable_reset(self.panel_on_focus)
3016
3017    def get_toolbar_height(self):
3018        """
3019        """
3020        size_y = 0
3021        if self.GetToolBar() is not None and self.GetToolBar().IsShown():
3022            if not IS_LINUX:
3023                _, size_y = self.GetToolBar().GetSizeTuple()
3024        return size_y
3025
3026    def set_schedule_full_draw(self, panel=None, func='del'):
3027        """
3028        Add/subtract the schedule full draw list with the panel given
3029
3030        :param panel: plot panel
3031        :param func: append or del [string]
3032        """
3033
3034        # append this panel in the schedule list if not in yet
3035        if func == 'append':
3036            if panel not in self.schedule_full_draw_list:
3037                self.schedule_full_draw_list.append(panel)
3038        # remove this panel from schedule list
3039        elif func == 'del':
3040            if len(self.schedule_full_draw_list) > 0:
3041                if panel in self.schedule_full_draw_list:
3042                    self.schedule_full_draw_list.remove(panel)
3043
3044        # reset the schdule
3045        if len(self.schedule_full_draw_list) == 0:
3046            self.schedule = False
3047        else:
3048            self.schedule = True
3049
3050    def full_draw(self):
3051        """
3052        Draw the panels with axes in the schedule to full dwar list
3053        """
3054
3055        count = len(self.schedule_full_draw_list)
3056        # if not self.schedule:
3057        if count < 1:
3058            self.set_schedule(False)
3059            return
3060
3061        else:
3062            ind = 0
3063            # if any of the panel is shown do full_draw
3064            for panel in self.schedule_full_draw_list:
3065                ind += 1
3066                if panel.frame.IsShown():
3067                    break
3068                # otherwise, return
3069                if ind == count:
3070                    return
3071        # Simple redraw only for a panel shown
3072
3073        def f_draw(panel):
3074            """
3075            Draw A panel in the full draw list
3076            """
3077            try:
3078                # This checking of GetCapture is to stop redrawing
3079                # while any panel is capture.
3080                frame = panel.frame
3081
3082                if not frame.GetCapture():
3083                    # draw if possible
3084                    panel.set_resizing(False)
3085                    # panel.Show(True)
3086                    panel.draw_plot()
3087                # Check if the panel is not shown
3088                flag = frame.IsShown()
3089                frame.Show(flag)
3090            except:
3091                pass
3092
3093        # Draw all panels
3094        if count == 1:
3095            f_draw(self.schedule_full_draw_list[0])
3096        else:
3097            map(f_draw, self.schedule_full_draw_list)
3098        # Reset the attr
3099        if len(self.schedule_full_draw_list) == 0:
3100            self.set_schedule(False)
3101        else:
3102            self.set_schedule(True)
3103
3104    def set_schedule(self, schedule=False):
3105        """
3106        Set schedule
3107        """
3108        self.schedule = schedule
3109
3110    def get_schedule(self):
3111        """
3112        Get schedule
3113        """
3114        return self.schedule
3115
3116    def on_set_plot_focus(self, panel):
3117        """
3118        Set focus on a plot panel
3119        """
3120        if panel is None:
3121            return
3122        # self.set_plot_unfocus()
3123        panel.on_set_focus(None)
3124        # set focusing panel
3125        self.panel_on_focus = panel
3126        self.set_panel_on_focus(None)
3127
3128    def set_plot_unfocus(self):
3129        """
3130        Un focus all plot panels
3131        """
3132        for plot in self.plot_panels.values():
3133            plot.on_kill_focus(None)
3134
3135    def get_window_size(self):
3136        """
3137        Get window size
3138
3139        :returns: size
3140        :rtype: tuple
3141        """
3142        width, height = self.GetSizeTuple()
3143        if not IS_WIN:
3144            # Subtract toolbar height to get real window side
3145            if self._toolbar.IsShown():
3146                height -= 45
3147        return (width, height)
3148
3149    def _onDrawIdle(self, *args, **kwargs):
3150        """
3151        ReDraw with axes
3152        """
3153        try:
3154            # check if it is time to redraw
3155            if self.GetCapture() is None:
3156                # Draw plot, changes resizing too
3157                self.full_draw()
3158        except:
3159            pass
3160
3161        # restart idle
3162        self._redraw_idle(*args, **kwargs)
3163
3164    def _redraw_idle(self, *args, **kwargs):
3165        """
3166        Restart Idle
3167        """
3168        # restart idle
3169        self.idletimer.Restart(100 * TIME_FACTOR, *args, **kwargs)
3170
3171
3172class DefaultPanel(wx.Panel, PanelBase):
3173    """
3174    Defines the API for a panels to work with
3175    the GUI manager
3176    """
3177    # Internal nickname for the window, used by the AUI manager
3178    window_name = "default"
3179    # Name to appear on the window title bar
3180    window_caption = "Welcome panel"
3181    # Flag to tell the AUI manager to put this panel in the center pane
3182    CENTER_PANE = True
3183
3184    def __init__(self, parent, *args, **kwds):
3185        wx.Panel.__init__(self, parent, *args, **kwds)
3186        PanelBase.__init__(self, parent)
3187
3188
3189class SasViewApp(wx.App):
3190    """
3191    SasView application
3192    """
3193    def OnInit(self):
3194        """
3195        When initialised
3196        """
3197        pos, size, self.is_max = self.window_placement((GUIFRAME_WIDTH,
3198                                                        GUIFRAME_HEIGHT))
3199        self.frame = ViewerFrame(parent=None,
3200                                 title=APPLICATION_NAME,
3201                                 pos=pos,
3202                                 gui_style=DEFAULT_STYLE,
3203                                 size=size)
3204        self.frame.Hide()
3205        if not IS_WIN:
3206            self.frame.EnableCloseButton(False)
3207        self.s_screen = None
3208
3209        try:
3210            self.open_file()
3211        except:
3212            msg = "%s Could not load " % str(APPLICATION_NAME)
3213            msg += "input file from command line.\n"
3214            logger.error(msg)
3215        # Display a splash screen on top of the frame.
3216        try:
3217            if os.path.isfile(SPLASH_SCREEN_PATH):
3218                self.s_screen = \
3219                    self.display_splash_screen(parent=self.frame,
3220                                               path=SPLASH_SCREEN_PATH)
3221            else:
3222                self.frame.Show()
3223        except:
3224            if self.s_screen is not None:
3225                self.s_screen.Close()
3226            msg = "Cannot display splash screen\n"
3227            msg += str(sys.exc_value)
3228            logger.error(msg)
3229            self.frame.Show()
3230
3231        self.SetTopWindow(self.frame)
3232
3233        return True
3234
3235    def maximize_win(self):
3236        """
3237        Maximize the window after the frame shown
3238        """
3239        if self.is_max:
3240            if self.frame.IsShown():
3241                # Max window size
3242                self.frame.Maximize(self.is_max)
3243
3244    def open_file(self):
3245        """
3246        open a state file at the start of the application
3247        """
3248        input_file = None
3249        if len(sys.argv) >= 2:
3250            cmd = sys.argv[0].lower()
3251            basename = os.path.basename(cmd)
3252            app_base = str(APPLICATION_NAME).lower()
3253            if os.path.isfile(cmd) or basename.lower() == app_base:
3254                app_py = app_base + '.py'
3255                app_exe = app_base + '.exe'
3256                app_app = app_base + '.app'
3257                if basename.lower() in [app_py, app_exe, app_app, app_base]:
3258                    data_base = sys.argv[1]
3259                    input_file = os.path.normpath(os.path.join(get_app_dir(),
3260                                                               data_base))
3261        if input_file is None:
3262            return
3263        if self.frame is not None:
3264            self.frame.set_input_file(input_file=input_file)
3265
3266    def clean_plugin_models(self, path):
3267        """
3268        Delete plugin models  in app folder
3269
3270        :param path: path of the plugin_models folder in app
3271        """
3272        # do it only the first time app loaded
3273        # delete unused model folder
3274        model_folder = os.path.join(get_app_dir(), path)
3275        if os.path.exists(model_folder) and os.path.isdir(model_folder):
3276            if len(os.listdir(model_folder)) > 0:
3277                try:
3278                    for filename in os.listdir(model_folder):
3279                        file_path = os.path.join(model_folder, filename)
3280                        if os.path.isfile(file_path):
3281                            os.remove(file_path)
3282                except:
3283                    logger.error("gui_manager.clean_plugin_models:\n  %s"
3284                                  % sys.exc_value)
3285
3286    def set_manager(self, manager):
3287        """
3288        Sets a reference to the application manager
3289        of the GUI manager (Frame)
3290        """
3291        self.frame.set_manager(manager)
3292
3293    def build_gui(self):
3294        """
3295        Build the GUI
3296        """
3297        # try to load file at the start
3298        self.open_file()
3299        self.frame.build_gui()
3300
3301    def set_welcome_panel(self, panel_class):
3302        """
3303        Set the welcome panel
3304
3305        :param panel_class: class of the welcome panel to be instantiated
3306
3307        """
3308        self.frame.welcome_panel_class = panel_class
3309
3310    def add_perspective(self, perspective):
3311        """
3312        Manually add a perspective to the application GUI
3313        """
3314        self.frame.add_perspective(perspective)
3315
3316    def window_placement(self, size):
3317        """
3318        Determines the position and size of the application frame such that it
3319        fits on the user's screen without obstructing (or being obstructed by)
3320        the Windows task bar.  The maximum initial size in pixels is bounded by
3321        WIDTH x HEIGHT.  For most monitors, the application
3322        will be centered on the screen; for very large monitors it will be
3323        placed on the left side of the screen.
3324        """
3325        is_maximized = False
3326        # Get size of screen without
3327        for screenCount in range(wx.Display().GetCount()):
3328            screen = wx.Display(screenCount)
3329            if screen.IsPrimary():
3330                displayRect = screen.GetClientArea()
3331                break
3332
3333        posX, posY, displayWidth, displayHeight = displayRect
3334        customWidth, customHeight = size
3335
3336        # If the custom size is default, set 90% of the screen size
3337        if customWidth <= 0 and customHeight <= 0:
3338            if customWidth == 0 and customHeight == 0:
3339                is_maximized = True
3340            customWidth = displayWidth * 0.9
3341            customHeight = displayHeight * 0.9
3342        else:
3343            # If the custom screen is bigger than the
3344            # window screen than make maximum size
3345            if customWidth > displayWidth:
3346                customWidth = displayWidth
3347            if customHeight > displayHeight:
3348                customHeight = displayHeight
3349
3350        # Note that when running Linux and using an Xming (X11) server on a PC
3351        # with a dual  monitor configuration, the reported display size may be
3352        # that of both monitors combined with an incorrect display count of 1.
3353        # To avoid displaying this app across both monitors, we check for
3354        # screen 'too big'.  If so, we assume a smaller width which means the
3355        # application will be placed towards the left hand side of the screen.
3356
3357        # If dual screen registered as 1 screen. Make width half.
3358        # MAC just follows the default behavior of pos
3359        if IS_WIN:
3360            if displayWidth > (displayHeight * 2):
3361                if customWidth == displayWidth:
3362                    customWidth = displayWidth / 2
3363                # and set the position to be the corner of the screen.
3364                posX = 0
3365                posY = 0
3366
3367            # Make the position the middle of the screen. (Not 0,0)
3368            else:
3369                posX = (displayWidth - customWidth) / 2
3370                posY = (displayHeight - customHeight) / 2
3371        # Return the suggested position and size for the application frame.
3372        return (posX, posY), (customWidth, customHeight), is_maximized
3373
3374    def display_splash_screen(self, parent,
3375                              path=SPLASH_SCREEN_PATH):
3376        """Displays the splash screen.  It will exactly cover the main frame."""
3377
3378        # Prepare the picture.  On a 2GHz intel cpu, this takes about a second.
3379        image = wx.Image(path, wx.BITMAP_TYPE_PNG)
3380        image.Rescale(SPLASH_SCREEN_WIDTH,
3381                      SPLASH_SCREEN_HEIGHT, wx.IMAGE_QUALITY_HIGH)
3382        bm = image.ConvertToBitmap()
3383
3384        # Create and show the splash screen.  It will disappear only when the
3385        # program has entered the event loop AND either the timeout has expired
3386        # or the user has left clicked on the screen.  Thus any processing
3387        # performed in this routine (including sleeping) or processing in the
3388        # calling routine (including doing imports) will prevent the splash
3389        # screen from disappearing.
3390        #
3391        # Note that on Linux, the timeout appears to occur immediately in which
3392        # case the splash screen disappears upon entering the event loop.
3393        s_screen = wx.SplashScreen(bitmap=bm,
3394                                   splashStyle=(wx.SPLASH_TIMEOUT |
3395                                                wx.SPLASH_CENTRE_ON_SCREEN),
3396                                   style=(wx.SIMPLE_BORDER |
3397                                          wx.FRAME_NO_TASKBAR |
3398                                          wx.FRAME_FLOAT_ON_PARENT),
3399                                   milliseconds=SS_MAX_DISPLAY_TIME,
3400                                   parent=parent,
3401                                   id=wx.ID_ANY)
3402        from sas.sasgui.guiframe.gui_statusbar import SPageStatusbar
3403        statusBar = SPageStatusbar(s_screen)
3404        s_screen.SetStatusBar(statusBar)
3405        s_screen.Bind(wx.EVT_CLOSE, self.on_close_splash_screen)
3406        s_screen.Show()
3407        return s_screen
3408
3409    def on_close_splash_screen(self, event):
3410        """
3411        When the splash screen is closed.
3412        """
3413        self.frame.Show(True)
3414        event.Skip()
3415        self.maximize_win()
3416
3417
3418class MDIFrame(CHILD_FRAME):
3419    """
3420    Frame for panels
3421    """
3422    def __init__(self, parent, panel, title="Untitled", size=(300, 200)):
3423        """
3424        comment
3425        :param parent: parent panel/container
3426        """
3427        # Initialize the Frame object
3428        CHILD_FRAME.__init__(self, parent=parent, id=wx.ID_ANY,
3429                             title=title, size=size)
3430        self.parent = parent
3431        self.name = "Untitled"
3432        self.batch_on = self.parent.batch_on
3433        self.panel = panel
3434        if panel is not None:
3435            self.set_panel(panel)
3436        self.Show(False)
3437
3438    def show_data_panel(self, action):
3439        """
3440        Turns on the data panel
3441
3442        The the data panel is optional.  Most of its functions can be
3443        performed from the menu bar and from the plots.
3444        """
3445        self.parent.show_data_panel(action)
3446
3447    def set_panel(self, panel):
3448        """
3449        """
3450        self.panel = panel
3451        self.name = panel.window_name
3452        self.SetTitle(panel.window_caption)
3453        self.SetHelpText(panel.help_string)
3454        width, height = self.parent._get_panels_size(panel)
3455        if hasattr(panel, "CENTER_PANE") and panel.CENTER_PANE:
3456            width *= 0.6
3457        self.SetSize((width, height))
3458        self.parent.put_icon(self)
3459        self.Bind(wx.EVT_SET_FOCUS, self.set_panel_focus)
3460        self.Bind(wx.EVT_CLOSE, self.OnClose)
3461        self.Show(False)
3462
3463    def set_panel_focus(self, event):
3464        """
3465        """
3466        if self.parent.panel_on_focus != self.panel:
3467            self.panel.SetFocus()
3468            self.parent.panel_on_focus = self.panel
3469
3470    def OnClose(self, event):
3471        """
3472        On Close event
3473        """
3474        self.panel.on_close(event)
3475
3476if __name__ == "__main__":
3477    app = SasViewApp(0)
3478    app.MainLoop()
Note: See TracBrowser for help on using the repository browser.