Changeset ae84427 in sasview


Ignore:
Timestamp:
Apr 20, 2013 7:14:41 PM (11 years ago)
Author:
Jae Cho <jhjcho@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
ba152f1
Parents:
d4895dd
Message:

mdi frames for main applications

Files:
32 edited

Legend:

Unmodified
Added
Removed

  • calculatorview/src/sans/perspectives/calculator/calculator.py

    r3e001f9 rae84427  
    1212################################################################################ 
    1313 
    14  
     14import wx 
    1515from sans.guiframe.plugin_base import PluginBase 
    1616from sans.perspectives.calculator.data_operator import DataOperatorWindow 
     17from sans.perspectives.calculator.data_editor import DataEditorWindow 
     18from sans.perspectives.calculator.kiessig_calculator_panel import KiessigWindow 
     19from sans.perspectives.calculator.sld_panel import SldWindow 
     20from sans.perspectives.calculator.density_panel import DensityWindow 
     21from sans.perspectives.calculator.slit_length_calculator_panel \ 
     22            import SlitLengthCalculatorWindow 
     23from sans.perspectives.calculator.resolution_calculator_panel \ 
     24            import ResolutionWindow 
     25from sans.perspectives.calculator.gen_scatter_panel import SasGenWindow 
     26from sans.perspectives.calculator.image_viewer import ImageView 
     27from sans.perspectives.calculator.pyconsole import PyConsole 
    1728import logging 
    1829 
    … …  
    2738        logging.info("Calculator plug-in started")    
    2839        self.sub_menu = "Tool"  
     40        self.data_edit_frame = None 
    2941        # data operator use one frame all the time 
    3042        self.data_operator_frame = None 
     43        self.kiessig_frame = None 
     44        self.sld_frame = None 
     45        self.cal_md_frame = None 
     46        self.cal_slit_frame = None 
     47        self.cal_res_frame = None 
     48        self.gen_frame = None 
     49        self.image_view = None 
     50        self.py_frame = None 
     51         
    3152         
    3253    def help(self, evt): 
    … …  
    88109        Edit meta data  
    89110        """ 
    90         from sans.perspectives.calculator.data_editor import DataEditorWindow 
    91         frame = DataEditorWindow(parent=self.parent, data=[], 
    92                                   title="Data Editor") 
    93         self.put_icon(frame) 
    94         frame.Show(True) 
     111        if self.data_edit_frame == None: 
     112            self.data_edit_frame = DataEditorWindow(parent=self.parent,  
     113                                                    manager=self, data=[], 
     114                                                    title="Data Editor") 
     115            self.put_icon(self.data_edit_frame) 
     116        self.data_edit_frame.Show(False)     
     117        self.data_edit_frame.Show(True) 
    95118               
    96119    def on_data_operation(self, event): 
    … …  
    101124            # Use one frame all the time 
    102125            self.data_operator_frame = DataOperatorWindow(parent=self.parent,  
     126                                                manager=self,  
    103127                                                title="Data Operation") 
    104128            self.put_icon(self.data_operator_frame) 
    … …  
    111135        Compute the Kiessig thickness 
    112136        """ 
    113         from sans.perspectives.calculator.kiessig_calculator_panel \ 
    114         import KiessigWindow 
    115         frame = KiessigWindow() 
    116         self.put_icon(frame) 
    117         frame.Show(True)  
    118      
     137        if self.kiessig_frame == None: 
     138            frame = KiessigWindow(parent=self.parent, manager=self) 
     139            self.put_icon(frame) 
     140            self.kiessig_frame = frame 
     141        self.kiessig_frame.Show(False) 
     142        self.kiessig_frame.Show(True)  
     143         
    119144    def on_calculate_sld(self, event): 
    120145        """ 
    121146        Compute the scattering length density of molecula 
    122147        """ 
    123         from sans.perspectives.calculator.sld_panel import SldWindow 
    124         frame = SldWindow(base=self.parent) 
    125         self.put_icon(frame) 
    126         frame.Show(True)  
     148        if self.sld_frame == None: 
     149            frame = SldWindow(base=self.parent, manager=self) 
     150            self.put_icon(frame) 
     151            self.sld_frame = frame 
     152        self.sld_frame.Show(False) 
     153        self.sld_frame.Show(True)  
    127154     
    128155    def on_calculate_dv(self, event): 
    … …  
    130157        Compute the mass density or molar voulme 
    131158        """ 
    132         from sans.perspectives.calculator.density_panel import DensityWindow 
    133         frame = DensityWindow(base=self.parent) 
    134         self.put_icon(frame) 
    135         frame.Show(True)  
     159        if self.cal_md_frame == None: 
     160            frame = DensityWindow(base=self.parent, manager=self) 
     161            self.put_icon(frame) 
     162            self.cal_md_frame = frame 
     163        self.cal_md_frame.Show(False) 
     164        self.cal_md_frame.Show(True)  
    136165               
    137166    def on_calculate_slit_size(self, event): 
    … …  
    139168        Compute the slit size a given data 
    140169        """ 
    141         from sans.perspectives.calculator.slit_length_calculator_panel \ 
    142         import SlitLengthCalculatorWindow 
    143         frame = SlitLengthCalculatorWindow(parent=self.parent)   
    144         self.put_icon(frame)   
    145         frame.Show(True) 
     170        if self.cal_slit_frame == None: 
     171            frame = SlitLengthCalculatorWindow(parent=self.parent, manager=self)   
     172            self.put_icon(frame) 
     173            self.cal_slit_frame = frame  
     174        self.cal_slit_frame.Show(False)      
     175        self.cal_slit_frame.Show(True) 
    146176         
    147177    def on_calculate_resoltuion(self, event): 
    … …  
    149179        Estimate the instrumental resolution 
    150180        """ 
    151         from sans.perspectives.calculator.resolution_calculator_panel \ 
    152         import ResolutionWindow 
    153         frame = ResolutionWindow(parent=self.parent) 
    154         self.put_icon(frame) 
    155         frame.Show(True)  
     181        if self.cal_res_frame == None: 
     182            frame = ResolutionWindow(parent=self.parent, manager=self) 
     183            self.put_icon(frame) 
     184            self.cal_res_frame = frame 
     185        self.cal_res_frame.Show(False) 
     186        self.cal_res_frame.Show(True)  
    156187         
    157188    def on_gen_model(self, event): 
    … …  
    159190        On Generic model menu event 
    160191        """ 
    161         from sans.perspectives.calculator.gen_scatter_panel \ 
    162         import SasGenWindow 
    163         frame = SasGenWindow(parent=self.parent) 
    164         self.put_icon(frame) 
    165         frame.Show(True)  
     192        if self.gen_frame == None: 
     193            frame = SasGenWindow(parent=self.parent, manager=self) 
     194            self.put_icon(frame) 
     195            self.gen_frame = frame 
     196        self.gen_frame.Show(False) 
     197        self.gen_frame.Show(True)  
    166198 
    167199    def on_image_viewer(self, event): 
    … …  
    171203        :param event: menu event 
    172204        """ 
    173         from sans.perspectives.calculator.image_viewer import ImageView 
    174         image_view = ImageView(parent=self.parent) 
    175         image_view.load() 
     205        self.image_view = ImageView(parent=self.parent) 
     206        self.image_view.load() 
    176207         
    177208    def on_python_console(self, event): 
    … …  
    189220        :param filename: file name to open in editor 
    190221        """ 
    191         from sans.perspectives.calculator.pyconsole import PyConsole 
    192         frame = PyConsole(parent=self.parent, filename=filename) 
    193         self.put_icon(frame) 
    194         frame.Show(True)  
     222        if self.py_frame == None: 
     223            frame = PyConsole(parent=self.parent, base=self,  
     224                              filename=filename) 
     225            self.put_icon(frame) 
     226            self.py_frame = frame 
     227        self.py_frame.Show(False) 
     228        self.py_frame.Show(True)  
    195229         
    196230    def put_icon(self, frame): 

  • calculatorview/src/sans/perspectives/calculator/data_editor.py

    r7c720e9 rae84427  
    636636         
    637637class DataEditorWindow(wx.Frame): 
    638     def __init__(self, parent, data=None, *args, **kwds): 
     638    def __init__(self, parent, manager, data=None, *args, **kwds): 
    639639        kwds["size"] = (PANEL_WIDTH, PANEL_HEIGTH) 
    640640        wx.Frame.__init__(self, parent, *args, **kwds) 
    641641        self.parent = parent 
     642        self.manager = manager 
    642643        self.panel = DataEditorPanel(parent=self, data=data) 
    643644        self.Show() 

  • calculatorview/src/sans/perspectives/calculator/data_operator.py

    r657e52c rae84427  
    615615        event.Skip() 
    616616     
     617    def disconnect_panels(self): 
     618        """ 
     619        """ 
     620        self.out_pic.connect.disconnect() 
     621        self.equal_pic.connect.disconnect() 
     622        self.data1_pic.connect.disconnect() 
     623        self.operator_pic.connect.disconnect() 
     624        self.data2_pic.connect.disconnect() 
     625     
    617626    def on_close(self, event): 
    618627        """ 
    … …  
    926935         
    927936class DataOperatorWindow(wx.Frame): 
    928     def __init__(self, parent, *args, **kwds): 
     937    def __init__(self, parent, manager, *args, **kwds): 
    929938        kwds["size"] = (PANEL_WIDTH, PANEL_HEIGTH) 
    930939        wx.Frame.__init__(self, parent, *args, **kwds) 
    931940        self.parent = parent 
     941        self.manager = manager 
    932942        self.panel = DataOperPanel(parent=self) 
    933943        wx.EVT_CLOSE(self, self.OnClose) 
    … …  
    939949        On close event 
    940950        """ 
    941         self.Show(False) 
     951        if self.manager != None: 
     952            self.manager.data_operator_frame = None 
     953        self.panel.disconnect_panels() 
     954        self.Destroy() 
    942955 
    943956         

  • calculatorview/src/sans/perspectives/calculator/density_panel.py

    r0efca36 rae84427  
    375375    """ 
    376376    def __init__(self, parent=None, title="Density/Volume Calculator", 
    377                   base=None, size=(PANEL_SIZE, PANEL_SIZE/1.7), *args, **kwds): 
     377                  base=None, manager=None,  
     378                  size=(PANEL_SIZE, PANEL_SIZE/1.7), *args, **kwds): 
    378379        """ 
    379380        """ 
    … …  
    383384        """ 
    384385        """ 
     386        self.manager = manager 
    385387        self.panel = DensityPanel(self, base=base) 
     388        self.Bind(wx.EVT_CLOSE, self.on_close) 
    386389        self.Centre() 
    387390        self.Show(True) 
     391     
     392    def on_close(self, event): 
     393        """ 
     394        On close event 
     395        """ 
     396        if self.manager != None: 
     397            self.manager.cal_md_frame = None 
     398        self.Destroy() 
     399         
    388400         
    389401class ViewApp(wx.App): 

  • calculatorview/src/sans/perspectives/calculator/gen_scatter_panel.py

    rd4895dd rae84427  
    1919matplotlib.use('WXAgg') 
    2020 
     21#from sans.guiframe.gui_manager import MDIFrame 
    2122from data_util.calcthread import CalcThread 
    2223from sans.guiframe.local_perspectives.plotting.SimplePlot import PlotFrame 
    … …  
    11131114        num_graph = str(self.graph_num) 
    11141115        wx.CallAfter(self.parent.draw_graph, new_plot,  
    1115                      title="Graph %s: "% num_graph + new_plot.id ) 
     1116                     title="GEN Graph %s: "% num_graph + new_plot.id ) 
    11161117        self.graph_num += 1 
    11171118                 
    … …  
    11721173        num_graph = str(self.graph_num) 
    11731174        wx.CallAfter(self.parent.draw_graph, new_plot,  
    1174                      title="Graph %s: "% num_graph + new_plot.id ) 
     1175                     title="GEN Graph %s: "% num_graph + new_plot.id ) 
    11751176        self.graph_num += 1 
    1176          
     1177          
    11771178    def set_scale2d(self, scale): 
    11781179        """ 
    … …  
    17941795    GEN SAS main window 
    17951796    """ 
    1796     def __init__(self, parent=None, title="Generic Scattering Calculator", 
     1797    def __init__(self, parent=None, manager= None, title="Generic Scattering Calculator", 
    17971798                size=(PANEL_WIDTH * 1.3, PANEL_HEIGHT * 1.65), *args, **kwds): 
    17981799        """ 
    … …  
    18041805        wx.Frame.__init__(self, parent, *args, **kwds) 
    18051806        self.parent = parent 
     1807        self.base = manager 
    18061808        self.omfpanel = OmfPanel(parent=self) 
    18071809        self.panel = SasGenPanel(parent=self) 
    … …  
    18151817        self._plot_title = '' 
    18161818        self.scale2d = 'log_{10}' 
     1819        self.Bind(wx.EVT_CLOSE, self.on_close) 
    18171820         
    18181821        self._build_toolbar() 
    1819         self._build_menubar() 
    18201822         
    18211823        self.build_panels() 
    … …  
    20082010        frame.Show(True) 
    20092011        frame.SetFocus() 
    2010      
     2012 
     2013    def set_schedule_full_draw(self, panel=None, func='del'):   
     2014        """ 
     2015        Send full draw to gui frame 
     2016        """ 
     2017        self.parent.set_schedule_full_draw(panel, func) 
     2018         
    20112019    def get_npix(self): 
    20122020        """ 
    … …  
    20822090        Close 
    20832091        """ 
     2092        if self.base != None: 
     2093            self.base.gen_frame = None 
    20842094        self.Destroy() 
    20852095         

  • calculatorview/src/sans/perspectives/calculator/image_viewer.py

    r3e001f9 rae84427  
    7070                    parent.put_icon(plot_frame) 
    7171            except: 
     72                print "parent", parent 
     73                raise 
    7274                err_msg += "Failed to load '%s'.\n"% basename 
    7375        if err_msg: 

  • calculatorview/src/sans/perspectives/calculator/kiessig_calculator_panel.py

    r7d45a56 rae84427  
    191191              
    192192class KiessigWindow(wx.Frame): 
    193     def __init__(self, parent=None, title="Kiessig Thickness Calculator", 
    194                   size=(PANEL_WIDTH,PANEL_HEIGHT), *args, **kwds): 
     193    def __init__(self, parent=None, manager=None,  
     194                 title="Kiessig Thickness Calculator", 
     195                 size=(PANEL_WIDTH,PANEL_HEIGHT), *args, **kwds): 
    195196        kwds['title'] = title 
    196197        kwds['size'] = size 
    197198        wx.Frame.__init__(self, parent, *args, **kwds) 
    198199        self.parent = parent 
     200        self.manager = manager 
    199201        self.panel = KiessigThicknessCalculatorPanel(parent=self) 
     202        self.Bind(wx.EVT_CLOSE, self.on_close) 
    200203        self.Centre() 
    201204        self.Show(True) 
     205         
     206    def on_close(self, event): 
     207        """ 
     208        Close event 
     209        """ 
     210        if self.manager != None: 
     211            self.manager.kiessig_frame = None 
     212        self.Destroy() 
     213 
    202214         
    203215if __name__ == "__main__":  

  • calculatorview/src/sans/perspectives/calculator/pyconsole.py

    rf706e09c rae84427  
    4040    ## Flag to tell the AUI manager to put this panel in the center pane 
    4141    CENTER_PANE = False 
    42     def __init__(self, parent=None, manager=None, panel=None, 
     42    def __init__(self, parent=None, base=None, manager=None, panel=None, 
    4343                    title='Python Shell/Editor', filename=None, 
    4444                    size=(PANEL_WIDTH, PANEL_HEIGHT)): 
    … …  
    4949        self.parent = parent 
    5050        self._manager = manager 
     51        self.base = base 
    5152        self.panel = panel 
    5253        self._add_menu() 
    … …  
    6869        self.Bind(wx.EVT_UPDATE_UI, self.OnUpdateCompileMenu, id=ID_COMPILE) 
    6970        self.Bind(wx.EVT_UPDATE_UI, self.OnUpdateCompileMenu, id=ID_RUN) 
     71        self.Bind(wx.EVT_CLOSE, self.on_close) 
    7072        if not title.count('Python Shell'): 
    7173            # Delete menu item (open and new) if not python shell 
    … …  
    293295            event.Enable(False) 
    294296             
     297    def on_close(self, event): 
     298        """ 
     299        Close event 
     300        """ 
     301        if self.base != None: 
     302            self.base.py_frame = None 
     303        self.Destroy() 
     304                     
    295305ABOUT =  "Welcome to Python %s! \n\n"% sys.version.split()[0] 
    296306ABOUT += "This uses Py Shell/Editor in wx (developed by Patrick K. O'Brien).\n" 

  • calculatorview/src/sans/perspectives/calculator/resolution_calculator_panel.py

    re95614e rae84427  
    13931393    Resolution Window 
    13941394    """ 
    1395     def __init__(self, parent = None, title = "SANS Resolution Estimator", 
    1396                   size=(PANEL_WIDTH * 2, PANEL_HEIGHT), *args, **kwds): 
     1395    def __init__(self, parent = None, manager=None,  
     1396                 title = "SANS Resolution Estimator", 
     1397                 size=(PANEL_WIDTH * 2, PANEL_HEIGHT), *args, **kwds): 
    13971398        kwds['title'] = title 
    13981399        kwds['size'] = size 
    13991400        wx.Frame.__init__(self, parent=None, *args, **kwds) 
    14001401        self.parent = parent 
     1402        self.manager = manager 
    14011403        self.panel = ResolutionCalculatorPanel(parent=self) 
     1404        self.Bind(wx.EVT_CLOSE, self.OnClose) 
    14021405        self.Centre() 
    14031406        self.Show(True) 
    1404         wx.EVT_CLOSE(self, self.OnClose) 
    14051407     
    14061408    def OnClose(self, event):   
    … …  
    14091411        """ 
    14101412        _pylab_helpers.Gcf.figs = {} 
    1411         self.Destroy()   
     1413        if self.manager != None: 
     1414            self.manager.cal_res_frame = None 
     1415        self.Destroy()  
    14121416 
    14131417         

  • calculatorview/src/sans/perspectives/calculator/sld_panel.py

    r9c30b8c rae84427  
    441441    """ 
    442442    def __init__(self, parent=None, title="SLD Calculator", 
    443                   base=None, size=(PANEL_SIZE, PANEL_SIZE), *args, **kwds): 
     443                  base=None, manager=None,  
     444                  size=(PANEL_SIZE, PANEL_SIZE), *args, **kwds): 
    444445        """ 
    445446        """ 
    … …  
    449450        """ 
    450451        """ 
     452        self.parent = parent 
     453        self.base = base 
     454        self.manager = manager 
    451455        self.panel = SldPanel(self, base=base) 
     456        self.Bind(wx.EVT_CLOSE, self.on_close) 
    452457        self.Centre() 
    453458        self.Show(True) 
     459     
     460    def on_close(self, event): 
     461        """ 
     462        On close event 
     463        """ 
     464        if self.manager != None: 
     465            self.manager.sld_frame = None 
     466        self.Destroy() 
     467         
    454468         
    455469class ViewApp(wx.App): 

  • calculatorview/src/sans/perspectives/calculator/slit_length_calculator_panel.py

    r29a90b0 rae84427  
    254254    """ 
    255255    """ 
    256     def __init__(self, parent=None, title="Slit Size Calculator", 
     256    def __init__(self, parent=None, manager=None, title="Slit Size Calculator", 
    257257                size=(PANEL_WIDTH,PANEL_HEIGHT), *args, **kwds): 
    258258        """ 
    … …  
    262262        wx.Frame.__init__(self, parent, *args, **kwds) 
    263263        self.parent = parent 
     264        self.manager = manager 
    264265        self.panel = SlitLengthCalculatorPanel(parent=self) 
     266        self.Bind(wx.EVT_CLOSE, self.on_close) 
    265267        self.Centre() 
    266268        self.Show(True) 
     269 
     270    def on_close(self, event): 
     271        """ 
     272        Close event 
     273        """ 
     274        if self.manager != None: 
     275            self.manager.cal_slit_frame = None 
     276        self.Destroy() 
    267277         
    268278if __name__ == "__main__":  

  • fittingview/src/sans/perspectives/fitting/basepage.py

    rcb270ad2 rae84427  
    713713        msg = menu.GetHelpString(event.GetId()) 
    714714        msg += " reloaded" 
    715         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     715        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    716716        self.Show(False) 
    717717        name = menu.GetLabel(event.GetId()) 
    … …  
    746746        if self.parent != None: 
    747747            self._default_save_location = \ 
    748                         self.parent.parent._default_save_location 
     748                        self._manager.parent._default_save_location 
    749749        dlg = wx.FileDialog(self, "Choose a file", self._default_save_location, 
    750750                                        self.window_caption, "*.fitv", wx.SAVE) 
    … …  
    753753            path = dlg.GetPath() 
    754754            self._default_save_location = os.path.dirname(path) 
    755             self.parent.parent._default_save_location =\ 
     755            self._manager.parent._default_save_location =\ 
    756756                                 self._default_save_location 
    757757        else: 
    … …  
    803803            msg += ": No valid parameter values to paste from the clipboard..." 
    804804            infor = "error" 
    805             wx.PostEvent(self.parent.parent, 
     805            wx.PostEvent(self._manager.parent, 
    806806                    StatusEvent(status=msg, info=infor)) 
    807807            raise 
    808808        # inform msg to wx 
    809         wx.PostEvent(self.parent.parent, 
     809        wx.PostEvent(self._manager.parent, 
    810810                    StatusEvent(status=msg, info=infor)) 
    811811         
    … …  
    843843        ## post help message for the selected model 
    844844        msg += " Saved! right click on this page to retrieve this model" 
    845         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     845        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    846846         
    847847        id = wx.NewId() 
    848848        self.popUpMenu.Append(id, name, str(msg)) 
    849849        wx.EVT_MENU(self, id, self.onResetModel) 
    850         wx.PostEvent(self.parent.parent, 
     850        wx.PostEvent(self._manager.parent, 
    851851                     AppendBookmarkEvent(title=name, 
    852852                                         hint=str(msg), 
    … …  
    877877        try: 
    878878            if path == None: 
    879                 wx.PostEvent(self.parent.parent, 
     879                wx.PostEvent(self._manager.parent, 
    880880                            StatusEvent(status= \ 
    881881                            " Selected Distribution was not loaded: %s" % path)) 
    … …  
    14901490        if self.parent != None: 
    14911491            self._default_save_location = \ 
    1492                         self.parent.parent.get_save_location() 
     1492                        self._manager.parent.get_save_location() 
    14931493        dlg = wx.FileDialog(self, "Choose a weight file", 
    14941494                                self._default_save_location, "", 
    … …  
    17021702            msg = "Cannot Plot or Fit :Must select a " 
    17031703            msg += " model or Fitting range is not valid!!!  " 
    1704             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1704            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    17051705         
    17061706        try: 
    … …  
    20812081        except: 
    20822082            msg = "%s\n" % (sys.exc_value) 
    2083             wx.PostEvent(self.parent.parent, 
     2083            wx.PostEvent(self._manager.parent, 
    20842084                         StatusEvent(status=msg, info="error")) 
    20852085        self._populate_box(self.formfactorbox, m_list) 
    … …  
    21882188        #Clear msg if previously shown. 
    21892189        msg = "" 
    2190         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2190        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    21912191        # Flag to register when a parameter has changed. 
    21922192        is_modified = False 
    … …  
    22232223                else: 
    22242224                    msg = "Cannot Plot :No npts in that Qrange!!!  " 
    2225                     wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2225                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22262226        else: 
    22272227            tcrtl.SetBackgroundColour("pink") 
    22282228            msg = "Model Error:wrong value entered!!!" 
    2229             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2229            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    22302230        self.save_current_state() 
    22312231        event = PageInfoEvent(page=self) 
    … …  
    23672367                qmax_ctrl.Refresh() 
    23682368                msg = "Invalid Q range: Q min must be smaller than Q max" 
    2369                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2369                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    23702370                return False 
    23712371        return True 
    … …  
    23992399                msg = "Npts of Data Error :" 
    24002400                msg += "No or too little npts of %s." % data.name 
    2401                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2401                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    24022402                self.fitrange = False 
    24032403                flag = False 
    … …  
    24342434                msg = "Npts of Data Error :" 
    24352435                msg += "No or too little npts of %s." % data.name 
    2436                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2436                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    24372437                self.fitrange = False 
    24382438                flag = False 
    … …  
    24852485                        except: 
    24862486                            msg = "Wrong Fit parameter range entered " 
    2487                             wx.PostEvent(self.parent.parent, 
     2487                            wx.PostEvent(self._manager.parent, 
    24882488                                         StatusEvent(status=msg)) 
    24892489                            raise ValueError, msg 
    … …  
    25022502                        except: 
    25032503                            msg = "Wrong Fit parameter range entered " 
    2504                             wx.PostEvent(self.parent.parent, 
     2504                            wx.PostEvent(self._manager.parent, 
    25052505                                         StatusEvent(status=msg)) 
    25062506                            raise ValueError, msg 
    … …  
    25112511                        msg = "Wrong Fit range entered for parameter " 
    25122512                        msg += "name %s of model %s " % (name, self.model.name) 
    2513                         wx.PostEvent(self.parent.parent, 
     2513                        wx.PostEvent(self._manager.parent, 
    25142514                                     StatusEvent(status=msg)) 
    25152515                 
    … …  
    25332533                item[2].SetBackgroundColour("pink") 
    25342534                msg = "Wrong Fit parameter value entered " 
    2535                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2535                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    25362536                 
    25372537        return is_modified 
    … …  
    27632763            # Focus on Fit button so that users can see the pinky box 
    27642764            self.btFit.SetFocus() 
    2765             wx.PostEvent(self.parent.parent, 
     2765            wx.PostEvent(self._manager.parent, 
    27662766                         StatusEvent(status=msg, info="error")) 
    27672767         
    … …  
    27852785            return 
    27862786        self._default_save_location = os.path.dirname(path) 
    2787         if self.parent != None: 
    2788             self.parent.parent._default_save_location =\ 
     2787        if self._manager != None: 
     2788            self._manager.parent._default_save_location =\ 
    27892789                             self._default_save_location 
    27902790 
    … …  
    28002800        # Tell the user that we are about to apply the distribution 
    28012801        msg = "Applying loaded %s distribution: %s" % (name, path) 
    2802         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2802        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    28032803        self._set_array_disp_model(name=name, disp=disp, 
    28042804                                    values=values, weights=weights) 
    … …  
    29472947        if flag == False: 
    29482948            msg = "Cannot Plot :Must enter a number!!!  " 
    2949             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     2949            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    29502950        else: 
    29512951            # set relative text ctrs. 
    … …  
    29832983        res_item = None 
    29842984        # call gui_manager 
    2985         gui_manager = self.parent.parent 
     2985        gui_manager = self._manager.parent 
    29862986        # loops through the panels [dic] 
    29872987        for _, item2 in gui_manager.plot_panels.iteritems(): 

  • fittingview/src/sans/perspectives/fitting/fitpage.py

    r3e001f9 rae84427  
    6868        #create a default data for an empty panel 
    6969        self.create_default_data() 
     70        #self._manager.frame.Bind(wx.EVT_SET_FOCUS, self.on_set_focus) 
    7071     
    7172    def enable_fit_button(self): 
    … …  
    985986        if not flag: 
    986987            msg = "The parameters are invalid" 
    987             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     988            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    988989            return 
    989990         
    … …  
    10001001            return 
    10011002 
    1002         if len(self.parent._manager.fit_thread_list) > 0 and\ 
    1003                     self.parent._manager._fit_engine != "park" and\ 
     1003        if len(self._manager.fit_thread_list) > 0 and\ 
     1004                    self._manager._fit_engine != "park" and\ 
    10041005                    self._manager.sim_page != None and \ 
    10051006                    self._manager.sim_page.uid == self.uid: 
    … …  
    10361037        if not flag: 
    10371038            msg = "Fitting range or parameters are invalid" 
    1038             wx.PostEvent(self.parent.parent, 
     1039            wx.PostEvent(self._manager.parent, 
    10391040                         StatusEvent(status=msg, type="stop")) 
    10401041            return 
    … …  
    12591260        #Clear msg if previously shown. 
    12601261        msg = "" 
    1261         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1262        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    12621263 
    12631264        if check_float(tcrtl): 
    … …  
    13011302            self.save_current_state() 
    13021303            msg = "Cannot Plot :Must enter a number!!!  " 
    1303             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1304            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13041305              
    13051306        self.save_current_state() 
    … …  
    13131314        #Clear msg if previously shown. 
    13141315        msg = "" 
    1315         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1316        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13161317        # Flag to register when a parameter has changed. 
    13171318        is_modified = False 
    … …  
    13241325                tcrtl.SetBackgroundColour("pink") 
    13251326                msg = "Model Error:wrong value entered : %s" % sys.exc_value 
    1326                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1327                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    13271328                return 
    13281329        else: 
    … …  
    13571358            d_group_id = self.data.group_id 
    13581359            act_ctrl = event.GetEventObject() 
    1359             wx.PostEvent(self.parent.parent,  
     1360            wx.PostEvent(self._manager.parent,  
    13601361                         PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,  
    13611362                                     group_id=d_group_id, leftdown=is_click, 
    … …  
    13731374        d_id = self.data.id 
    13741375        d_group_id = self.data.group_id 
    1375         wx.PostEvent(self.parent.parent,  
     1376        wx.PostEvent(self._manager.parent,  
    13761377                     PlotQrangeEvent(ctrl=[self.qmin, self.qmax], id=d_id,  
    13771378                                     group_id=d_group_id, leftdown=False,  
    … …  
    14151416        #Clear msg if previously shown. 
    14161417        msg = "" 
    1417         wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1418        wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14181419        # For theory mode 
    14191420        if not self.data.is_data: 
    … …  
    14361437                    tcrtl.SetBackgroundColour("pink") 
    14371438                    msg = "Model Error:wrong value entered : %s" % sys.exc_value 
    1438                     wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1439                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14391440                    return 
    14401441            except: 
    14411442                tcrtl.SetBackgroundColour("pink") 
    14421443                msg = "Model Error:wrong value entered : %s" % sys.exc_value 
    1443                 wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1444                wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14441445                return 
    14451446            #Check if # of points for theory model are valid(>0). 
    … …  
    14571458                    msg = "Cannot Plot :No or too little npts in" 
    14581459                    msg += " that data range!!!  " 
    1459                     wx.PostEvent(self.parent.parent, 
     1460                    wx.PostEvent(self._manager.parent, 
    14601461                                 StatusEvent(status=msg)) 
    14611462                    return 
    … …  
    14751476            tcrtl.SetBackgroundColour("pink") 
    14761477            msg = "Model Error:wrong value entered!!!" 
    1477             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1478            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    14781479         
    14791480        self._draw_model() 
    … …  
    17671768            self.set_npts2fit() 
    17681769            msg = "No model is found on updating MASK in the model plot... " 
    1769             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
     1770            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    17701771        else: 
    17711772            event.Skip() 
    … …  
    19831984            try: 
    19841985                wx.PostEvent(self._manager.parent, 
    1985                              NewPlotEvent(action="remove", 
     1986                             NewPlotEvent(action="delete", 
    19861987                                          group_id=old_group_id, id=old_id)) 
    19871988            except: 
    … …  
    20152016            msg += "information.\n" 
    20162017            msg += "%s"% (sys.exc_value) 
    2017             wx.PostEvent(self.parent.parent, 
     2018            wx.PostEvent(self._manager.parent, 
    20182019                         StatusEvent(status=msg, info="error")) 
    20192020        self._lay_out() 
    … …  
    26802681            if item[0] and item[0].IsShown(): 
    26812682                param2fit.append(item[1]) 
    2682         self.parent._manager.set_param2fit(self.uid, param2fit) 
     2683        self._manager.set_param2fit(self.uid, param2fit) 
    26832684                 
    26842685    def select_all_param(self, event): 
    … …  
    28122813            if item[0] and item[0].IsShown(): 
    28132814                param2fit.append(item[1]) 
    2814         self.parent._manager.set_param2fit(self.uid, param2fit) 
     2815        self._manager.set_param2fit(self.uid, param2fit) 
    28152816         
    28162817    def set_model_param_sizer(self, model): 
    … …  
    32373238            infor = 'warning' 
    32383239            # inform msg to wx 
    3239             wx.PostEvent(self.parent.parent, 
     3240            wx.PostEvent(self._manager.parent, 
    32403241                        StatusEvent(status=msg, info=infor)) 
    32413242         

  • fittingview/src/sans/perspectives/fitting/fitpanel.py

    r3b148c3 rae84427  
    7171        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, self.on_page_changing) 
    7272        self.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSED, self.on_closed) 
    73  
     73         
    7474    def on_closed(self, event): 
    7575        """ 
    … …  
    161161        if pos != -1: 
    162162            selected_page = self.GetPage(pos) 
    163             wx.PostEvent(self.parent, PanelOnFocusEvent(panel=selected_page)) 
     163            wx.PostEvent(self._manager.parent,  
     164                         PanelOnFocusEvent(panel=selected_page)) 
    164165        self.enable_close_button() 
    165166        
    … …  
    170171        if pos != -1: 
    171172            selected_page = self.GetPage(pos) 
    172             wx.PostEvent(self.parent, PanelOnFocusEvent(panel=selected_page)) 
     173            wx.PostEvent(self._manager.parent,  
     174                         PanelOnFocusEvent(panel=selected_page)) 
    173175         
    174176    def get_data(self): 

  • fittingview/src/sans/perspectives/fitting/fitting.py

    rbca2cb9 rae84427  
    4141from sans.perspectives.calculator.model_editor import TextDialog 
    4242from sans.perspectives.calculator.model_editor import EditorWindow 
     43from sans.guiframe.gui_manager import MDIFrame 
    4344 
    4445MAX_NBR_DATA = 4 
    … …  
    427428            page.Refresh() 
    428429            page.SetFocus() 
    429             self.parent._mgr.Update() 
     430            #self.parent._mgr.Update() 
    430431            msg = "%s already opened\n" % str(page.window_caption) 
    431432            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    … …  
    500501        #self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper) 
    501502        # Creation of the fit panel 
    502         self.fit_panel = FitPanel(parent=self.parent, manager=self) 
     503        self.frame = MDIFrame(self.parent, None, 'None', (100, 200)) 
     504        self.fit_panel = FitPanel(parent=self.frame, manager=self) 
     505        self.frame.set_panel(self.fit_panel) 
     506        self._frame_set_helper() 
    503507        self.on_add_new_page(event=None) 
    504508        #Set the manager for the main panel 
    … …  
    513517        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event) 
    514518        self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL) 
    515         self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer) 
     519        #self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer) 
    516520        #Create reader when fitting panel are created 
    517521        self.state_reader = Reader(self.set_state) 
    … …  
    577581                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    578582     
    579     def set_top_panel(self): 
    580         """ 
    581         Close default (welcome) panel 
    582         """ 
    583         if 'default' in self.parent.panels: 
    584             self.parent.on_close_welcome_panel() 
    585  
    586          
    587583    def set_theory(self, theory_list=None): 
    588584        """ 
    … …  
    11681164                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    11691165                                                       info="warning")) 
    1170             self.set_top_panel() 
    11711166        except: 
    11721167            msg = "Creating Fit page: %s"%sys.exc_value 
    … …  
    12241219            the panel and panel_name to find the slicer 's panel concerned. 
    12251220        """ 
     1221        event.panel_name 
    12261222        for item in self.parent.panels: 
    12271223            name = event.panel_name 
    … …  
    12291225                self.parent.panels[item].set_slicer(event.type, event.params) 
    12301226                 
    1231         self.parent._mgr.Update() 
     1227        #self.parent._mgr.Update() 
    12321228    
    12331229    def _closed_fitpage(self, event): 
    … …  
    13081304                data = plottable 
    13091305                self.add_fit_page(data=[data]) 
    1310         self.set_top_panel() 
    13111306             
    13121307    def update_fit(self, result=None, msg=""): 
    … …  
    16891684            self.slicer_panels.append(event.panel) 
    16901685            # Set group ID if available 
    1691             event_id = self.parent.popup_panel(new_panel) 
    1692             new_panel.uid = event_id 
    1693             self.mypanels.append(new_panel) 
     1686            event_id = self.parent.popup_panel(event.panel) 
     1687            event.panel.uid = event_id 
     1688            self.mypanels.append(event.panel) 
    16941689        
    16951690    def _onclearslicer(self, event): 
    … …  
    16971692        Clear the boxslicer when close the panel associate with this slicer 
    16981693        """ 
    1699         name = event.GetPane().caption 
    1700      
     1694        name = event.GetEventObject().frame.GetTitle() 
     1695        print "name", name 
    17011696        for panel in self.slicer_panels: 
    17021697            if panel.window_caption == name: 
    … …  
    17061701                        if self.parent.panels[item].uid == panel.base.uid: 
    17071702                            self.parent.panels[item].onClearSlicer(event) 
    1708                             self.parent._mgr.Update() 
     1703                            #self.parent._mgr.Update() 
    17091704                            break 
    17101705                break 

  • invariantview/src/sans/perspectives/invariant/invariant.py

    r6813da7d rae84427  
    1717import copy 
    1818import logging 
    19  
     19from sans.guiframe.gui_manager import MDIFrame 
    2020from sans.guiframe.dataFitting import Data1D 
    2121from sans.guiframe.events import NewPlotEvent 
    … …  
    8383        ## Save a reference to the parent 
    8484        self.parent = parent 
    85         self.invariant_panel = InvariantPanel(parent=self.parent) 
     85        self.frame = MDIFrame(self.parent, None, 'None', (100, 200))      
     86        self.invariant_panel = InvariantPanel(parent=self.frame)         
     87        self.frame.set_panel(self.invariant_panel) 
     88        self._frame_set_helper() 
    8689        self.invariant_panel.set_manager(manager=self) 
    8790        self.perspective.append(self.invariant_panel.window_name)   

  • invariantview/src/sans/perspectives/invariant/invariant_panel.py

    rf686259 rae84427  
    7171        self.SetWindowVariant(variant=FONT_VARIANT) 
    7272        #Object that receive status event 
    73         self.parent = parent 
     73        self.parent = parent.parent 
    7474        #plug-in using this panel 
    7575        self._manager = manager  
    … …  
    646646                                                  type="stop")) 
    647647            return 
    648         self.Show(False) 
     648        #self.Show(False) 
    649649        r_msg = '' 
    650650        try: 
    … …  
    712712            wx.PostEvent(self.parent, 
    713713                StatusEvent(status='\nFinished invariant computation...')) 
    714         self.Show(True) 
     714        #self.Show(True) 
    715715        self.Refresh() 
    716716             

  • inversionview/src/sans/perspectives/pr/inversion_panel.py

    r657e52c rae84427  
    4646        self.plots = plots 
    4747        self.radio_buttons = {} 
    48         self.parent = parent 
     48        self.parent = parent.parent 
    4949         
    5050        ## Data file TextCtrl 

  • inversionview/src/sans/perspectives/pr/pr.py

    r0320d36 rae84427  
    2222import numpy 
    2323import pylab 
     24from sans.guiframe.gui_manager import MDIFrame 
    2425from sans.guiframe.dataFitting import Data1D 
    2526from sans.guiframe.events import NewPlotEvent 
    … …  
    12541255         
    12551256        self.parent = parent 
    1256         self.control_panel = InversionControl(self.parent, -1,  
     1257        self.frame = MDIFrame(self.parent, None, 'None', (100, 200))      
     1258        self.control_panel = InversionControl(self.frame, -1,  
    12571259                                              style=wx.RAISED_BORDER, 
    12581260                                              standalone=self.standalone) 
     1261        self.frame.set_panel(self.control_panel) 
     1262        self._frame_set_helper() 
    12591263        self.control_panel.set_manager(self) 
    12601264        self.control_panel.nfunc = self.nfunc 
    … …  
    12651269      
    12661270        return [self.control_panel] 
    1267      
     1271         
    12681272    def set_data(self, data_list=None): 
    12691273        """ 

  • plottools/src/danse/common/plottools/PlotPanel.py

    r2acedc8 rae84427  
    116116        wx.Panel.__init__(self, parent, id=id, **kwargs) 
    117117        self.parent = parent 
     118        if hasattr(parent, "parent"): 
     119            self.parent = self.parent.parent 
    118120        self.dimension = 1 
    119121        self.gotLegend = 0  # to begin, legend is not picked. 

  • sansguiframe/src/sans/guiframe/data_panel.py

    r318b5bbb rae84427  
    142142        self._default_save_location = None   
    143143        self.all_data1d = True 
    144         self.parent = parent 
    145         self.manager = manager 
     144        self.parent = parent.parent 
     145        self._manager = manager 
     146        self.frame = None 
    146147        if list is None: 
    147148            list = [] 
    … …  
    10081009        self.enable_append() 
    10091010        self.enable_remove_plot() 
    1010         
     1011     
     1012    def set_plot_unfocus(self): 
     1013        """ 
     1014        Unfocus plot 
     1015        """ 
     1016        return 
     1017     
    10111018    def _on_perspective_selection(self, event=None): 
    10121019        """ 
    … …  
    10471054                                          action="delete")) 
    10481055        self.enable_remove_plot() 
     1056     
     1057    def set_frame(self, frame): 
     1058        """ 
     1059        """ 
     1060        self.frame = frame 
     1061     
     1062    def get_frame(self): 
     1063        """ 
     1064        """ 
     1065        return self.frame  
     1066 
     1067    def set_schedule_full_draw(self, panel=None, func='del'): 
     1068        """ 
     1069        Send full draw to guimanager 
     1070        """ 
     1071        self.parent.set_schedule_full_draw(panel, func) 
    10491072         
    10501073    def enable_remove_plot(self): 
    … …  
    12611284                temp.append(data) 
    12621285        return temp 
    1263              
     1286                
    12641287class DataFrame(wx.Frame): 
    12651288    """ 
    … …  
    12821305        self.parent = parent 
    12831306        self.owner = owner 
    1284         self.manager = manager 
     1307        self._manager = manager 
    12851308        self.panel = DataPanel(parent=self,  
    1286                                #size=size, 
     1309                               manager=manager, 
    12871310                               list_of_perspective=list_of_perspective) 
    12881311      

  • sansguiframe/src/sans/guiframe/gui_manager.py

    r592cd678 rae84427  
    77#project funded by the US National Science Foundation.  
    88# 
    9 #See the license text in license.txt 
     9#See the license text in license.txtz 
    1010# 
    1111#copyright 2008, University of Tennessee 
    … …  
    192192IS_WIN = True 
    193193CLOSE_SHOW = True 
    194 TIME_FACTOR = 1 
     194TIME_FACTOR = 2 
    195195NOT_SO_GRAPH_LIST = ["BoxSum"] 
    196196if sys.platform.count("win32")==0: 
    … …  
    201201            CLOSE_SHOW = False 
    202202     
    203 class ViewerFrame(wx.Frame): 
     203class ViewerFrame(wx.MDIParentFrame): 
    204204    """ 
    205205    Main application frame 
    … …  
    215215        """ 
    216216 
    217         wx.Frame.__init__(self, parent=parent, title=title, pos=pos, size=size) 
     217        wx.MDIParentFrame.__init__(self, parent=parent, title=title, pos=pos, size=size) 
    218218        # title 
    219219        self.title = title 
    220         # Preferred window size 
    221         self._window_width, self._window_height = size 
    222220        self.__gui_style = gui_style        
    223221        path = os.path.dirname(__file__) 
    … …  
    292290        #control_panel on focus 
    293291        self.cpanel_on_focus = None 
     292 
    294293        self.loader = Loader()    
    295294        #data manager 
    … …  
    297296        from sans.guiframe.data_manager import DataManager 
    298297        self._data_manager = DataManager() 
    299         self._data_panel = DataPanel(parent=self) 
     298        self._data_panel = None#DataPanel(parent=self) 
    300299        if self.panel_on_focus is not None: 
    301300            self._data_panel.set_panel_on_focus( 
    … …  
    312311        self.on_batch_selection(event=None) 
    313312        self.add_icon() 
     313         
    314314        # Register the close event so it calls our own method 
    315315        wx.EVT_CLOSE(self, self.WindowClose) 
    … …  
    324324        self.Bind(EVT_CATEGORY, self.on_change_categories) 
    325325        self.setup_custom_conf() 
     326        # Preferred window size 
     327        self._window_width, self._window_height = size 
    326328         
    327329    def add_icon(self): 
    … …  
    345347                except: 
    346348                    pass   
    347          
     349                 
     350    def get_client_size(self): 
     351        """ 
     352        return client size tuple 
     353        """ 
     354        width, height = self.GetClientSizeTuple() 
     355        height -= 45 
     356        # Adjust toolbar height 
     357        toolbar = self.GetToolBar() 
     358        if toolbar != None: 
     359            _, tb_h = toolbar.GetSizeTuple() 
     360            height -= tb_h  
     361        return width, height 
     362     
    348363    def on_change_categories(self, evt): 
    349364        # ILL 
    … …  
    597612                     
    598613                    plugin.on_perspective(event=None) 
     614                    frame = plugin.get_frame() 
     615                    frame.Show(True) 
    599616                    #self._check_applications_menu() 
    600                     break 
     617                    #break 
     618                else: 
     619                    frame = plugin.get_frame() 
     620                    frame.Show(False)  
    601621            except: 
    602622                pass   
    … …  
    651671            #Disable save application if the current panel is in batch mode 
    652672            flag = self.panel_on_focus.get_save_flag() 
    653             self._save_appl_menu.Enable(flag) 
     673            if self._save_appl_menu != None: 
     674                self._save_appl_menu.Enable(flag) 
    654675 
    655676            if self.panel_on_focus not in self.plot_panels.values(): 
    … …  
    665686                #update edit menu 
    666687                self.enable_edit_menu() 
    667      
     688 
    668689    def disable_app_menu(self, p_panel=None):   
    669690        """ 
    670691        Disables all menus in the menubar 
    671692        """ 
    672         if p_panel == None: 
    673             return 
    674         p_name = p_panel.window_name 
    675         enable = not self._mgr.GetPane(p_name).IsMaximized() 
    676         if self._data_panel is not None: 
    677             self._data_panel.disable_app_combo(enable) 
    678         if self._menubar is not None: 
    679             for menu, _ in self._menubar.GetMenus(): 
    680                 for items in menu.GetMenuItems(): 
    681                     items.Enable(enable) 
    682         c_panel = self.cpanel_on_focus 
    683         # disable depending on the save_app flag 
    684         self._save_appl_menu.Enable(c_panel.get_save_flag()) 
    685         if not enable: 
    686             if self._toolbar is not None: 
    687                 self._toolbar.update_toolbar(None) 
    688             p_panel.on_set_focus(None) 
    689         else: 
    690             self._toolbar.update_toolbar(c_panel) 
     693        return 
    691694         
    692695    def set_panel_on_focus_helper(self): 
    … …  
    695698        """ 
    696699        ID = self.panel_on_focus.uid 
    697         self._data_panel.set_panel_on_focus(ID) 
     700        if self._data_panel != None: 
     701            self._data_panel.set_panel_on_focus(ID) 
    698702        #update combo 
    699703        if self.panel_on_focus in self.plot_panels.values(): 
    … …  
    707711                cpanel.on_tap_focus() 
    708712                self.cpanel_on_focus = self.panel_on_focus 
    709                  
     713       
    710714    def reset_bookmark_menu(self, panel): 
    711715        """ 
    … …  
    758762        self._setup_extra_custom() 
    759763        self._check_update(None) 
    760      
     764 
    761765    def _setup_extra_custom(self):   
    762766        """ 
    … …  
    781785        self.SetStatusBar(self.sb) 
    782786        # Add panel 
    783         default_flag = wx.aui.AUI_MGR_DEFAULT#| wx.aui.AUI_MGR_ALLOW_ACTIVE_PANE 
    784         self._mgr = wx.aui.AuiManager(self, flags=default_flag) 
    785         self._mgr.SetDockSizeConstraint(0.5, 0.5) 
     787        #default_flag = wx.aui.AUI_MGR_DEFAULT#| wx.aui.AUI_MGR_ALLOW_ACTIVE_PANE 
     788        #self._mgr = wx.aui.AuiManager(self, flags=default_flag) 
     789        #self._mgr.SetDockSizeConstraint(0.5, 0.5) 
    786790        # Load panels 
    787791        self._load_panels() 
    788792        self.set_default_perspective() 
    789         self._mgr.Update() 
     793        #self._mgr.Update() 
    790794         
    791795    def SetStatusText(self, *args, **kwds): 
    … …  
    906910                    except: 
    907911                        msg = "ViewerFrame._find_plugins: %s" % sys.exc_value 
    908                         #print msg 
    909912                        logging.error(msg) 
    910913                    finally: 
    … …  
    925928         
    926929        """ 
    927         self.defaultPanel = panel_class(self, -1, style=wx.RAISED_BORDER) 
     930        win = MDIFrame(self, None, 'None', (100, 200)) 
     931        self.defaultPanel = panel_class(win, -1, style=wx.RAISED_BORDER) 
     932        win.set_panel(self.defaultPanel) 
     933        self.defaultPanel.set_frame(win) 
     934        #win.EnableCloseButton(False) 
     935        win.Show(False) 
    928936         
    929937    def _get_panels_size(self, p): 
    … …  
    932940        get the proper panel width and height 
    933941        """ 
    934         ## Check and set the size 
     942        self._window_width, self._window_height = self.get_client_size() 
     943        ## Default size 
    935944        if DATAPANEL_WIDTH < 0: 
    936             panel_width = int(self._window_width * 0.22) 
     945            panel_width = int(self._window_width * 0.25) 
    937946        else: 
    938947            panel_width = DATAPANEL_WIDTH 
    939         panel_height = int(self._window_height * 0.9) 
     948        panel_height = int(self._window_height) 
    940949        style = self.__gui_style & (GUIFRAME.MANAGER_ON) 
    941950        if self._data_panel is not None  and (p == self._data_panel): 
    942951            return panel_width, panel_height 
    943952        if hasattr(p, "CENTER_PANE") and p.CENTER_PANE: 
    944             style = self.__gui_style & (GUIFRAME.PLOTTING_ON|GUIFRAME.MANAGER_ON) 
    945             if style == (GUIFRAME.PLOTTING_ON|GUIFRAME.MANAGER_ON): 
    946                 panel_width = self._window_width - panel_width 
     953            #style = self.__gui_style & (GUIFRAME.PLOTTING_ON|GUIFRAME.MANAGER_ON) 
     954            #if style == (GUIFRAME.PLOTTING_ON|GUIFRAME.MANAGER_ON): 
     955            panel_width = self._window_width * 0.45 
    947956            return panel_width, panel_height 
     957        elif p == self.defaultPanel: 
     958            return self._window_width, panel_height 
     959        #total_width = panel_width + self._window_width - 2.3 * panel_width 
    948960        return panel_width, panel_height 
    949961     
    … …  
    952964        Load all panels in the panels directory 
    953965        """ 
    954          
    955966        # Look for plug-in panels 
    956967        panels = []     
    … …  
    963974        # It also sets the size of the application windows 
    964975        #TODO: Use this for splash screen 
    965         if self.defaultPanel is None: 
    966             self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER) 
     976        #if self.defaultPanel is None: 
     977        #    self.defaultPanel = DefaultPanel(self, -1, style=wx.RAISED_BORDER) 
    967978        # add a blank default panel always present  
    968979        self.panels["default"] = self.defaultPanel 
     980        w, h = self._get_panels_size(self.defaultPanel) 
     981        #win = MDIFrame(self, DefaultPanel, "default",  
     982        #               (self._window_width, self._window_height)) 
     983        #win.set_panel(self.defaultPanel) 
     984        #self.defaultPanel.set_frame(win) 
     985        frame = self.defaultPanel.get_frame() 
     986        frame.SetSize((self._window_width, self._window_height)) 
     987        frame.Show(True) 
     988        """ 
    969989        self._mgr.AddPane(self.defaultPanel, wx.aui.AuiPaneInfo(). 
    970990                              Name("default"). 
    … …  
    975995                                               self._window_height)). 
    976996                              Show()) 
    977  
     997        """ 
    978998        #add data panel  
     999         
     1000        w, h = self._get_panels_size(self._data_panel) 
     1001        win = MDIFrame(self, None, 'None', (w,h)) 
     1002        self._data_panel = DataPanel(parent=win) 
     1003        win.set_panel(self._data_panel) 
     1004        win.EnableCloseButton(False) 
    9791005        self.panels["data_panel"] = self._data_panel 
    980         w, h = self._get_panels_size(self._data_panel) 
    981         self._mgr.AddPane(self._data_panel, wx.aui.AuiPaneInfo(). 
    982                               Name(self._data_panel.window_name). 
    983                               Caption(self._data_panel.window_caption). 
    984                               Left(). 
    985                               CloseButton(CLOSE_SHOW). 
    986                               TopDockable(False). 
    987                               BottomDockable(False). 
    988                               LeftDockable(True). 
    989                               RightDockable(False). 
    990                               BestSize(wx.Size(w, h)). 
    991                               Hide()) 
    992  
     1006        self._data_panel.set_frame(win) 
    9931007        style = self.__gui_style & GUIFRAME.MANAGER_ON 
    994         data_pane = self._mgr.GetPane(self.panels["data_panel"].window_name) 
    9951008        if style != GUIFRAME.MANAGER_ON: 
    996             data_pane.Hide() 
     1009            flag = False 
    9971010        else: 
    998             data_pane.Show() 
    999              
     1011            flag = True 
     1012        win.Show(flag) 
     1013        d_panel_width = w 
    10001014        # Add the panels to the AUI manager 
    10011015        for panel_class in panels: 
    1002             p = panel_class 
     1016            frame = panel_class.get_frame() 
    10031017            id = wx.NewId() 
    10041018            # Check whether we need to put this panel 
    10051019            # in the center pane 
    1006             if hasattr(p, "CENTER_PANE") and p.CENTER_PANE: 
    1007                 w, h = self._get_panels_size(p) 
    1008                 if p.CENTER_PANE: 
    1009                     self.panels[str(id)] = p 
     1020             
     1021            if hasattr(panel_class, "CENTER_PANE") and panel_class.CENTER_PANE: 
     1022                w, h = self._get_panels_size(panel_class) 
     1023                if panel_class.CENTER_PANE: 
     1024                    self.panels[str(id)] = panel_class 
     1025                    _, pos_y = frame.GetPositionTuple() 
     1026                    frame.SetPosition((d_panel_width, pos_y)) 
     1027                    frame.SetSize((w, h)) 
     1028                    frame.Show(False) 
     1029                    """ 
    10101030                    self._mgr.AddPane(p, wx.aui.AuiPaneInfo(). 
    10111031                                          Name(p.window_name). 
    … …  
    10141034                                          CloseButton(False). 
    10151035                                          Hide()) 
     1036                    """ 
    10161037            else: 
    1017                 self.panels[str(id)] = p 
     1038                self.panels[str(id)] = panel_class 
     1039                frame.SetSize((w, h)) 
     1040                frame.Show(False) 
     1041                #win = MDIFrame(self, p, p.window_name, (w, h)) 
     1042                #win.set_panel(p) 
     1043                """ 
    10181044                self._mgr.AddPane(p, wx.aui.AuiPaneInfo(). 
    10191045                                  Name(p.window_name).Caption(p.window_caption). 
    … …  
    10261052                                  MinimizeButton(). 
    10271053                                  Hide())         
    1028        
     1054                """ 
     1055        #if frame != None: 
     1056        #    frame.EnableCloseButton(False) 
     1057         
    10291058    def update_data(self, prev_data, new_data): 
    10301059        """ 
    … …  
    11081137        delete it. 
    11091138        """ 
    1110         panel = event.GetPane() 
    1111         if panel.IsMaximized(): 
    1112             self._mgr.RestoreMaximizedPane() 
     1139        frame = event.GetEventObject() 
     1140        #panel = frame.panel 
     1141        #if panel.IsMaximized(): 
     1142        #    self._mgr.RestoreMaximizedPane() 
    11131143        for ID in self.plot_panels.keys(): 
    1114             if self.plot_panels[ID].window_name == panel.name: 
     1144            if self.plot_panels[ID].window_name == frame.name: 
    11151145                self.disable_app_menu(self.plot_panels[ID]) 
    11161146                self.delete_panel(ID) 
    … …  
    11301160        ID = wx.NewId() 
    11311161        self.panels[str(ID)] = p 
     1162        ## Check and set the size 
     1163        if PLOPANEL_WIDTH < 0: 
     1164            p_panel_width = int(self._window_width * 0.45) 
     1165        else: 
     1166            p_panel_width = PLOPANEL_WIDTH 
     1167        p_panel_height = int(p_panel_width * 0.76) 
     1168        p.frame.SetSize((p_panel_width, p_panel_height)) 
     1169        """ 
     1170        dw, dh = self._get_panels_size(self._data_panel) 
     1171        dw += p_panel_width 
     1172        _, dh = self.GetToolBar().GetSizeTuple() 
     1173        p.frame.SetPosition((dw, -dh)) 
     1174        """ 
    11321175        self.graph_num += 1 
    11331176        if p.window_caption.split()[0] in NOT_SO_GRAPH_LIST: 
    … …  
    11541197        style2 = self.__gui_style & GUIFRAME.FLOATING_PANEL 
    11551198         
    1156         ## Check and set the size 
    1157         if PLOPANEL_WIDTH < 0: 
    1158             p_panel_width = int(self._window_width * 0.36) 
    1159         else: 
    1160             p_panel_width = PLOPANEL_WIDTH 
    1161         p_panel_height = int(p_panel_width * 0.75) 
    1162          
     1199        p.frame.SetTitle(p.window_caption) 
     1200        p.frame.name = p.window_name 
     1201        p.frame.Show(True) 
     1202        #if p not in self.schedule_full_draw_list: 
     1203        #    self.schedule_full_draw_list.append(p) 
     1204        """ 
    11631205        if style1 == GUIFRAME.FIXED_PANEL: 
    11641206            self._mgr.AddPane(p, wx.aui.AuiPaneInfo(). 
    … …  
    11761218                                               p_panel_height))) 
    11771219            self._popup_fixed_panel(p) 
    1178      
    11791220        elif style2 == GUIFRAME.FLOATING_PANEL: 
    11801221            self._mgr.AddPane(p, wx.aui.AuiPaneInfo(). 
    … …  
    11881229             
    11891230            self._popup_floating_panel(p) 
     1231        """ 
    11901232        # Register for closing of panels 
    1191         self.Bind(wx.aui.EVT_AUI_PANE_CLOSE, self.on_panel_close) 
     1233        #self.Bind(wx.aui.EVT_AUI_PANE_CLOSE, self.on_panel_close) 
    11921234        # Register for showing/hiding the panel 
    11931235        wx.EVT_MENU(self, ID, self.on_view) 
    … …  
    12311273        self._add_menu_tool() 
    12321274        self._add_current_plugin_menu() 
    1233         self._add_menu_window() 
     1275        #self._add_menu_window() 
    12341276        self._add_help_menu() 
    12351277        self.SetMenuBar(self._menubar) 
    … …  
    12511293        application_name = 'No Selected Analysis' 
    12521294        panel_name = 'No Panel on Focus' 
    1253         c_panel = self.cpanel_on_focus 
     1295        c_panel = self.cpanel_on_focus         
    12541296        if self._toolbar is  None: 
    12551297            return 
    … …  
    14451487        self.panel = ConfDialog(parent=self, gui=self.__gui_style) 
    14461488        self.panel.ShowModal() 
    1447         #wx.PostEvent(self.parent, event) 
    1448          
    1449  
    1450     def _add_menu_window(self): 
    1451         """ 
    1452         add a menu window to the menu bar 
    1453         Window menu 
    1454         Attach a menu item for each panel in our 
    1455         panel list that also appears in a plug-in. 
    1456          
    1457         Only add the panel menu if there is only one perspective and 
    1458         it has more than two panels. 
    1459         Note: the first plug-in is always the plotting plug-in.  
    1460         The first application 
    1461         #plug-in is always the second one in the list. 
    1462         """ 
    1463         self._window_menu = wx.Menu() 
    1464         if self._plotting_plugin is not None: 
    1465             for (menu, name) in self._plotting_plugin.populate_menu(self): 
    1466                 self._window_menu.AppendSubMenu(menu, name) 
    1467         self._menubar.Append(self._window_menu, '&Graph') 
    1468  
    1469         style = self.__gui_style & GUIFRAME.PLOTTING_ON 
    1470         if style == GUIFRAME.PLOTTING_ON: 
    1471              
    1472             self._window_menu.AppendSeparator() 
    1473             id = wx.NewId() 
    1474             hint = "Hide all the graph panels" 
    1475             self._window_menu.Append(id, '&Hide  All', hint) 
    1476             wx.EVT_MENU(self, id, self.hide_all_plotpanels) 
    1477             id = wx.NewId() 
    1478             hint = "Show all the graph panels" 
    1479             self._window_menu.Append(id, '&Show All', hint) 
    1480             wx.EVT_MENU(self, id, self.show_all_plotpanels) 
    1481              
    1482             self._window_menu.AppendSeparator() 
    1483             id = wx.NewId() 
    1484             preferences_menu = wx.Menu() 
    1485             hint = "All plot panels will floating" 
    1486             preferences_menu.AppendRadioItem(id, '&Float All', hint) 
    1487             wx.EVT_MENU(self, id, self.set_plotpanel_floating) 
    1488             style = self.__gui_style & GUIFRAME.FLOATING_PANEL 
    1489             f_menu = preferences_menu.FindItemById(id) 
    1490             if style == GUIFRAME.FLOATING_PANEL:  
    1491                 f_checked = True 
    1492             else: 
    1493                 f_checked = False 
    1494             f_menu.Check(f_checked) 
    1495  
    1496             id = wx.NewId() 
    1497             hint = "All plot panels will displayed within the frame" 
    1498             preferences_menu.AppendRadioItem(id, '&Dock All', hint) 
    1499             wx.EVT_MENU(self, id, self.set_plotpanel_fixed)  
    1500             if not f_checked: 
    1501                 d_menu = preferences_menu.FindItemById(id) 
    1502                 d_menu.Check(True) 
    1503             preferences_menu.AppendSeparator() 
    1504             id = wx.NewId() 
    1505             hint = "Clean up the dock area for plots on new-plot" 
    1506             preferences_menu.AppendCheckItem(id, '&CleanUp Dock on NewPlot',  
    1507                                              hint) 
    1508             wx.EVT_MENU(self, id, self.on_cleanup_dock) 
    1509             flag = self.cleanup_plots 
    1510             if self.cleanup_plots: 
    1511                 c_menu = preferences_menu.FindItemById(id) 
    1512                 c_menu.Check(True)   
    1513             self._window_menu.AppendSubMenu(preferences_menu,'&Preferences') 
    1514         if self._window_menu.GetMenuItemCount() == 0: 
    1515             pos = self._menubar.FindMenu('Graph') 
    1516             self._menubar.Remove(pos) 
    1517         #wx.EVT_MENU(self, id, self.show_preferences_panel)    
    1518         #if len(self.plugins) == 2: 
    1519         #    plug = self.plugins[1] 
    1520         #    pers = plug.get_perspective() 
    1521         # 
    1522         #    if len(pers) > 1: 
    1523         #        self._window_menu = wx.Menu() 
    1524         #        for item in self.panels: 
    1525         #            if item == 'default': 
    1526         #                continue 
    1527         #            panel = self.panels[item] 
    1528         #            if panel.window_name in pers: 
    1529         #                self._window_menu.Append(int(item), 
    1530         #                                          panel.window_caption, 
    1531         #                                "Show %s window" % panel.window_caption) 
    1532         #                wx.EVT_MENU(self, int(item), self.on_view) 
    1533         #        self._menubar.Append(self._window_menu, '&Window') 
    15341489 
    15351490                 
    … …  
    15621517                                      "Switch to analysis: %s" % plug.sub_menu) 
    15631518                    wx.EVT_MENU(self, id, plug.on_perspective) 
     1519 
    15641520            #self._applications_menu. 
    15651521            if (not plug_data_count or not plug_no_data_count): 
    … …  
    16531609                               'Preview current panel') 
    16541610        wx.EVT_MENU(self, GUIFRAME_ID.PREVIEW_ID, self.on_preview_panel) 
    1655         #self._edit_menu.Append(GUIFRAME_ID.PRINT_ID, '&Print', 
    1656         #                       'Print current panel') 
    1657         #wx.EVT_MENU(self, GUIFRAME_ID.PRINT_ID, self.on_print_panel) 
     1611 
    16581612        self._edit_menu.Append(GUIFRAME_ID.RESET_ID, '&Reset Page',  
    16591613                               'Reset current panel') 
    … …  
    17161670        wx.CallLater(5*TIME_FACTOR, self.set_schedule(True)) 
    17171671        self.set_plot_unfocus() 
    1718          
    1719     def on_close_welcome_panel(self): 
    1720         """ 
    1721         Close the welcome panel 
    1722         """ 
    1723         if self.defaultPanel is None: 
    1724             return  
    1725         default_panel = self._mgr.GetPane(self.panels["default"].window_name) 
    1726         if default_panel.IsShown(): 
    1727             default_panel.Hide() 
    1728             # Recover current perspective 
    1729             perspective = self._current_perspective 
    1730             perspective.on_perspective(event=None) 
    1731             self._mgr.Update() 
    1732             # Show toolbar 
    1733             #style = self.__gui_style & GUIFRAME.TOOLBAR_ON 
    1734             #if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()): 
    1735             #    self._on_toggle_toolbar() 
    1736              
     1672  
    17371673    def show_welcome_panel(self, event): 
    17381674        """     
    … …  
    17411677        if self.defaultPanel is None: 
    17421678            return  
    1743         for id, panel in self.panels.iteritems(): 
    1744             if id  ==  'default': 
    1745                 # Show default panel 
    1746                 if not self._mgr.GetPane(self.panels["default"].window_name).IsShown(): 
    1747                     self._mgr.GetPane(self.panels["default"].window_name).Show(True) 
    1748             elif id == "data_panel": 
    1749                 flag = self._mgr.GetPane(self.panels["data_panel"].window_name).IsShown() 
    1750                 self._mgr.GetPane(self.panels["data_panel"].window_name).Show(flag) 
    1751             elif panel not in self.plot_panels.values() : 
    1752                 self._mgr.GetPane(self.panels[id].window_name).IsShown() 
    1753                 self._mgr.GetPane(self.panels[id].window_name).Hide() 
    1754         #style = self.__gui_style & GUIFRAME.TOOLBAR_ON 
    1755         #if (style == GUIFRAME.TOOLBAR_ON) & (self._toolbar.IsShown()): 
    1756         #    #    self._toolbar.Show(True) 
    1757         #    self._on_toggle_toolbar() 
    1758  
    1759         self._mgr.Update() 
    1760         
    1761     def show_panel(self, uid, show=None): 
    1762         """ 
    1763         Shows the panel with the given id 
    1764          
    1765         :param uid: unique ID number of the panel to show 
    1766          
    1767         """ 
    1768         ID = str(uid) 
    1769         config.printEVT("show_panel: %s" % ID) 
    1770         if ID in self.panels.keys(): 
    1771             if not self._mgr.GetPane(self.panels[ID].window_name).IsShown():  
    1772                 if show == 'on': 
    1773                     self._mgr.GetPane(self.panels[ID].window_name).Show()    
    1774                 elif self.panels[ID].window_caption.split(" ")[0] == \ 
    1775                                                             "Residuals": 
    1776                     self._mgr.GetPane(self.panels[ID].window_name).Hide() 
    1777                 else: 
    1778                     self._mgr.GetPane(self.panels[ID].window_name).Show() 
    1779                 # Hide default panel 
    1780                 self._mgr.GetPane(self.panels["default"].window_name).Hide() 
    1781         self._mgr.Update()      
    1782         self._redraw_idle() 
    1783  
    1784     def show_all_plotpanels(self, event): 
    1785         """ 
    1786         Show all plotpanels shown 
    1787          
    1788         :param event: menu event 
    1789         """ 
    1790         #event.Skip() 
    1791         any_hidden = False 
    1792         for id in self.plot_panels.keys(): 
    1793             if self._mgr.GetPane(self.plot_panels[id].window_name).IsShown(): 
    1794                 continue 
    1795             else: 
    1796                 any_hidden = True 
    1797                 self.show_panel(id) 
    1798         if not any_hidden: 
    1799             msg = "No hidden graph panel exists." 
    1800         else: 
    1801             # Make sure the Checkmenuitem checked: Need this for-loop \ 
    1802             # because the check menu is not responding on floating panel  
    1803             if IS_WIN: 
    1804                 try: 
    1805                     for item in self._plotting_plugin.menu.GetMenuItems(): 
    1806                         item.Check(True) 
    1807                 except: 
    1808                     # MAC is not using checkmenuitem 
    1809                     pass 
    1810             msg = "All graph panels are shown." 
    1811         wx.PostEvent(self, StatusEvent(status=msg)) 
    1812              
    1813     def hide_all_plotpanels(self, event): 
    1814         """ 
    1815         Hide all plotpanels shown 
    1816          
    1817         :param event: menu event 
    1818         """ 
    1819         #event.Skip() 
    1820         any_shown = False 
    1821         for ID in self.plot_panels.keys(): 
    1822             if self._mgr.GetPane(self.plot_panels[ID].window_name).IsShown(): 
    1823                 any_shown = True 
    1824                 try: 
    1825                     self.hide_panel(ID) 
    1826                 except: 
    1827                     print "hide_panel: No such plot id %s" % ID 
    1828             else: 
    1829                 continue 
    1830         if not any_shown: 
    1831             msg = "No shown graph panel exists." 
    1832         else: 
    1833             # Make sure the Checkmenuitem unchecked: Need this for-loop  
    1834             # because the check menu is not responding on floating panel  
    1835             if IS_WIN: 
    1836                 try: 
    1837                     for item in self._plotting_plugin.menu.GetMenuItems(): 
    1838                         item.Check(False) 
    1839                 except: 
    1840                     # MAC is not using checkmenuitem 
    1841                     pass 
    1842             msg = "All graph panels are hidden." 
    1843         wx.PostEvent(self, StatusEvent(status=msg)) 
    1844                      
    1845     def hide_panel(self, uid): 
    1846         """ 
    1847         hide panel except default panel 
    1848         """ 
    1849         ID = str(uid) 
    1850         caption = self.panels[ID].window_caption 
    1851         config.printEVT("hide_panel: %s" % ID) 
    1852         if ID in self.panels.keys(): 
    1853             pane = self._mgr.GetPane(self.panels[ID].window_name) 
    1854             if pane.IsMaximized(): 
    1855                 self._mgr.RestoreMaximizedPane() 
    1856                 self.disable_app_menu(self.panels[ID]) 
    1857             if pane.IsShown(): 
    1858                 pane.Hide() 
    1859                 item = self._plotting_plugin.menu.FindItemById(uid) 
    1860                 item.Check(False) 
    1861                 if self._data_panel is not None and \ 
    1862                             ID in self.plot_panels.keys(): 
    1863                     self._data_panel.cb_plotpanel.Append(str(caption),  
    1864                                                          self.panels[ID]) 
    1865                 # Do not Hide default panel here... 
    1866                 #self._mgr.GetPane(self.panels["default"].window_name).Hide() 
    1867             wx.CallAfter(self._mgr.Update) 
    1868             self.cpanel_on_focus.SetFocus() 
     1679        frame = self.panels['default'].get_frame() 
     1680        if frame == None: 
     1681            return 
     1682        # Show default panel 
     1683        if not frame.IsShown(): 
     1684            frame.Show(True) 
     1685             
     1686    def on_close_welcome_panel(self): 
     1687        """ 
     1688        Close the welcome panel 
     1689        """ 
     1690        if self.defaultPanel is None: 
     1691            return  
     1692        default_panel = self.panels["default"].frame 
     1693        if default_panel.IsShown(): 
     1694            default_panel.Show(False)  
    18691695                 
    18701696    def delete_panel(self, uid): 
    … …  
    18821708            self.panel_on_focus = None 
    18831709            panel = self.panels[ID] 
    1884             self._mgr.DetachPane(panel) 
     1710            #self._mgr.DetachPane(panel) 
     1711            if hasattr(panel, "connect"): 
     1712                panel.connect.disconnect() 
    18851713            self._plotting_plugin.delete_panel(panel.group_id) 
    1886             panel.Hide() 
    1887             panel.clear() 
    1888             panel.Close() 
     1714            #panel.Hide() 
     1715            #panel.clear() 
     1716            #panel.Close() 
    18891717            if panel in self.schedule_full_draw_list: 
    18901718                self.schedule_full_draw_list.remove(panel)  
    … …  
    18951723            if ID in self.panels.keys(): 
    18961724                del self.panels[ID] 
    1897             #CallAfter: make sure panel is clear before updating mgr 
    1898             wx.CallAfter(self._mgr.Update) 
    18991725            return  
    1900        
    1901     def clear_panel(self): 
    1902         """ 
    1903         Clear the panel 
    1904         """ 
    1905         for item in self.panels: 
    1906             try: 
    1907                 self.panels[item].clear_panel() 
    1908             except: 
    1909                 pass 
    19101726             
    19111727    def create_gui_data(self, data, path=None): 
    … …  
    19541770        if style == GUIFRAME.MANAGER_ON: 
    19551771            if self._data_panel is not None: 
    1956                 #data_state = self._data_manager.get_selected_data() 
    1957                 #self._data_panel.load_data_list(data_state) 
    1958                 self._mgr.GetPane(self._data_panel.window_name).Show(True) 
     1772                self._data_panel.frame.Show(True) 
    19591773       
    19601774    def load_from_cmd(self,  path):    
    … …  
    19811795 
    19821796        self._default_save_location = os.path.dirname(path) 
    1983  
    1984     def load_state(self, path):    
     1797         
     1798    def show_panel(self, uid, show=None): 
     1799        """ 
     1800        Shows the panel with the given id 
     1801         
     1802        :param uid: unique ID number of the panel to show 
     1803         
     1804        """ 
     1805        ID = str(uid) 
     1806        config.printEVT("show_panel: %s" % ID) 
     1807        if ID in self.panels.keys(): 
     1808            if not self.panels[ID].frame.IsShown():  
     1809                if show == 'on': 
     1810                    self.panels[ID].frame.Show()    
     1811                elif self.panels[ID].window_caption.split(" ")[0] == \ 
     1812                                                            "Residuals": 
     1813                    self._mgr.GetPane(self.panels[ID].window_name).Hide() 
     1814                else: 
     1815                    self._mgr.GetPane(self.panels[ID].window_name).Show() 
     1816                # Hide default panel 
     1817                self._mgr.GetPane(self.panels["default"].window_name).Hide() 
     1818        self._mgr.Update()      
     1819        self._redraw_idle() 
     1820         
     1821    def load_state(self, path, is_project=False):    
    19851822        """ 
    19861823        load data from command line or application 
    … …  
    19901827            if APPLICATION_STATE_EXTENSION is not None \ 
    19911828                and basename.endswith(APPLICATION_STATE_EXTENSION): 
    1992                 #Hide current plot_panels i 
    1993                 for ID in self.plot_panels.keys(): 
    1994                     panel = self._mgr.GetPane(self.plot_panels[ID].window_name) 
    1995                     if panel.IsShown(): 
    1996                         panel.Hide() 
     1829                if is_project: 
     1830                    for ID in self.plot_panels.keys(): 
     1831                        panel = self.plot_panels[ID] 
     1832                        panel.on_close(None) 
    19971833            self.get_data(path) 
    19981834            wx.PostEvent(self, StatusEvent(status="Completed loading.")) 
    19991835        else: 
    20001836            wx.PostEvent(self, StatusEvent(status=" ")) 
    2001         if self.defaultPanel is not None and \ 
    2002             self._mgr.GetPane(self.panels["default"].window_name).IsShown(): 
    2003             self.on_close_welcome_panel() 
     1837        #if self.defaultPanel is not None and \ 
     1838        #    self._mgr.GetPane(self.panels["default"].window_name).IsShown(): 
     1839        #    self.on_close_welcome_panel() 
    20041840             
    20051841    def load_data(self, path): 
    … …  
    21321968        #except: 
    21331969         
    2134         self.load_state(path=path) 
     1970        self.load_state(path=path, is_project=True) 
    21351971         
    21361972    def _on_save_application(self, event): 
    … …  
    24162252        :param panels: list of panels 
    24172253        """ 
    2418         #style = self.__gui_style & GUIFRAME.TOOLBAR_ON 
    2419         #if (style == GUIFRAME.TOOLBAR_ON) & (not self._toolbar.IsShown()): 
    2420         #    self._on_toggle_toolbar() 
    2421         for item in self.panels: 
     2254        for item in self.panels.keys(): 
    24222255            # Check whether this is a sticky panel 
    24232256            if hasattr(self.panels[item], "ALWAYS_ON"): 
    24242257                if self.panels[item].ALWAYS_ON: 
    24252258                    continue  
    2426              
     2259            if self.panels[item] == None: 
     2260                continue 
    24272261            if self.panels[item].window_name in panels: 
    2428                 if not self._mgr.GetPane(self.panels[item].window_name).IsShown(): 
    2429                     self._mgr.GetPane(self.panels[item].window_name).Show() 
     2262                frame = self.panels[item].get_frame() 
     2263                if not frame.IsShown(): 
     2264                    frame.Show(True) 
    24302265            else: 
    24312266                # always show the data panel if enable 
    … …  
    24332268                if (style == GUIFRAME.MANAGER_ON) and self.panels[item] == self._data_panel: 
    24342269                    if 'data_panel' in self.panels.keys(): 
    2435                         flag = self._mgr.GetPane(self.panels['data_panel'].window_name).IsShown() 
    2436                         self._mgr.GetPane(self.panels['data_panel'].window_name).Show(flag) 
     2270                        frame = self.panels['data_panel'].get_frame() 
     2271                        if frame == None: 
     2272                            continue 
     2273                        flag = frame.IsShown() 
     2274                        frame.Show(flag) 
    24372275                else: 
    2438                     if self._mgr.GetPane(self.panels[item].window_name).IsShown(): 
    2439                         self._mgr.GetPane(self.panels[item].window_name).Hide() 
    2440                  
    2441         self._mgr.Update() 
     2276                    frame = self.panels[item].get_frame() 
     2277                    if frame == None: 
     2278                        continue 
     2279 
     2280                    if frame.IsShown(): 
     2281                        frame.Show(False) 
    24422282         
    24432283    def show_data_panel(self, event=None, action=True): 
    … …  
    24482288            return 
    24492289        label = self._data_panel_menu.GetText() 
     2290        pane = self.panels["data_panel"] 
     2291        frame = pane.get_frame() 
    24502292        if label == 'Show Data Explorer': 
    2451             pane = self._mgr.GetPane(self.panels["data_panel"].window_name) 
    24522293            #if not pane.IsShown(): 
    24532294            if action:  
    2454                 pane.Show(True) 
    2455                 self._mgr.Update() 
     2295                frame.Show(True) 
    24562296            self.__gui_style = self.__gui_style | GUIFRAME.MANAGER_ON 
    2457              
    24582297            self._data_panel_menu.SetText('Hide Data Explorer') 
    24592298        else: 
    2460             pane = self._mgr.GetPane(self.panels["data_panel"].window_name) 
    2461             #if not pane.IsShown(): 
    24622299            if action: 
    2463                 pane.Show(False) 
    2464                 self._mgr.Update() 
     2300                frame.Show(False) 
    24652301            self.__gui_style = self.__gui_style & (~GUIFRAME.MANAGER_ON) 
    24662302            self._data_panel_menu.SetText('Show Data Explorer') 
    2467      
     2303 
    24682304    def add_data_helper(self, data_list): 
    24692305        """ 
    … …  
    24932329            #wait for button press from the data panel to set_data  
    24942330            if self._data_panel is not None: 
    2495                 self._mgr.GetPane(self._data_panel.window_name).Show(True) 
    2496                 self._mgr.Update()  
     2331                self._data_panel.frame.Show(True) 
    24972332        else: 
    24982333            #automatically send that to the current perspective 
    24992334            self.set_data(data_id=data_list.keys()) 
    2500             self.on_close_welcome_panel() 
    25012335        
    25022336    def set_data(self, data_id, theory_id=None):  
    … …  
    25062340        list_data, _ = self._data_manager.get_by_id(data_id) 
    25072341        if self._current_perspective is not None: 
    2508             if self.cleanup_plots: 
    2509                 for uid, panel in self.plot_panels.iteritems(): 
    2510                     #panel = self.plot_panels[uid] 
    2511                     window = self._mgr.GetPane(panel.window_name) 
    2512                     # To hide all docked plot panels when set the data 
    2513                     if not window.IsFloating(): 
    2514                         self.hide_panel(uid) 
    25152342            self._current_perspective.set_data(list_data.values()) 
    2516             self.on_close_welcome_panel() 
     2343 
    25172344        else: 
    25182345            msg = "Guiframe does not have a current perspective" 
    … …  
    25662393                                                   info='warning')) 
    25672394            else: 
    2568                 if self.cleanup_plots: 
    2569                     for id, panel in self.plot_panels.iteritems(): 
    2570                         window = self._mgr.GetPane(panel.window_name) 
    2571                         # To hide all docked plot panels when set the data 
    2572                         if not window.IsFloating(): 
    2573                             self.hide_panel(id) 
    25742395                #if not append then new plot 
    25752396                from sans.guiframe.dataFitting import Data2D 
    … …  
    25932414        """ 
    25942415        temp = data_id + theory_id 
    2595         """ 
    2596         value = [plug.is_in_use(temp) for plug in self.plugins] 
    2597         if len(value) > 0: 
    2598             print "value" 
    2599             return 
    2600             from data_panel import DataDialog 
    2601             dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA) 
    2602             if dlg.ShowModal() == wx.ID_OK: 
    2603                 selected_data_list = dlg.get_data() 
    2604             dlg.Destroy() 
    2605         """ 
    26062416        for plug in self.plugins: 
    26072417            plug.delete_data(temp) 
    … …  
    28922702                if hasattr(panel, 'CENTER_PANE') and panel.CENTER_PANE: 
    28932703                    for name in self._current_perspective.get_perspective(): 
    2894                         if name == panel.window_name: 
    2895                             panel.on_set_focus(event=None) 
    2896                             break                
     2704                        frame = panel.get_frame() 
     2705                        if frame != None: 
     2706                            if name == panel.window_name: 
     2707                                panel.on_set_focus(event=None) 
     2708                                frame.Show(True) 
     2709                            else: 
     2710                                frame.Show(False) 
     2711                            #break                
    28972712            name = self._current_perspective.sub_menu 
    28982713            if self._data_panel is not None: 
    … …  
    29012716            #Set the SasView title 
    29022717            self._set_title_name(name) 
    2903            
    29042718             
    29052719    def _set_title_name(self, name): 
    … …  
    29262740                        else: 
    29272741                            menu.Check(False)  
    2928             
    2929     def set_plotpanel_floating(self, event=None): 
    2930         """ 
    2931         make the plot panel floatable 
    2932         """ 
    2933          
    2934         self.__gui_style &= (~GUIFRAME.FIXED_PANEL) 
    2935         self.__gui_style |= GUIFRAME.FLOATING_PANEL 
    2936         plot_panel = [] 
    2937         id = event.GetId() 
    2938         menu = self._window_menu.FindItemById(id) 
    2939         if self._plotting_plugin is not None: 
    2940             plot_panel = self.plot_panels.values() 
    2941             for p in plot_panel: 
    2942                 self._popup_floating_panel(p) 
    2943             menu.Check(True) 
    2944              
    2945     def set_plotpanel_fixed(self, event=None): 
    2946         """ 
    2947         make the plot panel fixed 
    2948         """ 
    2949         self.__gui_style &= (~GUIFRAME.FLOATING_PANEL) 
    2950         self.__gui_style |= GUIFRAME.FIXED_PANEL 
    2951         plot_panel = [] 
    2952         id = event.GetId() 
    2953         menu = self._window_menu.FindItemById(id) 
    2954         if self._plotting_plugin is not None: 
    2955             plot_panel = self.plot_panels.values() 
    2956             for p in plot_panel: 
    2957                 self._popup_fixed_panel(p) 
    2958             menu.Check(True) 
    2959              
    2960     def on_cleanup_dock(self, event=None):      
    2961         """ 
    2962         Set Cleanup Dock option 
    2963         """ 
    2964         if event == None: 
    2965             return 
    2966         id = event.GetId() 
    2967         menu = self._window_menu.FindItemById(id) 
    2968         Flag = self.cleanup_plots 
    2969         if not Flag: 
    2970             menu.Check(True) 
    2971             self.cleanup_plots = True 
    2972             msg = "Cleanup-Dock option set to 'ON'." 
    2973         else: 
    2974             menu.Check(False) 
    2975             self.cleanup_plots = False 
    2976             msg = "Cleanup-Dock option set to 'OFF'." 
    2977  
    2978         wx.PostEvent(self, StatusEvent(status= msg)) 
    2979           
    2980     def _popup_fixed_panel(self, p): 
    2981         """ 
    2982         """ 
    2983         style = self.__gui_style & GUIFRAME.FIXED_PANEL 
    2984         if style == GUIFRAME.FIXED_PANEL: 
    2985             pane = self._mgr.GetPane(p.window_name) 
    2986             pane.Dock() 
    2987             pane.Floatable() 
    2988             pane.Right() 
    2989             pane.TopDockable(False) 
    2990             pane.BottomDockable(False) 
    2991             pane.LeftDockable(False) 
    2992             pane.RightDockable(True) 
    2993             self._mgr.Update() 
    2994              
    2995     def _popup_floating_panel(self, p): 
    2996         """ 
    2997         """ 
    2998         style = self.__gui_style &  GUIFRAME.FLOATING_PANEL 
    2999         if style == GUIFRAME.FLOATING_PANEL:  
    3000             pane = self._mgr.GetPane(p.window_name) 
    3001             pane.Floatable(True) 
    3002             pane.Float() 
    3003             pane.Dockable(False) 
    3004             self._mgr.Update() 
    30052742             
    30062743    def enable_add_data(self, new_plot): 
    … …  
    32332970        : return: AuiPaneInfo of the name 
    32342971        """ 
    3235         return self._mgr.GetPane(name)  
     2972        return None#self._mgr.GetPane(name)  
    32362973     
    32372974    def enable_undo(self): 
    … …  
    33253062        if self.cpanel_on_focus is not None: 
    33263063            self._toolbar.enable_reset(self.panel_on_focus) 
    3327  
     3064             
     3065    def get_toolbar_height(self): 
     3066        """ 
     3067        """ 
     3068        size_y = 0 
     3069        if self.GetToolBar() != None and self.GetToolBar().IsShown(): 
     3070            _, size_y = self.GetToolBar().GetSizeTuple() 
     3071        return size_y 
     3072     
    33283073    def set_schedule_full_draw(self, panel=None, func='del'): 
    33293074        """ 
    … …  
    33543099        Draw the panels with axes in the schedule to full dwar list 
    33553100        """ 
     3101         
    33563102        count = len(self.schedule_full_draw_list) 
    33573103        #if not self.schedule: 
    … …  
    33593105            self.set_schedule(False) 
    33603106            return 
     3107 
    33613108        else: 
    33623109            ind = 0 
    … …  
    33643111            for panel in self.schedule_full_draw_list: 
    33653112                ind += 1 
    3366                 if self._mgr.GetPane(panel.window_name).IsShown(): 
     3113                if panel.frame.IsShown(): 
    33673114                    break 
    33683115                # otherwise, return 
    33693116                if ind == count: 
    33703117                    return 
    3371  
    33723118        #Simple redraw only for a panel shown 
    33733119        def f_draw(panel): 
    … …  
    33783124                # This checking of GetCapture is to stop redrawing 
    33793125                # while any panel is capture. 
    3380                 if self.GetCapture() == None: 
     3126                frame = panel.frame 
     3127                 
     3128                if not frame.GetCapture(): 
    33813129                    # draw if possible 
    33823130                    panel.set_resizing(False) 
    3383                     panel.Show(False) 
     3131                    #panel.Show(True) 
    33843132                    panel.draw_plot() 
    3385                      
    3386                     # Check if the panel is not shown 
    3387                     if not self._mgr.GetPane(panel.window_name).IsShown(): 
    3388                         self._mgr.GetPane(panel.window_name).Hide() 
    3389                     else: 
    3390                         panel.Show(True) 
     3133                # Check if the panel is not shown 
     3134                flag = frame.IsShown() 
     3135                frame.Show(flag) 
     3136                    
    33913137            except: 
    3392                 pass 
    3393          
     3138                raise 
     3139      
    33943140        # Draw all panels         
    3395         map(f_draw, self.schedule_full_draw_list) 
    3396          
     3141        #map(f_draw, self.schedule_full_draw_list) 
     3142        f_draw(self.schedule_full_draw_list[0]) 
    33973143        # Reset the attr   
    33983144        if len(self.schedule_full_draw_list) == 0: 
    … …  
    34003146        else: 
    34013147            self.set_schedule(True) 
    3402         # do not update mgr 
    3403         #self._mgr.Update() 
    34043148         
    34053149    def set_schedule(self, schedule=False):   
    … …  
    37033447                                 style=(wx.SIMPLE_BORDER| 
    37043448                                        wx.FRAME_NO_TASKBAR| 
    3705                                         wx.STAY_ON_TOP), 
     3449                                        wx.FRAME_FLOAT_ON_PARENT), 
    37063450                                         
    37073451                        milliseconds=SS_MAX_DISPLAY_TIME, 
    … …  
    37243468        self.maximize_win() 
    37253469 
     3470 
     3471class MDIFrame(wx.MDIChildFrame): 
     3472    """ 
     3473    Frame for panels 
     3474    """ 
     3475    def __init__(self, parent, panel, title="Untitled", 
     3476                size=(300,200), *args, **kwds): 
     3477        """ 
     3478        comment 
     3479        :param parent: parent panel/container 
     3480        """ 
     3481        kwds['size']= size 
     3482        kwds['title']= title 
     3483        # Initialize the Frame object 
     3484        wx.MDIChildFrame.__init__(self, parent, *args, **kwds) 
     3485        self.parent = parent 
     3486        self.name = "Untitled" 
     3487        self.batch_on = self.parent.batch_on 
     3488        self.panel = panel 
     3489        if panel != None: 
     3490            self.set_panel(panel) 
     3491        self.Show(False) 
     3492     
     3493    def show_data_panel(self, action): 
     3494        """ 
     3495        """ 
     3496        self.parent.show_data_panel(action) 
     3497         
     3498    def set_panel(self, panel): 
     3499        """ 
     3500        """ 
     3501        self.panel = panel 
     3502        self.name = panel.window_name 
     3503        self.SetTitle(panel.window_caption) 
     3504        self.SetHelpText(panel.help_string) 
     3505        width, height = self.parent._get_panels_size(panel) 
     3506        if hasattr(panel, "CENTER_PANE") and panel.CENTER_PANE: 
     3507            width *= 0.6   
     3508        self.SetSize((width, height)) 
     3509        self.parent.put_icon(self) 
     3510        self.Bind(wx.EVT_SET_FOCUS, self.set_panel_focus) 
     3511        self.Bind(wx.EVT_CLOSE, self.OnClose) 
     3512        self.Show(False) 
     3513     
     3514    def set_panel_focus(self, event): 
     3515        """ 
     3516        """ 
     3517        self.panel.SetFocus() 
     3518        self.parent.panel_on_focus = self.panel 
     3519        #self.parent.set_panel_on_focus_helper() 
     3520         
     3521    def OnClose(self, event): 
     3522        """ 
     3523        On Close event 
     3524        """ 
     3525        #event.Skip() 
     3526        self.panel.on_close(event) 
     3527        #self.parent.delete_panel(event) 
     3528        #self.DestroyChildren() 
     3529        #self.panel = None 
     3530        #wx.CallAfter(self.Destroy) 
     3531         
    37263532if __name__ == "__main__":  
    37273533    app = ViewApp(0) 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/Plotter1D.py

    r3e001f9 rae84427  
    7373        ## Reference to the parent window 
    7474        self.parent = parent 
     75        if hasattr(parent, "parent"): 
     76            self.parent = self.parent.parent 
    7577        ## Plottables 
    7678        self.plots = {} 
     79        self.frame = None 
    7780        #context menu 
    7881        self._slicerpop = None 
    … …  
    335338        """   
    336339        ax = event.inaxes 
    337         dclick = event.action == 'dclick' 
    338         if ax == None or dclick: 
    339             # remove the vline 
    340             self._check_zoom_plot() 
    341             self.canvas.draw() 
    342             self.q_ctrl = None 
    343             return  
     340        if hasattr(event, "action"): 
     341            dclick = event.action == 'dclick' 
     342            if ax == None or dclick: 
     343                # remove the vline 
     344                self._check_zoom_plot() 
     345                self.canvas.draw() 
     346                self.q_ctrl = None 
     347                return  
    344348        if self.ly != None and event.xdata != None: 
    345349            # Selecting a new line if cursor lines are displayed already 
    … …  
    442446                data = theory_list[id] 
    443447            # Update Graph menu and help string         
    444             h_id = self.parent._window_menu.FindItem(self.window_caption) 
     448            #h_id = self.parent._window_menu.FindItem(self.window_caption) 
    445449            if data != None: 
    446450                if data.__class__.__name__ == 'list': 
    … …  
    450454            else: 
    451455                label = '???' 
    452             helpString = self.parent._window_menu.GetHelpString(h_id)  
     456            #helpString = self.parent._window_menu.GetHelpString(h_id)  
    453457            d_string = (' ' + str(label) +';') 
    454             new_tip = helpString.replace(d_string, '') 
    455             self.parent._window_menu.SetHelpString(h_id, new_tip)   
     458            #new_tip = helpString.replace(d_string, '') 
     459            #self.parent._window_menu.SetHelpString(h_id, new_tip)   
    456460 
    457461            del self.plots[id] 
    … …  
    518522                self.is_zoomed = False 
    519523            # Update Graph menu and help string         
    520             pos = self.parent._window_menu.FindItem(self.window_caption) 
     524            #pos = self.parent._window_menu.FindItem(self.window_caption) 
    521525            helpString = 'Show/Hide Graph: ' 
    522526            for plot in  self.plots.itervalues(): 
    523527                helpString += (' ' + str(plot.label) +';') 
    524             self.parent._window_menu.SetHelpString(pos, helpString)       
    525            
     528            #self.parent._window_menu.SetHelpString(pos, helpString)   
     529                 
    526530    def draw_plot(self): 
    527531        """ 
    … …  
    801805        Add refresh, add/hide button in the tool bar 
    802806        """ 
     807        return 
    803808        if self.parent.__class__.__name__ != 'ViewerFrame': 
    804809            return 
    … …  
    817822            self.parent.hide_panel(self.uid) 
    818823 
     824    def on_close(self, event): 
     825        """ 
     826        On Close Event 
     827        """ 
     828        ID = self.uid 
     829        self.parent.delete_panel(ID) 
     830     
    819831    def createAppDialog(self, event): 
    820832        """ 
    … …  
    859871            self.appearance_selected_plot.label = str(info[3]) 
    860872 
    861             pos = self.parent._window_menu.FindItem(self.window_caption) 
    862             helpString = 'Show/Hide Graph: ' 
    863             for plot in  self.plots.itervalues(): 
    864                 helpString += (' ' + str(plot.label) + ';') 
    865                 self.parent._window_menu.SetHelpString(pos, helpString) 
    866                 self._is_changed_legend_label = True 
     873            #pos = self.parent._window_menu.FindItem(self.window_caption) 
     874            #helpString = 'Show/Hide Graph: ' 
     875            #for plot in  self.plots.itervalues(): 
     876            #    helpString += (' ' + str(plot.label) + ';') 
     877            #    self.parent._window_menu.SetHelpString(pos, helpString) 
     878            #    self._is_changed_legend_label = True 
    867879                 
    868880        self.appD.Destroy() 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/Plotter2D.py

    r3e001f9 rae84427  
    106106        """ 
    107107        ModelPanel1D.__init__(self, parent, id=id, style=style, **kwargs) 
    108          
     108        self.parent = parent 
    109109        ## Reference to the parent window 
    110         self.parent = parent 
     110        if hasattr(parent, "parent"): 
     111            self.parent = self.parent.parent 
    111112        ## Dictionary containing Plottables 
    112113        self.plots = {} 
    … …  
    247248            self.subplot.figure.canvas.draw_idle()     
    248249        # Update Graph menu and help string         
    249         pos = self.parent._window_menu.FindItem(self.window_caption) 
     250        #pos = self.parent._window_menu.FindItem(self.window_caption) 
    250251        helpString = 'Show/Hide Graph: ' 
    251252        helpString += (' ' + str(data.label) +';') 
    252         self.parent._window_menu.SetHelpString(pos, helpString) 
     253        #self.parent._window_menu.SetHelpString(pos, helpString) 
    253254        ## store default value of zmin and zmax  
    254255        self.default_zmin_ctl = self.zmin_2D 
    … …  
    467468        # Update Graph menu and help string  
    468469        if self.title_label != None:      
    469             pos = self.parent._window_menu.FindItem(self.window_caption) 
     470            #pos = self.parent._window_menu.FindItem(self.window_caption) 
    470471            helpString = 'Show/Hide Graph: ' 
    471472            helpString += (' ' + str(self.title_label) +';') 
    472             self.parent._window_menu.SetHelpString(pos, helpString) 
     473            #self.parent._window_menu.SetHelpString(pos, helpString) 
    473474 
    474475         
    … …  
    691692        """ 
    692693        """ 
     694        from sans.guiframe.gui_manager import MDIFrame 
    693695        from boxSum import BoxSum 
    694696        self.onClearSlicer(event) 
    … …  
    704706        ## Create a new panel to display results of summation of Data2D 
    705707        from slicerpanel import SlicerPanel 
    706         new_panel = SlicerPanel(parent=self.parent, id=-1, 
     708        win = MDIFrame(self.parent, None, 'None', (100, 200)) 
     709        new_panel = SlicerPanel(parent=win, id=-1, 
    707710                                    base=self, type=type, 
    708711                                    params=params, style=wx.RAISED_BORDER) 
    … …  
    713716                                    str(self.data2D.name) 
    714717        ## Store a reference of the new created panel 
    715         self.panel_slicer = new_panel 
     718         
    716719        ## save the window_caption of the new panel in the current slicer 
    717720        self.slicer.set_panel_name(name=new_panel.window_caption) 
    718721        ## post slicer panel to guiframe to display it  
    719722        from sans.guiframe.events import SlicerPanelEvent 
    720         wx.PostEvent(self.parent, SlicerPanelEvent(panel=self.panel_slicer, 
     723         
     724        win.set_panel(new_panel) 
     725        new_panel.frame = win 
     726        wx.PostEvent(self.parent, SlicerPanelEvent(panel=new_panel, 
    721727                                                    main_panel=self)) 
    722  
     728        wx.CallAfter(new_panel.frame.Show) 
     729        self.panel_slicer = new_panel 
     730         
    723731    def onBoxavgX(self,event): 
    724732        """ 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/SimplePlot.py

    r9e9e9a5 rae84427  
    2121        """ 
    2222        PlotPanel.__init__(self, parent, id=id, style=style, **kwargs) 
     23 
    2324        self.SetColor(wx.WHITE) 
    2425         
    … …  
    198199        """ 
    199200        # Initialize the Frame object 
    200         wx.Frame.__init__(self, parent, id, title, 
    201                           wx.DefaultPosition, size) 
     201        wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, size) 
    202202         
    203203        # Panel for 1D plot 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/plotting.py

    r3e001f9 rae84427  
    2121from sans.guiframe.dataFitting import Data1D 
    2222from sans.guiframe.dataFitting import Data2D 
    23  
     23from sans.guiframe.gui_manager import MDIFrame 
    2424DEFAULT_MENU_ITEM_LABEL = "No graph available" 
    2525DEFAULT_MENU_ITEM_ID = wx.NewId() 
    … …  
    6969         
    7070        """ 
     71        return [] 
     72        """ 
    7173        self.menu = wx.Menu() 
    7274        self.menu.Append(DEFAULT_MENU_ITEM_ID, DEFAULT_MENU_ITEM_LABEL,  
    … …  
    7476        self.menu.FindItemByPosition(0).Enable(False) 
    7577        return [(self.menu, "Show")] 
     78        """ 
    7679     
    7780    def get_panels(self, parent): 
    … …  
    126129            self.hide_panel(group_id) 
    127130        self.plot_panels = {} 
    128         item = self.menu.FindItemByPosition(0) 
    129         while item != None: 
    130             self.menu.DeleteItem(item)  
    131             try: 
    132                 item = self.menu.FindItemByPosition(0) 
    133             except: 
    134                 item = None 
    135                 
    136131     
    137132    def clear_panel_by_id(self, group_id): 
    … …  
    151146        hide panel with group ID = group_id 
    152147        """ 
    153         if group_id in self.plot_panels.keys(): 
    154             panel = self.plot_panels[group_id] 
    155             self.parent.hide_panel(panel.uid) 
    156             return True 
     148        # Not implemeted 
    157149        return False 
    158150     
    … …  
    171163        new_panel.window_name = data.title 
    172164        event_id = self.parent.popup_panel(new_panel) 
    173         #remove the default item in the menu 
    174         if len(self.plot_panels) == 0: 
    175             pos = self.menu.FindItem(DEFAULT_MENU_ITEM_LABEL) 
    176             if pos != -1: 
    177                 self.menu.Delete(DEFAULT_MENU_ITEM_ID) 
     165 
    178166        # Set UID to allow us to reference the panel later 
    179167        new_panel.uid = event_id 
    180168        # Ship the plottable to its panel 
    181169        wx.CallAfter(new_panel.plot_data, data)  
     170        #new_panel.canvas.set_resizing(new_panel.resizing) 
    182171        self.plot_panels[new_panel.group_id] = new_panel 
    183172         
    184173        # Set Graph menu and help string         
    185         helpString = 'Show/Hide Graph: ' 
     174        self.help_string = ' Graph: ' 
    186175        for plot in  new_panel.plots.itervalues(): 
    187             helpString += (' ' + plot.label + ';') 
    188         self.menu.AppendCheckItem(event_id, new_panel.window_caption,  
    189                                   helpString) 
    190         self.menu.Check(event_id, IS_WIN) 
    191         wx.EVT_MENU(self.parent, event_id, self._on_check_menu) 
     176            help_string += (' ' + plot.label + ';') 
     177        #self.menu.AppendCheckItem(event_id, new_panel.window_caption,  
     178        #                          helpString) 
     179        #self.menu.Check(event_id, IS_WIN) 
     180        #wx.EVT_MENU(self.parent, event_id, self._on_check_menu) 
    192181 
    193182         
    … …  
    203192            ytransform = data.ytransform 
    204193            ## create a plotpanel for 1D Data 
    205             new_panel = ModelPanel1D(self.parent, -1, xtransform=xtransform, 
     194            win = MDIFrame(self.parent, None, 'None', (100, 200)) 
     195            new_panel = ModelPanel1D(win, -1, xtransform=xtransform, 
    206196                     ytransform=ytransform, style=wx.RAISED_BORDER) 
     197            win.set_panel(new_panel) 
     198            win.Show(False) 
     199            new_panel.frame = win 
     200            #win.Show(True) 
    207201            return  new_panel 
    208202         
    … …  
    217211            from Plotter2D import ModelPanel2D 
    218212            scale = data.scale 
    219             new_panel = ModelPanel2D(self.parent, id = -1, 
     213            win = MDIFrame(self.parent, None, 'None', (200, 150)) 
     214            win.Show(False) 
     215            new_panel = ModelPanel2D(win, id = -1, 
    220216                                data2d=data, scale = scale,  
    221217                                style=wx.RAISED_BORDER) 
     218            win.set_panel(new_panel) 
     219            new_panel.frame = win 
     220            #win.Show(True) 
    222221            return new_panel 
    223222        msg = "2D Panel of group ID %s could not be created" % str(group_id) 
    … …  
    247246                data.list_group_id.append(panel.group_id) 
    248247            wx.CallAfter(panel.plot_data, data) 
    249             #Do not show residual plot when it is hidden 
    250             #ToDo: find better way 
    251             if str(panel.group_id)[0:3] == 'res' and not panel.IsShown(): 
    252                 return 
    253             self.parent.show_panel(panel.uid)    
    254      
    255     def delete_menu_item(self, name, uid): 
    256         """ 
    257         """ 
    258         #remove menu item 
    259         pos = self.menu.FindItem(name)  
    260         if pos != -1: 
    261             self.menu.Delete(uid) 
    262         if self.menu.GetMenuItemCount() == 0: 
    263             self.menu.Append(DEFAULT_MENU_ITEM_ID, DEFAULT_MENU_ITEM_LABEL,  
    264                              "No graph available") 
    265             self.menu.FindItemByPosition(0).Enable(False) 
    266          
     248 
    267249    def delete_panel(self, group_id): 
    268250        """ 
    … …  
    275257                                    caption=panel.window_caption)) 
    276258            #remove menu item 
    277             self.delete_menu_item(panel.window_caption, panel.uid) 
     259            #self.delete_menu_item(panel.window_caption, panel.uid) 
    278260            del self.plot_panels[group_id] 
    279261            if uid in self.parent.plot_panels.keys(): 
    280262                del self.parent.plot_panels[uid] 
     263                panel.frame.Destroy() 
    281264            return True 
    282265 
    … …  
    352335            self.create_panel_helper(new_panel, data, group_id, title)  
    353336        return 
    354  
    355     def _on_check_menu(self, event): 
    356         """ 
    357         Check mark on menu 
    358         """ 
    359         #event.Skip() 
    360         event_id = event.GetId() 
    361  
    362         if self.menu.IsChecked(event_id): 
    363             self.parent.on_view(event) 
    364             self.menu.Check(event_id, IS_WIN) 
    365         else: 
    366             self.parent.hide_panel(event_id) 
    367             self.menu.Check(event_id, False) 
    368          
     337        
    369338    def help(self, evt): 
    370339        """ 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/profile_dialog.py

    r657e52c rae84427  
    195195        Show data dialog 
    196196        """    
    197         self.parent.parent.parent.show_data1d(data, name) 
     197        self.parent._manager.parent.show_data1d(data, name) 
    198198         
    199199class SLDplotpanel(PlotPanel): 
    … …  
    300300            # What an ancestor! 
    301301            fit_panel = self.parent.parent.parent 
    302             fit_panel.parent.save_data1d(data, default_name) 
     302            fit_panel._manager.parent.save_data1d(data, default_name) 
    303303              
    304304class ViewerFrame(wx.Frame): 

  • sansguiframe/src/sans/guiframe/local_perspectives/plotting/slicerpanel.py

    rd555416 rae84427  
    3232            params = {} 
    3333        self.params = params 
    34         self.parent = parent 
     34        self.parent = base.parent 
     35        self.frame = None 
    3536        self.type = type 
    3637        self.listeners = [] 
    … …  
    118119        #self.bck.Fit(self) 
    119120        self.Layout() 
    120         self.parent.GetSizer().Layout() 
     121        psizer = self.parent.GetSizer() 
     122        if psizer != None: 
     123            psizer.Layout() 
    121124         
    122125    def onSetFocus(self, evt): 
    … …  
    163166            event = SlicerParameterEvent(type=self.type, params=params) 
    164167            wx.PostEvent(self.base, event) 
    165              
    166          
     168 
     169    def on_close(self, event): 
     170        """ 
     171        On Close Event 
     172        """ 
     173        ID = self.uid 
     174        self.parent.delete_panel(ID)             
     175        self.frame.Destroy() 

  • sansguiframe/src/sans/guiframe/panel_base.py

    r225ed2d rae84427  
    5757        
    5858        self.group_id = None 
     59        self.help_string = '' 
    5960 
    6061    def on_batch_selection(self, event): 
    … …  
    426427        """ 
    427428        """ 
    428         return self._manager 
     429        return self._manager   
     430       
     431    def get_frame(self): 
     432        """ 
     433        """ 
     434        if self._manager == None: 
     435            return None 
     436        return self._manager.frame 
     437     
     438    def on_close(self, event): 
     439        """ 
     440        On Close Event 
     441        """ 
     442        if self.frame != None: 
     443            self.frame.Destroy() 
     444             

  • sansguiframe/src/sans/guiframe/plugin_base.py

    rda7cacb rae84427  
    4141        ## Reference to the parent window. Filled by get_panels() below. 
    4242        self.parent = None 
     43        self.frame = None 
    4344        #plugin state reader 
    4445        self.state_reader = None  
    … …  
    145146        return [] 
    146147     
     148    def get_frame(self): 
     149        """ 
     150        Returns MDIChildFrame 
     151        """ 
     152        return self.frame 
     153 
     154    def _frame_set_helper(self): 
     155        """ 
     156        Sets default frame config 
     157        """ 
     158        if self.frame != None: 
     159            self.frame.EnableCloseButton(False) 
     160            self.frame.Show(False) 
     161     
    147162    def get_panels(self, parent): 
    148163        """ 
    … …  
    212227         
    213228        """ 
     229        old_frame = None 
     230        tool_height = self.parent.get_toolbar_height() 
     231        old_persp = self.parent.get_current_perspective() 
     232        if old_persp != None: 
     233            old_frame = old_persp.get_frame() 
    214234        self.parent.check_multimode(self) 
    215235        self.parent.set_current_perspective(self) 
    216236        self.parent.set_perspective(self.perspective) 
     237         
     238        if self.frame != None: 
     239            if old_frame != None: 
     240                pos_x, pos_y = old_frame.GetPositionTuple() 
     241                self.frame.SetPosition((pos_x, pos_y - tool_height)) 
     242            if not self.frame.IsShown(): 
     243                self.frame.Show(True) 
    217244         
    218245         

  • sansguiframe/src/sans/guiframe/startup_configuration.py

    r657e52c rae84427  
    126126            p_size = None 
    127127            for panel in self.parent.plot_panels.values(): 
    128                 p_panel = self.parent._mgr.GetPane(panel.window_name) 
    129                 if p_panel.IsShown(): 
    130                     if p_size == None or panel.size > p_size: 
    131                         p_size = panel.size 
     128                #p_panel = self.parent._mgr.GetPane(panel.window_name) 
     129                width, _ = panel.frame.GetSizeTuple() 
     130                if panel.frame.IsShown(): 
     131                    if p_size == None or width > p_size: 
     132                        p_size = width 
    132133            if p_size == None: 
    133134                p_size = CURRENT_STRINGS['PLOPANEL_WIDTH'] 
    134135            self.current_string['PLOPANEL_WIDTH'] = p_size 
    135136             
    136             data_pw, _ = self.parent.panels["data_panel"].GetSizeTuple() 
     137            data_pw, _ = self.parent.panels["data_panel"].frame.GetSizeTuple() 
    137138            if data_pw == None: 
    138139                data_pw = CURRENT_STRINGS['DATAPANEL_WIDTH'] 
    … …  
    140141             
    141142            #label = self.parent._data_panel_menu.GetText() 
    142             label = self.parent._mgr.GetPane(\ 
    143                         self.parent.panels['data_panel'].window_name).IsShown() 
     143            label = self.parent.panels['data_panel'].frame.IsShown() 
    144144            if label:# == 'Hide Data Explorer': 
    145145                self.current_string['DATALOADER_SHOW'] = True 
    … …  
    158158                self.current_string['FIXED_PANEL'] = True 
    159159                 
    160             if self.parent._mgr.GetPane(self.parent.panels['default'].window_name).IsShown(): 
     160            if self.parent.panels['default'].frame.IsShown(): 
    161161                self.current_string['WELCOME_PANEL_SHOW'] = True 
    162162            else: 
    … …  
    197197        fname = os.path.join(self.path, 'custom_config.py') 
    198198        self.write_string(fname, self.return_string) 
    199      
    200199        self.Destroy() 
    201200 

  • sansview/welcome_panel.py

    r657e52c rae84427  
    3737        PanelBase.__init__(self) 
    3838        #For sasview the parent is guiframe 
    39         self.parent = parent 
     39        self.parent = parent.parent 
     40        self.frame = None 
    4041        
    4142        welcome_page = WelcomePage(self) 
    … …  
    6364        """ 
    6465        pass 
     66     
     67    def set_frame(self, frame): 
     68        """ 
     69        """ 
     70        self.frame = frame 
     71        if frame != None: 
     72            self.frame.Bind(wx.EVT_CLOSE, self.on_close_page) 
     73     
     74    def get_frame(self): 
     75        """ 
     76        """ 
     77        return self.frame 
    6578     
    6679     
Note: See TracChangeset for help on using the changeset viewer.