Changeset 7df0ccd in sasview for src/sas/sasgui/guiframe


Ignore:
Timestamp:
Jun 16, 2017 11:04:34 AM (7 years ago)
Author:
Paul Kienzle <pkienzle@…>
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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
de995e5b
Parents:
13fe3be (diff), d9c1551 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ticket-887-reorg

Location:
src/sas/sasgui/guiframe
Files:
1 added
1 deleted
12 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

    r7432acb r3e5648b  
    361361                if self.slicer.__class__.__name__ != "BoxSum": 
    362362                    wx_id = ids.next() 
    363                     slicerpop.Append(wx_id, '&Edit Slicer Parameters') 
     363                    name = '&Edit Slicer Parameters and Batch Slicing' 
     364                    slicerpop.Append(wx_id, name) 
    364365                    wx.EVT_MENU(self, wx_id, self._onEditSlicer) 
    365366            slicerpop.AppendSeparator() 
    … …  
    532533 
    533534        """ 
    534         ## Clear current slicer 
     535        # Clear current slicer 
    535536        if self.slicer is not None: 
    536537            self.slicer.clear() 
    537         ## Create a new slicer 
     538        # Create a new slicer 
    538539        self.slicer_z += 1 
    539540        self.slicer = slicer(self, self.subplot, zorder=self.slicer_z) 
    540541        self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax) 
    541542        self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax) 
    542         ## Draw slicer 
     543        # Draw slicer 
    543544        self.update() 
    544545        self.slicer.update() 
    … …  
    572573        npt = math.floor(npt) 
    573574        from sas.sascalc.dataloader.manipulations import CircularAverage 
    574         ## compute the maximum radius of data2D 
     575        # compute the maximum radius of data2D 
    575576        self.qmax = max(math.fabs(self.data2D.xmax), 
    576577                        math.fabs(self.data2D.xmin)) 
    … …  
    578579                        math.fabs(self.data2D.ymin)) 
    579580        self.radius = math.sqrt(math.pow(self.qmax, 2) + math.pow(self.ymax, 2)) 
    580         ##Compute beam width 
     581        # Compute beam width 
    581582        bin_width = (self.qmax + self.qmax) / npt 
    582         ## Create data1D circular average of data2D 
     583        # Create data1D circular average of data2D 
    583584        Circle = CircularAverage(r_min=0, r_max=self.radius, 
    584585                                 bin_width=bin_width) 
    … …  
    599600        new_plot.name = "Circ avg " + self.data2D.name 
    600601        new_plot.source = self.data2D.source 
    601         #new_plot.info = self.data2D.info 
     602        # new_plot.info = self.data2D.info 
    602603        new_plot.interactive = True 
    603604        new_plot.detector = self.data2D.detector 
    604605 
    605         ## If the data file does not tell us what the axes are, just assume... 
     606        # If the data file does not tell us what the axes are, just assume... 
    606607        new_plot.xaxis("\\rm{Q}", "A^{-1}") 
    607608        if hasattr(self.data2D, "scale") and \ 
    … …  
    615616        new_plot.id = "Circ avg " + self.data2D.name 
    616617        new_plot.is_data = True 
    617         self.parent.update_theory(data_id=self.data2D.id, \ 
    618                                        theory=new_plot) 
     618        self.parent.update_theory(data_id=self.data2D.id, theory=new_plot) 
    619619        wx.PostEvent(self.parent, 
    620620                     NewPlotEvent(plot=new_plot, title=new_plot.name)) 
    … …  
    630630        """ 
    631631        if self.slicer is not None: 
    632             from SlicerParameters import SlicerParameterPanel 
     632            from parameters_panel_slicer import SlicerParameterPanel 
    633633            dialog = SlicerParameterPanel(self, -1, "Slicer Parameters") 
    634634            dialog.set_slicer(self.slicer.__class__.__name__, 
    … …  
    668668        params = self.slicer.get_params() 
    669669        ## Create a new panel to display results of summation of Data2D 
    670         from slicerpanel import SlicerPanel 
     670        from parameters_panel_boxsum import SlicerPanel 
    671671        win = MDIFrame(self.parent, None, 'None', (100, 200)) 
    672672        new_panel = SlicerPanel(parent=win, id=-1, 
    … …  
    758758        if default_name.count('.') > 0: 
    759759            default_name = default_name.split('.')[0] 
    760         #default_name += "_out" 
    761760        if self.parent is not None: 
    762761            self.parent.show_data2d(data, default_name) 
    763762 
    764763    def modifyGraphAppearance(self, e): 
    765         self.graphApp = graphAppearance(self, 'Modify graph appearance', legend=False) 
     764        self.graphApp = graphAppearance(self, 'Modify graph appearance', 
     765                                        legend=False) 
    766766        self.graphApp.setDefaults(self.grid_on, self.legend_on, 
    767767                                  self.xaxis_label, self.yaxis_label, 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

    r7432acb r8de66b6  
    3737        ## Absolute value of the Angle between the middle line and any side line 
    3838        self.phi = math.pi / 12 
     39        # Binning base for log/lin binning 
     40        self.bin_base = 0 
    3941        ## Middle line 
    4042        self.main_line = LineInteractor(self, self.base.subplot, color='blue', 
    … …  
    151153        phimin = -self.left_line.phi + self.main_line.theta 
    152154        phimax = self.left_line.phi + self.main_line.theta 
     155        bin_base = self.bin_base 
    153156        if nbins is None: 
    154157            nbins = 20 
    155158        sect = SectorQ(r_min=0.0, r_max=radius, 
    156159                       phi_min=phimin + math.pi, 
    157                        phi_max=phimax + math.pi, nbins=nbins) 
     160                       phi_max=phimax + math.pi, nbins=nbins, base=bin_base) 
    158161 
    159162        sector = sect(self.base.data2D) 
    … …  
    239242        params["Delta_Phi [deg]"] = math.fabs(self.left_line.phi * 180 / math.pi) 
    240243        params["nbins"] = self.nbins 
     244        params["binning base"] = self.bin_base 
    241245        return params 
    242246 
    … …  
    252256        phi = math.fabs(params["Delta_Phi [deg]"] * math.pi / 180) 
    253257        self.nbins = int(params["nbins"]) 
     258        self.bin_base = params["binning base"] 
    254259        self.main_line.theta = main 
    255260        ## Reset the slicer parameters 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_boxsum.py

    r7432acb r37d461c  
    11import wx 
    22import wx.lib.newevent 
    3 #from copy import deepcopy 
     3from parameters_panel_slicer import SlicerParameterPanel 
    44from sas.sasgui.guiframe.utils import format_number 
    5 from sas.sasgui.guiframe.events import SlicerParameterEvent 
    6 from sas.sasgui.guiframe.events import EVT_SLICER_PARS 
    7 from sas.sasgui.guiframe.events import EVT_SLICER 
     5from sas.sasgui.guiframe.panel_base import PanelBase 
     6from sas.sasgui.guiframe.events import (SlicerParameterEvent, EVT_SLICER_PARS, 
     7                                        EVT_SLICER) 
    88 
    9 from sas.sasgui.guiframe.panel_base import PanelBase 
    109 
    1110class SlicerPanel(wx.Panel, PanelBase): 
    … …  
    1312    Panel class to show the slicer parameters 
    1413    """ 
    15     #TODO: show units 
    16     #TODO: order parameters properly 
    17     ## Internal name for the AUI manager 
     14    # Internal name for the AUI manager 
    1815    window_name = "Slicer panel" 
    19     ## Title to appear on top of the window 
     16    # Title to appear on top of the window 
    2017    window_caption = "Slicer Panel" 
    2118    CENTER_PANE = False 
    … …  
    2522        wx.Panel.__init__(self, parent, id, *args, **kwargs) 
    2623        PanelBase.__init__(self) 
    27         ## Initialization of the class 
     24        # Initialization of the class 
    2825        self.base = base 
    2926        if params is None: 
    … …  
    4441        else: 
    4542            self.set_slicer(type, params) 
    46         ## Bindings 
    47         self.parent.Bind(EVT_SLICER, self.onEVT_SLICER) 
    48         self.parent.Bind(EVT_SLICER_PARS, self.onParamChange) 
    49  
    50     def onEVT_SLICER(self, event): 
    51         """ 
    52         Process EVT_SLICER events 
    53         When the slicer changes, update the panel 
    54  
    55         :param event: EVT_SLICER event 
    56  
    57         """ 
    58         event.Skip() 
    59         if event.obj_class is None: 
    60             self.set_slicer(None, None) 
    61         else: 
    62             self.set_slicer(event.type, event.params) 
     43        # Bindings 
     44        self.parent.Bind(EVT_SLICER, SlicerParameterPanel.on_evt_slicer) 
     45        self.parent.Bind(EVT_SLICER_PARS, SlicerParameterPanel.on_param_change) 
    6346 
    6447    def set_slicer(self, type, params): 
    … …  
    8467            keys.sort() 
    8568            for item in keys: 
    86                 if not item.lower() in ["num_points", "avg", "avg_error", "sum", "sum_error"]: 
     69                if not item.lower() in ["num_points", "avg", "avg_error", "sum", 
     70                                        "sum_error"]: 
    8771                    n += 1 
    8872                    text = wx.StaticText(self, -1, item, style=wx.ALIGN_LEFT) 
    8973                    self.bck.Add(text, (n - 1, 0), 
    90                                  flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL, border=15) 
     74                                 flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 
     75                                 border=15) 
    9176                    ctl = wx.TextCtrl(self, -1, size=(80, 20), 
    9277                                      style=wx.TE_PROCESS_ENTER) 
    … …  
    9580                    ctl.SetToolTipString(hint_msg) 
    9681                    ctl.SetValue(str(format_number(params[item]))) 
    97                     self.Bind(wx.EVT_TEXT_ENTER, self.onTextEnter) 
    98                     ctl.Bind(wx.EVT_SET_FOCUS, self.onSetFocus) 
    99                     ctl.Bind(wx.EVT_KILL_FOCUS, self.onTextEnter) 
     82                    self.Bind(wx.EVT_TEXT_ENTER, self.on_text_enter) 
     83                    ctl.Bind(wx.EVT_SET_FOCUS, self.on_set_focus) 
     84                    ctl.Bind(wx.EVT_KILL_FOCUS, self.on_text_enter) 
    10085                    self.parameters.append([item, ctl]) 
    101                     self.bck.Add(ctl, (n - 1, 1), flag=wx.TOP | wx.BOTTOM, border=0) 
     86                    self.bck.Add(ctl, (n - 1, 1), flag=wx.TOP | wx.BOTTOM, 
     87                                 border=0) 
    10288            for item in keys: 
    103                 if  item.lower() in ["num_points", "avg", "avg_error", "sum", "sum_error"]: 
     89                if item.lower() in ["num_points", "avg", "avg_error", "sum", 
     90                                    "sum_error"]: 
    10491                    n += 1 
    105                     text = wx.StaticText(self, -1, item + ": ", style=wx.ALIGN_LEFT) 
    106                     self.bck.Add(text, (n - 1, 0), flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 
     92                    text = wx.StaticText(self, -1, item + ": ", 
     93                                         style=wx.ALIGN_LEFT) 
     94                    self.bck.Add(text, (n - 1, 0), 
     95                                 flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 
    10796                                 border=15) 
    10897                    ctl = wx.StaticText(self, -1, 
    … …  
    11099                                        style=wx.ALIGN_LEFT) 
    111100                    ctl.SetToolTipString("Result %s" % item) 
    112                     self.bck.Add(ctl, (n - 1, 1), flag=wx.TOP | wx.BOTTOM, border=0) 
     101                    self.bck.Add(ctl, (n - 1, 1), flag=wx.TOP | wx.BOTTOM, 
     102                                 border=0) 
    113103        self.bck.Layout() 
    114104        self.Layout() 
    115         psizer = self.parent.GetSizer() 
    116         if psizer is not None: 
    117             psizer.Layout() 
     105        p_sizer = self.parent.GetSizer() 
     106        if p_sizer is not None: 
     107            p_sizer.Layout() 
    118108 
    119     def onSetFocus(self, evt): 
     109    def on_set_focus(self, evt): 
    120110        """ 
    121111        Highlight the txtcrtl 
    … …  
    126116        # Select the whole control, after this event resolves 
    127117        wx.CallAfter(widget.SetSelection, -1, -1) 
    128         return 
    129118 
    130     def onParamChange(self, evt): 
    131         """ 
    132         Receive and event and reset the text field contained in self.parameters 
    133  
    134         """ 
    135         evt.Skip() 
    136         for item in self.parameters: 
    137             if item[0] in evt.params: 
    138                 item[1].SetValue(format_number(evt.params[item[0]])) 
    139                 item[1].Refresh() 
    140  
    141     def onTextEnter(self, evt): 
     119    def on_text_enter(self, evt): 
    142120        """ 
    143121        Parameters have changed 
    … …  
    149127            try: 
    150128                params[item[0]] = float(item[1].GetValue()) 
    151                 item[1].SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW)) 
     129                item[1].SetBackgroundColour(wx.SystemSettings_GetColour( 
     130                    wx.SYS_COLOUR_WINDOW)) 
    152131                item[1].Refresh() 
    153132            except: 
    … …  
    155134                item[1].SetBackgroundColour("pink") 
    156135                item[1].Refresh() 
    157  
    158         if has_error == False: 
     136        if not has_error: 
    159137            # Post parameter event 
    160             ## base is guiframe is this case 
     138            # base is guiframe is this case 
    161139            event = SlicerParameterEvent(type=self.type, params=params) 
    162140            wx.PostEvent(self.base, event) 
    … …  
    166144        On Close Event 
    167145        """ 
    168         ID = self.uid 
    169         self.parent.delete_panel(ID) 
     146        uid = self.uid 
     147        self.parent.delete_panel(uid) 
    170148        self.frame.Destroy() 

  • src/sas/sasgui/guiframe/CategoryInstaller.py

    r235f514 r914ba0a  
    1414import logging 
    1515from collections import defaultdict, OrderedDict 
     16 
     17from sas.sasgui import get_user_dir 
    1618 
    1719USER_FILE = 'categories.json' 
    … …  
    6971 
    7072    @staticmethod 
    71     def _get_home_dir(): 
    72         """ 
    73         returns the users sasview config dir 
    74         """ 
    75         return os.path.join(os.path.expanduser("~"), ".sasview") 
    76  
    77     @staticmethod 
    7873    def _regenerate_model_dict(master_category_dict): 
    7974        """ 
    … …  
    8580        by_model_dict = defaultdict(list) 
    8681        model_enabled_dict = defaultdict(bool) 
    87          
     82 
    8883        for category in master_category_dict: 
    8984            for (model, enabled) in master_category_dict[category]: 
    … …  
    9691    def _regenerate_master_dict(by_model_dict, model_enabled_dict): 
    9792        """ 
    98         regenerates master_category_dict from by_model_dict  
     93        regenerates master_category_dict from by_model_dict 
    9994        and model_enabled_dict 
    10095        returns the master category dictionary 
    … …  
    112107        returns the user data file, eg .sasview/categories.json.json 
    113108        """ 
    114         return os.path.join(CategoryInstaller._get_home_dir(), USER_FILE) 
     109        return os.path.join(get_user_dir(), USER_FILE) 
    115110 
    116111    @staticmethod 
    … …  
    150145                model_name, enabled = master_category_dict[cat][ind] 
    151146                if model_name not in _model_list: 
    152                     del_name = True  
     147                    del_name = True 
    153148                    try: 
    154149                        by_model_dict.pop(model_name) 

  • src/sas/sasgui/guiframe/aboutbox.py

    r959eb01 r914ba0a  
    2424import os.path 
    2525import os 
    26 try: 
    27     # Try to find a local config 
    28     import imp 
    29     path = os.getcwd() 
    30     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    31       (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    32         fObj, path, descr = imp.find_module('local_config', [path]) 
    33         config = imp.load_module('local_config', fObj, path, descr)   
    34     else: 
    35         # Try simply importing local_config 
    36         import local_config as config 
    37 except: 
    38     # Didn't find local config, load the default  
    39     import config 
     26 
     27from sas.sasgui import get_local_config 
     28config = get_local_config() 
    4029 
    4130def launchBrowser(url): 
    4231    """ 
    4332    Launches browser and opens specified url 
    44      
     33 
    4534    In some cases may require BROWSER environment variable to be set up. 
    46      
     35 
    4736    :param url: URL to open 
    48      
     37 
    4938    """ 
    5039    import webbrowser 
    … …  
    5544    """ 
    5645    "About" Dialog 
    57      
     46 
    5847    Shows product name, current version, authors, and link to the product page. 
    5948    Current version is taken from version.py 
    60      
    61     """ 
    62      
     49 
     50    """ 
     51 
    6352    def __init__(self, *args, **kwds): 
    6453 
    … …  
    6655        kwds["style"] = wx.DEFAULT_DIALOG_STYLE 
    6756        wx.Dialog.__init__(self, *args, **kwds) 
    68          
     57 
    6958        file_dir = os.path.dirname(__file__) 
    70          
     59 
    7160        # Mac doesn't display images with transparent background so well, 
    7261        # keep it for Windows 
    7362        image = file_dir + "/images/angles_flat.png" 
    74          
     63 
    7564        if os.path.isfile(config._corner_image): 
    7665            image = config._corner_image 
    … …  
    8069        else: 
    8170            self.bitmap_logo = wx.StaticBitmap(self, -1, wx.Bitmap(image)) 
    82          
     71 
    8372        self.label_title = wx.StaticText(self, -1, config.__appname__) 
    8473        self.label_version = wx.StaticText(self, -1, "") 
    … …  
    112101        #self.bitmap_button_danse = wx.BitmapButton(self, -1, wx.NullBitmap) 
    113102        self.bitmap_button_msu = wx.BitmapButton(self, -1, wx.NullBitmap) 
    114          
     103 
    115104        self.bitmap_button_isis = wx.BitmapButton(self, -1, wx.NullBitmap) 
    116105        self.bitmap_button_ess = wx.BitmapButton(self, -1, wx.NullBitmap) 
    … …  
    119108        self.bitmap_button_tudelft = wx.BitmapButton(self, -1, wx.NullBitmap) 
    120109        self.bitmap_button_dls = wx.BitmapButton(self, -1, wx.NullBitmap) 
    121          
     110 
    122111        self.static_line_3 = wx.StaticLine(self, -1) 
    123112        self.button_OK = wx.Button(self, wx.ID_OK, "OK") 
    … …  
    125114        self.__set_properties() 
    126115        self.__do_layout() 
    127          
     116 
    128117        self.Bind(wx.EVT_BUTTON, self.onNistLogo, self.bitmap_button_nist) 
    129118        self.Bind(wx.EVT_BUTTON, self.onUmdLogo, self.bitmap_button_umd) 
    … …  
    145134        random.shuffle(config._authors) 
    146135        strLabel = ", ".join(config._authors) 
    147          
     136 
    148137        # display version and svn revison numbers 
    149138        verwords = config.__version__.split('.') 
    … …  
    157146        self.label_version.SetLabel(config.__version__)#(version) 
    158147        self.label_svnrevision.SetLabel(build_num) 
    159          
     148 
    160149        # set bitmaps for logo buttons 
    161150        image = file_dir + "/images/nist_logo.png" 
    162151        if os.path.isfile(config._nist_logo): 
    163152            image = config._nist_logo 
    164         logo = wx.Bitmap(image)         
     153        logo = wx.Bitmap(image) 
    165154        self.bitmap_button_nist.SetBitmapLabel(logo) 
    166          
     155 
    167156        image = file_dir + "/images/umd_logo.png" 
    168157        if os.path.isfile(config._umd_logo): 
    169158            image = config._umd_logo 
    170         logo = wx.Bitmap(image)         
     159        logo = wx.Bitmap(image) 
    171160        self.bitmap_button_umd.SetBitmapLabel(logo) 
    172161 
    … …  
    174163        if os.path.isfile(config._ornl_logo): 
    175164            image = config._ornl_logo 
    176         logo = wx.Bitmap(image)         
     165        logo = wx.Bitmap(image) 
    177166        self.bitmap_button_ornl.SetBitmapLabel(logo) 
    178167 
    … …  
    181170        if os.path.isfile(config._sns_logo): 
    182171            image = config._sns_logo 
    183         logo = wx.Bitmap(image)         
     172        logo = wx.Bitmap(image) 
    184173        self.bitmap_button_sns.SetBitmapLabel(logo) 
    185          
     174 
    186175        image = file_dir + "/images/nsf_logo.png" 
    187176        if os.path.isfile(config._nsf_logo): 
    188177            image = config._nsf_logo 
    189         logo = wx.Bitmap(image)         
     178        logo = wx.Bitmap(image) 
    190179        self.bitmap_button_nsf.SetBitmapLabel(logo) 
    191180 
    … …  
    201190        logo = wx.Bitmap(image) 
    202191        self.bitmap_button_msu.SetBitmapLabel(logo) 
    203          
     192 
    204193        image = file_dir + "/images/isis_logo.png" 
    205194        if os.path.isfile(config._isis_logo): 
    206195            image = config._isis_logo 
    207         logo = wx.Bitmap(image)         
     196        logo = wx.Bitmap(image) 
    208197        self.bitmap_button_isis.SetBitmapLabel(logo) 
    209198 
    … …  
    213202        logo = wx.Bitmap(image) 
    214203        self.bitmap_button_ess.SetBitmapLabel(logo) 
    215          
     204 
    216205        image = file_dir + "/images/ill_logo.png" 
    217206        if os.path.isfile(config._ill_logo): 
    … …  
    219208        logo = wx.Bitmap(image) 
    220209        self.bitmap_button_ill.SetBitmapLabel(logo) 
    221          
     210 
    222211        image = file_dir + "/images/ansto_logo.png" 
    223212        if os.path.isfile(config._ansto_logo): 
    … …  
    225214        logo = wx.Bitmap(image) 
    226215        self.bitmap_button_ansto.SetBitmapLabel(logo) 
    227          
     216 
    228217        image = file_dir + "/images/tudelft_logo.png" 
    229218        if os.path.isfile(config._tudelft_logo): 
    … …  
    231220        logo = wx.Bitmap(image) 
    232221        self.bitmap_button_tudelft.SetBitmapLabel(logo) 
    233          
     222 
    234223        image = file_dir + "/images/dls_logo.png" 
    235224        if os.path.isfile(config._dls_logo): 
    … …  
    237226        logo = wx.Bitmap(image) 
    238227        self.bitmap_button_dls.SetBitmapLabel(logo) 
    239                  
     228 
    240229        # resize dialog window to fit version number nicely 
    241230        if wx.VERSION >= (2, 7, 2, 0): 
    … …  
    244233            size = [self.GetBestFittingSize()[0], self.GetSize()[1]] 
    245234        self.Fit() 
    246          
     235 
    247236    def __set_properties(self): 
    248237        """ 
    … …  
    310299        sizer_main.Add(self.static_line_2, 0, wx.EXPAND, 0) 
    311300 
    312         sizer_logos.Add(self.bitmap_button_msu, 0,  
     301        sizer_logos.Add(self.bitmap_button_msu, 0, 
    313302                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    314303        #sizer_logos.Add(self.bitmap_button_danse, 0, 
    315304        #                wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    316         #sizer_logos.Add(self.bitmap_button_nsf, 0,  
     305        #sizer_logos.Add(self.bitmap_button_nsf, 0, 
    317306        #                wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    318         sizer_logos.Add(self.bitmap_button_umd, 0,  
    319                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    320         sizer_logos.Add(self.bitmap_button_nist, 0,  
    321                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    322         #sizer_logos.Add(self.bitmap_button_sns, 0,  
     307        sizer_logos.Add(self.bitmap_button_umd, 0, 
     308                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     309        sizer_logos.Add(self.bitmap_button_nist, 0, 
     310                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     311        #sizer_logos.Add(self.bitmap_button_sns, 0, 
    323312        #                wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    324         sizer_logos.Add(self.bitmap_button_ornl, 0,  
    325                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    326         sizer_logos.Add(self.bitmap_button_isis, 0,  
    327                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    328         sizer_logos.Add(self.bitmap_button_ess, 0,  
    329                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    330         sizer_logos.Add(self.bitmap_button_ill, 0,  
    331                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    332         sizer_logos.Add(self.bitmap_button_ansto, 0,  
    333                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    334         sizer_logos.Add(self.bitmap_button_tudelft, 0,  
    335                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    336         sizer_logos.Add(self.bitmap_button_dls, 0,  
    337                         wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    338                  
     313        sizer_logos.Add(self.bitmap_button_ornl, 0, 
     314                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     315        sizer_logos.Add(self.bitmap_button_isis, 0, 
     316                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     317        sizer_logos.Add(self.bitmap_button_ess, 0, 
     318                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     319        sizer_logos.Add(self.bitmap_button_ill, 0, 
     320                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     321        sizer_logos.Add(self.bitmap_button_ansto, 0, 
     322                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     323        sizer_logos.Add(self.bitmap_button_tudelft, 0, 
     324                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     325        sizer_logos.Add(self.bitmap_button_dls, 0, 
     326                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     327 
    339328        sizer_logos.Add((10, 50), 0, wx.ADJUST_MINSIZE, 0) 
    340329        sizer_main.Add(sizer_logos, 0, wx.EXPAND, 0) 
    341330        sizer_main.Add(self.static_line_3, 0, wx.EXPAND, 0) 
    342331        sizer_button.Add((20, 40), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    343         sizer_button.Add(self.button_OK, 0,  
     332        sizer_button.Add(self.button_OK, 0, 
    344333                         wx.RIGHT|wx.ADJUST_MINSIZE|wx.CENTER, 10) 
    345334        sizer_main.Add(sizer_button, 0, wx.EXPAND, 0) 
    … …  
    350339        # end wxGlade 
    351340 
    352     def onNistLogo(self, event):  
     341    def onNistLogo(self, event): 
    353342        """ 
    354343        """ 
    … …  
    356345        launchBrowser(config._nist_url) 
    357346        event.Skip() 
    358          
    359     def onUmdLogo(self, event):  
     347 
     348    def onUmdLogo(self, event): 
    360349        """ 
    361350        """ 
    … …  
    363352        launchBrowser(config._umd_url) 
    364353        event.Skip() 
    365          
    366     def onOrnlLogo(self, event):  
     354 
     355    def onOrnlLogo(self, event): 
    367356        """ 
    368357        """ 
    … …  
    370359        launchBrowser(config._ornl_url) 
    371360        event.Skip() 
    372          
    373     def onSnsLogo(self, event):  
     361 
     362    def onSnsLogo(self, event): 
    374363        """ 
    375364        """ 
    … …  
    377366        launchBrowser(config._sns_url) 
    378367        event.Skip() 
    379                  
    380     def onNsfLogo(self, event):  
     368 
     369    def onNsfLogo(self, event): 
    381370        """ 
    382371        """ 
    … …  
    394383    def onUTLogo(self, event): 
    395384        """ 
    396         """  
     385        """ 
    397386        # wxGlade: DialogAbout.<event_handler> 
    398387        launchBrowser(config._inst_url) 
    399388        event.Skip() 
    400389 
    401     def onIsisLogo(self, event):  
     390    def onIsisLogo(self, event): 
    402391        """ 
    403392        """ 
    … …  
    415404    def onIllLogo(self, event): 
    416405        """ 
    417         """  
     406        """ 
    418407        # wxGlade: DialogAbout.<event_handler> 
    419408        launchBrowser(config._ill_url) 
    … …  
    422411    def onAnstoLogo(self, event): 
    423412        """ 
    424         """  
     413        """ 
    425414        # wxGlade: DialogAbout.<event_handler> 
    426415        launchBrowser(config._ansto_url) 
    … …  
    429418    def onTudelftLogo(self, event): 
    430419        """ 
    431         """  
     420        """ 
    432421        # wxGlade: DialogAbout.<event_handler> 
    433422        launchBrowser(config._tudelft_url) 
    … …  
    436425    def onDlsLogo(self, event): 
    437426        """ 
    438         """  
     427        """ 
    439428        # wxGlade: DialogAbout.<event_handler> 
    440429        launchBrowser(config._dls_url) 
    … …  
    462451    app = MyApp(0) 
    463452    app.MainLoop() 
    464      
    465 ##### end of testing code #####################################################     
     453 
     454##### end of testing code ##################################################### 

  • src/sas/sasgui/guiframe/acknowledgebox.py

    r74c8cd0 r914ba0a  
    1212import wx.lib.hyperlink 
    1313from wx.lib.expando import ExpandoTextCtrl 
    14 import random 
    15 import os.path 
    16 import os 
    17 try: 
    18     # Try to find a local config 
    19     import imp 
    20     path = os.getcwd() 
    21     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    22       (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    23         fObj, path, descr = imp.find_module('local_config', [path]) 
    24         config = imp.load_module('local_config', fObj, path, descr) 
    25     else: 
    26         # Try simply importing local_config 
    27         import local_config as config 
    28 except: 
    29     # Didn't find local config, load the default 
    30     import config 
    3114 
     15from sas.sasgui import get_local_config 
     16config = get_local_config() 
    3217 
    3318class DialogAcknowledge(wx.Dialog): 

  • src/sas/sasgui/guiframe/config.py

    ra1b8fee rc6bdb3b  
    11""" 
    2     Application settings 
     2Application settings 
    33""" 
    44from __future__ import print_function 
    … …  
    66import time 
    77import os 
     8import logging 
     9 
    810from sas.sasgui.guiframe.gui_style import GUIFRAME 
    911import sas.sasview 
    10 import logging 
    11  
    1212 
    1313logger = logging.getLogger(__name__) 
    … …  
    7575_ansto_logo = os.path.join(icon_path, "ansto_logo.png") 
    7676_tudelft_logo = os.path.join(icon_path, "tudelft_logo.png") 
     77_dls_logo = os.path.join(icon_path, "dls_logo.png") 
    7778_nsf_logo = os.path.join(icon_path, "nsf_logo.png") 
    7879_danse_logo = os.path.join(icon_path, "danse_logo.png") 
    … …  
    147148SAS_OPENCL = None 
    148149 
     150# Time out for updating sasview 
     151UPDATE_TIMEOUT = 2 
     152 
    149153def printEVT(message): 
    150154    if __EVT_DEBUG__: 

  • src/sas/sasgui/guiframe/customdir.py

    r959eb01 rc6bdb3b  
    11# Setup and find Custom config dir 
     2from __future__ import print_function 
     3 
    24import os.path 
     5import logging 
    36import shutil 
    47 
    5 CONF_DIR = 'config'  
    6 APPLICATION_NAME = 'sasview' 
     8from sasmodels.custom import load_module_from_path 
    79 
    8 def _find_usersasview_dir(): 
    9     """ 
    10     Find and return user/.sasview dir 
    11     """ 
    12     return os.path.join(os.path.expanduser("~"), ("." + APPLICATION_NAME)) 
     10from sas.sasgui import get_custom_config_path, get_app_dir 
    1311 
    14 def _find_customconf_dir(): 
    15     """ 
    16     Find path of the config directory. 
    17     The plugin directory is located in the user's home directory. 
    18     """ 
    19     u_dir = _find_usersasview_dir() 
    20     return os.path.join(u_dir, CONF_DIR) 
     12logger = logging.getLogger(__name__) 
    2113 
    22 def _setup_conf_dir(path): 
     14_config_cache = None 
     15def setup_custom_config(): 
    2316    """ 
    2417    Setup the custom config dir and cat file 
    2518    """ 
    26     conf_dir = _find_customconf_dir() 
    27     # If the plugin directory doesn't exist, create it 
    28     if not os.path.isdir(conf_dir): 
    29         os.makedirs(conf_dir) 
    30     config_file = os.path.join(conf_dir, "custom_config.py") 
    31  
    32     # Place example user models as needed 
    33     try: 
    34         if not os.path.isfile(config_file): 
    35             shutil.copyfile(os.path.join(path, "custom_config.py"), config_file) 
    36  
    37         #Adding SAS_OPENCL if it doesn't exist in the config file 
    38         # - to support backcompability 
    39         if not "SAS_OPENCL" in open(config_file).read(): 
    40             open(config_file,"a+").write("SAS_OPENCL = \"None\"\n") 
    41     except: 
    42         # Check for data path next to exe/zip file. 
    43         #Look for maximum n_dir up of the current dir to find plugins dir 
    44         n_dir = 12 
    45         is_dir = False 
    46         f_dir = path 
    47         for i in range(n_dir): 
    48             if i > 1: 
    49                 f_dir, _ = os.path.split(f_dir) 
    50             temp_path = os.path.join(f_dir, "custom_config.py") 
    51             if os.path.isfile(temp_path): 
    52                 shutil.copyfile(temp_path, config_file) 
    53                 is_dir = True 
    54                 break 
    55         if not is_dir: 
    56             raise 
    57     return conf_dir 
     19    global _config_cache 
     20    if not _config_cache: 
     21        _config_cache = _setup_custom_config() 
     22    return _config_cache 
    5823 
    5924 
    60 class SetupCustom(object): 
    61     """ 
    62     implement custom config dir 
    63     """ 
    64     def find_dir(self): 
    65         return _find_customconf_dir() 
    66      
    67     def setup_dir(self, path): 
    68         return _setup_conf_dir(path) 
     25def _setup_custom_config(): 
     26    path = get_custom_config_path() 
     27    if not os.path.isfile(path): 
     28        try: 
     29            # if the custom config file does not exist, copy the default from 
     30            # the app dir 
     31            shutil.copyfile(os.path.join(get_app_dir(), "custom_config.py"), 
     32                            path) 
     33        except Exception: 
     34            logger.error("Could not copy default custom config.") 
     35 
     36    #Adding SAS_OPENCL if it doesn't exist in the config file 
     37    # - to support backcompability 
     38    if not "SAS_OPENCL" in open(path).read(): 
     39        try: 
     40            open(config_file, "a+").write("SAS_OPENCL = \"None\"\n") 
     41        except Exception: 
     42            logger.error("Could not update custom config with SAS_OPENCL.") 
     43 
     44    custom_config = _load_config(path) 
     45    return custom_config 
     46 
     47 
     48def _load_config(path): 
     49    if os.path.exists(path): 
     50        try: 
     51            module = load_module_from_path('sas.sasview.custom_config', path) 
     52            logger.info("GuiManager loaded %s", path) 
     53            return module 
     54        except Exception as exc: 
     55            logger.error("Error loading %s: %s", path, exc) 
     56 
     57    from sas.sasview import custom_config 
     58    logger.info("GuiManager custom_config defaults to sas.sasview.custom_config") 
     59    return custom_config 

  • src/sas/sasgui/guiframe/data_panel.py

    ra1b8fee rc6bdb3b  
    3333from sas.sasgui.guiframe.local_perspectives.plotting.SimplePlot \ 
    3434    import PlotFrame as QucikPlotDialog 
    35 import sas.sasgui.guiframe.config as config 
     35from sas.sasgui import get_local_config 
     36 
     37config = get_local_config() 
    3638 
    3739# Check version 

  • src/sas/sasgui/guiframe/documentation_window.py

    r959eb01 rd66dbcc  
    1616import os 
    1717import logging 
    18 import wx 
    1918import webbrowser 
    2019import urllib 
    2120import sys 
    2221 
     22import wx 
     23try: 
     24    import wx.html2 as html 
     25    WX_SUPPORTS_HTML2 = True 
     26except: 
     27    WX_SUPPORTS_HTML2 = False 
     28 
     29from sas.sasgui import get_app_dir 
     30 
    2331logger = logging.getLogger(__name__) 
    2432 
    2533SPHINX_DOC_ENV = "SASVIEW_DOC_PATH" 
    26 WX_SUPPORTS_HTML2 = True 
    27 try: 
    28     import wx.html2 as html 
    29 except: 
    30     WX_SUPPORTS_HTML2 = False 
    31  
    32  
    33 from gui_manager import get_app_dir 
    34  
    3534 
    3635class DocumentationWindow(wx.Frame): 

  • src/sas/sasgui/guiframe/gui_manager.py

    r2f22db9 r914ba0a  
    2222import re 
    2323import logging 
    24 import httplib 
    2524import traceback 
    2625import urllib 
    27 import urllib2 
    2826import json 
    2927 
     28from matplotlib import _pylab_helpers 
     29 
     30from sas.sasgui import get_local_config, get_app_dir, get_user_dir 
    3031from sas.sasgui.guiframe.events import EVT_CATEGORY 
    3132from sas.sasgui.guiframe.events import EVT_STATUS 
    … …  
    4647from sas.sascalc.dataloader.loader import Loader 
    4748from sas.sasgui.guiframe.proxy import Connection 
    48 from matplotlib import _pylab_helpers 
     49from sas.sasgui.guiframe.customdir import setup_custom_config 
    4950 
    5051logger = logging.getLogger(__name__) 
    51  
    5252warnings.simplefilter("ignore") 
    5353 
    54 def get_app_dir(): 
    55     """ 
    56         The application directory is the one where the default custom_config.py 
    57         file resides. 
    58  
    59         :returns: app_path - the path to the applicatin directory 
    60     """ 
    61     # First, try the directory of the executable we are running 
    62     app_path = sys.path[0] 
    63     if os.path.isfile(app_path): 
    64         app_path = os.path.dirname(app_path) 
    65     if os.path.isfile(os.path.join(app_path, "custom_config.py")): 
    66         app_path = os.path.abspath(app_path) 
    67         logger.info("Using application path: %s", app_path) 
    68         return app_path 
    69  
    70     # Next, try the current working directory 
    71     if os.path.isfile(os.path.join(os.getcwd(), "custom_config.py")): 
    72         logger.info("Using application path: %s", os.getcwd()) 
    73         return os.path.abspath(os.getcwd()) 
    74  
    75     # Finally, try the directory of the sasview module 
    76     # TODO: gui_manager will have to know about sasview until we 
    77     # clean all these module variables and put them into a config class 
    78     # that can be passed by sasview.py. 
    79     logger.debug(sys.executable) 
    80     logger.debug(str(sys.argv)) 
    81     from sas import sasview as sasview 
    82     app_path = os.path.dirname(sasview.__file__) 
    83     logger.debug("Using application path: %s", app_path) 
    84     return app_path 
    85  
    86  
    87 def get_user_directory(): 
    88     """ 
    89         Returns the user's home directory 
    90     """ 
    91     userdir = os.path.join(os.path.expanduser("~"), ".sasview") 
    92     if not os.path.isdir(userdir): 
    93         os.makedirs(userdir) 
    94     return userdir 
    95  
    96  
    97 def _find_local_config(file, path): 
    98     """ 
    99         Find configuration file for the current application 
    100     """ 
    101     config_module = None 
    102     fObj = None 
    103     try: 
    104         fObj, path_config, descr = imp.find_module(file, [path]) 
    105         config_module = imp.load_module(file, fObj, path_config, descr) 
    106     except: 
    107         logger.error("Error loading %s/%s: %s" % (path, file, sys.exc_value)) 
    108     finally: 
    109         if fObj is not None: 
    110             fObj.close() 
    111     logger.debug("GuiManager loaded %s/%s" % (path, file)) 
    112     return config_module 
    113  
    114 # Get APP folder 
    115 PATH_APP = get_app_dir() 
    116 DATAPATH = PATH_APP 
    117  
    118 # GUI always starts from the App folder 
    119 # os.chdir(PATH_APP) 
    120 # Read in the local config, which can either be with the main 
    121 # application or in the installation directory 
    122 config = _find_local_config('local_config', PATH_APP) 
    123 if config is None: 
    124     config = _find_local_config('local_config', os.getcwd()) 
    125     if config is None: 
    126         # Didn't find local config, load the default 
    127         import sas.sasgui.guiframe.config as config 
    128         logger.debug("using default local_config") 
    129     else: 
    130         logger.debug("found local_config in %s" % os.getcwd()) 
    131 else: 
    132     logger.debug("found local_config in %s" % PATH_APP) 
    133  
    134 from sas.sasgui.guiframe.customdir import SetupCustom 
    135 c_conf_dir = SetupCustom().setup_dir(PATH_APP) 
    136 custom_config = _find_local_config('custom_config', c_conf_dir) 
    137 if custom_config is None: 
    138     custom_config = _find_local_config('custom_config', os.getcwd()) 
    139     if custom_config is None: 
    140         msgConfig = "Custom_config file was not imported" 
    141         logger.debug(msgConfig) 
    142     else: 
    143         logger.debug("using custom_config in %s" % os.getcwd()) 
    144 else: 
    145     logger.debug("using custom_config from %s" % c_conf_dir) 
     54config = get_local_config() 
     55custom_config = setup_custom_config() 
    14656 
    14757# read some constants from config 
    … …  
    17787        DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder) 
    17888    else: 
    179         DEFAULT_OPEN_FOLDER = PATH_APP 
     89        DEFAULT_OPEN_FOLDER = get_app_dir() 
    18090    SAS_OPENCL = custom_config.SAS_OPENCL 
    18191except: 
    … …  
    192102    DEFAULT_PERSPECTIVE = None 
    193103    CLEANUP_PLOT = False 
     104    DEFAULT_OPEN_FOLDER = get_app_dir() 
    194105    DEFAULT_OPEN_FOLDER = PATH_APP 
    195106    SAS_OPENCL = None 
    … …  
    265176                if os.path.isfile(ico_file): 
    266177                    self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO)) 
    267         self.path = PATH_APP 
     178        self.path = get_app_dir() 
    268179        self.application_name = APPLICATION_NAME 
    269180        # Application manager 
    … …  
    540451        try: 
    541452            fd = open(file_name, 'w') 
    542         except: 
     453        except Exception: 
    543454            # On Permission denied: IOError 
    544             temp_dir = get_user_directory() 
     455            temp_dir = get_user_dir() 
    545456            temp_file_name = os.path.join(temp_dir, name) 
    546457            fd = open(temp_file_name, 'w') 
    … …  
    15321443            # want Analysis.  This is NOT an issue on the Mac which does not 
    15331444            # have the extra Window menu item. 
    1534             #      March 2016 Code Camp  -- PDB  
     1445            #      March 2016 Code Camp  -- PDB 
    15351446            Tools_pos = self._menubar.FindMenu("Tools") 
    15361447            self._menubar.Insert(Tools_pos+1, self._applications_menu, 
    … …  
    21632074                logger.info("Failed to connect to www.sasview.org") 
    21642075        self._process_version(version_info, standalone=event is None) 
     2076 
    21652077 
    21662078    def _process_version(self, version_info, standalone=True): 
    … …  
    33513263                if basename.lower() in [app_py, app_exe, app_app, app_base]: 
    33523264                    data_base = sys.argv[1] 
    3353                     input_file = os.path.normpath(os.path.join(DATAPATH, 
     3265                    input_file = os.path.normpath(os.path.join(get_app_dir(), 
    33543266                                                               data_base)) 
    33553267        if input_file is None: 
    … …  
    33663278        # do it only the first time app loaded 
    33673279        # delete unused model folder 
    3368         model_folder = os.path.join(PATH_APP, path) 
     3280        model_folder = os.path.join(get_app_dir(), path) 
    33693281        if os.path.exists(model_folder) and os.path.isdir(model_folder): 
    33703282            if len(os.listdir(model_folder)) > 0: 

  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r235f514 r914ba0a  
    1111 
    1212from sas.sascalc.dataloader.loader import Loader 
     13 
     14from sas.sasgui import get_local_config 
    1315from sas.sasgui.guiframe.plugin_base import PluginBase 
    1416from sas.sasgui.guiframe.events import StatusEvent 
    1517from sas.sasgui.guiframe.gui_style import GUIFRAME 
    1618from sas.sasgui.guiframe.gui_manager import DEFAULT_OPEN_FOLDER 
    17 try: 
    18     # Try to find a local config 
    19     import imp 
    20     path = os.getcwd() 
    21     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    22         (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    23         fObj, path, descr = imp.find_module('local_config', [path]) 
    24         config = imp.load_module('local_config', fObj, path, descr) 
    25     else: 
    26         # Try simply importing local_config 
    27         import local_config as config 
    28 except: 
    29     # Didn't find local config, load the default 
    30     import sas.sasgui.guiframe.config as config 
    31  
    32 if config is None: 
    33     import sas.sasgui.guiframe.config as config 
    34  
    35  
     19 
     20config = get_local_config() 
    3621extension_list = [] 
    3722if config.APPLICATION_STATE_EXTENSION is not None: 

  • src/sas/sasgui/guiframe/startup_configuration.py

    r7432acb r914ba0a  
    1  
    21################################################################################ 
    32#This software was developed by the University of Tennessee as part of the 
    43#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    5 #project funded by the US National Science Foundation.  
     4#project funded by the US National Science Foundation. 
    65# 
    76#See the license text in license.txt 
    … …  
    98#copyright 2009, University of Tennessee 
    109################################################################################ 
     10import os 
     11import copy 
     12 
    1113import wx 
    12 import os 
    13 import sys 
    14 import copy 
    15 #import sas.sasgui.guiframe.gui_manager as gui 
    16 from sas.sasgui.guiframe.events import StatusEvent   
     14 
     15from sas.sasgui import get_custom_config_path 
     16from sas.sasgui.guiframe.events import StatusEvent 
    1717from sas.sasgui.guiframe.gui_style import GUIFRAME 
    1818from sas.sasgui.guiframe import gui_manager as CURRENT 
    19 from sas.sasgui.guiframe.customdir  import SetupCustom 
     19 
     20 
    2021# default configuration 
    2122DEFAULT_STRINGS = {'GUIFRAME_WIDTH':-1, 
    … …  
    6263    """ 
    6364    def __init__(self, parent, gui, id=-1, title="Startup Setting"): 
    64         wx.Dialog.__init__(self, parent, id, title,  
     65        wx.Dialog.__init__(self, parent, id, title, 
    6566                           size=(PANEL_WIDTH, PANEL_HEIGHT)) 
    6667        # parent 
    6768        self.parent = parent 
    68         self.path = SetupCustom().find_dir() 
    6969        self._gui = gui 
    70         # font size  
     70        # font size 
    7171        self.SetWindowVariant(variant=FONT_VARIANT) 
    7272        self.current_string = copy.deepcopy(CURRENT_STRINGS) 
    … …  
    7676        title_text = wx.StaticText(self, id=wx.NewId(), label='Set interface configuration') 
    7777 
    78         default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30),  
     78        default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30), 
    7979                                    style=wx.RB_GROUP) 
    8080        default_bt.Bind(wx.EVT_RADIOBUTTON, self.OnDefault) 
    … …  
    8787        note_txt = wx.StaticText(self, -1, msg, (15, 75)) 
    8888        note_txt.SetForegroundColour("black") 
    89          
     89 
    9090        hbox = wx.BoxSizer(wx.HORIZONTAL) 
    9191        okButton = wx.Button(self, wx.ID_OK, 'Set', size=(70, 25)) 
    92         closeButton = wx.Button(self,wx.ID_CANCEL, 'Cancel', size=(70, 25)) 
     92        closeButton = wx.Button(self, wx.ID_CANCEL, 'Cancel', size=(70, 25)) 
    9393        hbox.Add(closeButton, 1, wx.RIGHT, 5) 
    9494        hbox.Add(okButton, 1, wx.RIGHT, 5) 
    … …  
    102102        self.SetSizer(vbox) 
    103103 
    104          
     104 
    105105    def OnDefault(self, event=None): 
    106106        """ 
    … …  
    111111        self.return_string = copy.deepcopy(DEFAULT_STRINGS) 
    112112        return self.return_string 
    113          
     113 
    114114    def OnCurrent(self, event=None): 
    115115        """ 
    … …  
    134134                p_size = CURRENT_STRINGS['PLOPANEL_WIDTH'] 
    135135            self.current_string['PLOPANEL_WIDTH'] = p_size 
    136              
     136 
    137137            try: 
    138138                control_frame = self.parent.get_current_perspective().frame 
    … …  
    143143                self.current_string['CONTROL_WIDTH'] = -1 
    144144                self.current_string['CONTROL_HEIGHT'] = -1 
    145                  
     145 
    146146            data_pw, _ = self.parent.panels["data_panel"].frame.GetSizeTuple() 
    147147            if data_pw is None: 
    148148                data_pw = CURRENT_STRINGS['DATAPANEL_WIDTH'] 
    149149            self.current_string['DATAPANEL_WIDTH'] = data_pw 
    150              
     150 
    151151            #label = self.parent._data_panel_menu.GetText() 
    152152            label = self.parent.panels['data_panel'].frame.IsShown() 
    … …  
    155155            else: 
    156156                self.current_string['DATALOADER_SHOW'] = False 
    157                  
     157 
    158158            if self.parent._toolbar.IsShown(): 
    159159                self.current_string['TOOLBAR_SHOW'] = True 
    160160            else: 
    161161                self.current_string['TOOLBAR_SHOW'] = False 
    162                  
     162 
    163163            style = self._gui & GUIFRAME.FLOATING_PANEL 
    164             if style == GUIFRAME.FLOATING_PANEL:  
     164            if style == GUIFRAME.FLOATING_PANEL: 
    165165                self.current_string['FIXED_PANEL'] = False 
    166166            else: 
    167167                self.current_string['FIXED_PANEL'] = True 
    168                  
     168 
    169169            if self.parent.panels['default'].frame.IsShown(): 
    170170                self.current_string['WELCOME_PANEL_SHOW'] = True 
    … …  
    182182            self.current_string['DEFAULT_OPEN_FOLDER'] = location 
    183183                        #self.parent._default_save_location.ascii_letters 
    184              
     184 
    185185        except: 
    186186            raise 
    … …  
    188188        self.return_string = self.current_string 
    189189        return self.return_string 
    190      
     190 
     191 
    191192    def write_custom_config(self): 
    192193        """ 
    193             Write custom configuration 
    194         """ 
    195         fname = os.path.join(self.path, 'custom_config.py') 
    196         self.write_string(fname, self.return_string) 
    197  
    198     def write_string(self, fname, strings): 
    199         """ 
    200         Write and Save file 
    201         """ 
    202          
    203         try: 
    204             out_f =  open(fname,'w') 
    205         except : 
    206             raise  #RuntimeError, "Error: Can not change the configuration..." 
    207         out_f.write("#Application appearance custom configuration\n" ) 
    208         for key, item in strings.iteritems(): 
    209             if (key == 'DEFAULT_PERSPECTIVE') or \ 
    210                 (key == 'DEFAULT_OPEN_FOLDER' and item is not None): 
    211                 out_f.write("%s = \"%s\"\n" % (key,str(item))) 
    212             else: 
    213                 out_f.write("%s = %s\n" % (key,str(item))) 
    214      
    215         out_f.close()  
    216          
     194        Write custom configuration 
     195        """ 
     196        path = get_custom_config_path() 
     197        with open(path, 'w') as out_f: 
     198            out_f.write("#Application appearance custom configuration\n") 
     199            for key, item in self.return_string.iteritems(): 
     200                if (key == 'DEFAULT_PERSPECTIVE') or \ 
     201                    (key == 'DEFAULT_OPEN_FOLDER' and item != None): 
     202                    out_f.write("%s = \"%s\"\n" % (key, str(item))) 
     203                else: 
     204                    out_f.write("%s = %s\n" % (key, str(item))) 
Note: See TracChangeset for help on using the changeset viewer.