source: branches/GUIdev/DuchampParameterGUI_mainInterfaceClass.py @ 1332

Last change on this file since 1332 was 1332, checked in by KelvinHsu, 11 years ago

DuchampParameterGUI.py split into four files (it could be made more modular but so far it is simply just code split into four files, without really using the advantage of multi-file programs...)
File size: 29.4 KB
Line 
1#-------------------------------------------------------------------------------
2# Name:        DuchampParameterGUI_mainInterfaceClass
3# Purpose:
4#
5# Author:      Kelvin
6#
7# Created:     4/12/2013
8#-------------------------------------------------------------------------------
9
10# Python 2 packages
11try:
12    from Tkinter import *
13    import tkFileDialog
14
15# Python 3 packages
16except ImportError:
17    from tkinter import *
18    import tkinter.filedialog as tkFileDialog
19
20from DuchampParameterGUI_fileIO import *
21from DuchampParameterGUI_listPrinting import *
22
23# GUI - Tkinter section
24
25class mainInterface:
26
27    def __init__(self, master):
28       
29        # --------------------------------------------------
30        # Initialise the GUI window.
31        self.frame = Frame(master)
32        self.frame.grid()
33        # --------------------------------------------------
34
35
36        # --------------------------------------------------
37        # Menu
38        self.menubar = Menu(master)
39
40        # File Menu
41        self.filemenu = Menu(self.menubar, tearoff = 0)
42        self.filemenu.add_command(label = "Open", command = self.createInputInterface)
43        self.filemenu.add_command(label = "Save specification", command = self.createSpecifiedOutputInterface)
44        self.filemenu.add_command(label = "Save all specification", command = self.createEffectiveOutputInterface)
45        self.filemenu.add_separator()
46        self.filemenu.add_command(label = "Exit", command = self.frame.quit)
47        self.menubar.add_cascade(label = "File", menu = self.filemenu)
48
49
50        # Options Menu
51        self.editmenu = Menu(self.menubar, tearoff = 0)
52        self.editmenu.add_command(label = "Cut", command = self.notImplementedYet)
53        self.editmenu.add_command(label = "Copy", command = self.notImplementedYet)
54        self.editmenu.add_command(label = "Paste", command = self.notImplementedYet)
55        self.menubar.add_cascade(label = "Options", menu = self.editmenu)
56
57        # Help Menu
58        self.helpmenu = Menu(self.menubar, tearoff = 0)
59        self.helpmenu.add_command(label = "About", command = self.notImplementedYet)
60        self.menubar.add_cascade(label = "Help", menu = self.helpmenu)
61        # --------------------------------------------------
62   
63       
64        # Row 1-10 reserved for future extensions
65       
66       
67        # --------------------------------------------------
68        # Parameter name and value entry
69        self.parameterLabel = Label(self.frame, text = "Parameter: ", foreground = "Blue")
70        self.parameterLabel.grid(row = 11, column = 1, columnspan = 2)
71
72        self.valueLabel = Label(self.frame, text = "Value: ", foreground = "Forest Green")
73        self.valueLabel.grid(row = 11, column = 3, columnspan = 2)
74
75        self.parameterEntry = Entry(self.frame, width = 25)
76        self.parameterEntry.bind("<Return>", self.checkParameterEvent)
77        self.parameterEntry.grid(row = 12, column = 1, padx = 10, columnspan = 2)
78
79        self.valueEntry = Entry(self.frame, width = 25)
80        self.valueEntry.bind("<Return>", self.updateParameterEvent)
81        self.valueEntry.grid(row = 12, column = 3, padx = 10, columnspan = 2)
82        # --------------------------------------------------
83
84
85        # --------------------------------------------------
86        # Check, update, and describe parameter buttons
87        self.checkButton = Button(self.frame, text = "Check", command = self.checkParameterWithDescription)
88        self.checkButton.grid(row = 13, column = 1, padx = 10, pady = 10)
89       
90        self.updateButton = Button(self.frame, text = "Update", command = self.updateParameter)
91        self.updateButton.grid(row = 13, column = 2, padx = 10, pady = 10)
92
93        self.revertDefaultButton = Button(self.frame, text = "Revert to default", command = self.revertDefault)
94        self.revertDefaultButton.grid(row = 13, column = 4, padx = 10, pady = 10, columnspan = 2)
95        # --------------------------------------------------
96
97
98        # Row 14-15 reserved for displaying the information queried from above
99
100
101        # --------------------------------------------------
102        # List parameter files buttons (default and specified)
103        self.listDefault = Button(self.frame, text = "List Default Parameters", command = lambda: self.listParameters("Default"))
104        self.listDefault.grid(row = 16, column = 1, padx = 10, pady = 10, columnspan = 2)
105
106        self.listSpecified = Button(self.frame, text = "List User Specified Parameters", command = lambda: self.listParameters("Specified"))
107        self.listSpecified.grid(row = 17, column = 1, padx = 10, pady = 10, columnspan = 2)
108
109        self.listEffective = Button(self.frame, text = "List Effective Parameters", command = lambda: self.listParameters("Effective"))
110        self.listEffective.grid(row = 18, column = 1, padx = 10, pady = 10, columnspan = 2)
111        # --------------------------------------------------
112
113
114        # --------------------------------------------------
115        # Radio Buttons
116
117        # Obtain (parameter: class) dictionary, and a list of the names of classes in order
118        (self.classOfParameter, self.classNames, self.description, self.paramType, self.paramFormat) = readParamByClass(defaultParamFilePath)
119
120        # Initialise the variable containing the name of the class to be displayed
121        self.whichClass = StringVar()
122
123        # Index the buttons
124        i = 0
125
126
127        # Create each radio button in order
128        for name in self.classNames:
129           
130            b = Radiobutton(self.frame, text = name, variable = self.whichClass, value = name, indicatoron = 0, command = lambda: self.listParameters("Class"), width = 30)
131
132            # Place them at appropriate positions
133            r = 19 + int(i/2)
134
135            if (i % 2) == 0:
136                c = 1
137            else:
138                c = 3
139
140            # Make them stick to the left
141            b.grid(row = r, column = c, columnspan = 2)
142            i = i + 1
143        # --------------------------------------------------
144
145
146        # --------------------------------------------------
147        # Variable definitions throughout the window
148       
149        # Firstly, determine the default list of parameters
150        (self.defaultParameters, self.orderedParameters) = readParamFile(defaultParamFilePath)
151
152        # Then, determine the user specified list of parameters
153        self.userSpecifiedParameters = {}
154        self.orderedSpecifiedParameters = []
155
156        # This is the effective parameters
157        self.effectiveParameters = dict(self.defaultParameters)
158
159        # Define the string variables in the parameter name and value entry section
160        self.resultTitle = StringVar()
161        self.result = StringVar()
162        self.notesTitle = StringVar()
163        self.notes = StringVar()
164        self.color = StringVar()
165
166        # Define the string variables for entering file directories, names, and paths   
167        self.userSpecifiedFileDirectory = StringVar()
168        self.userSpecifiedFileName = StringVar()
169        self.userSpecifiedFilePath = StringVar()
170        # --------------------------------------------------
171
172
173        # Give a default name for the user specified file name
174        self.userSpecifiedFileName = 'duchampHIPASS.txt'
175
176        self.frame.bind("<Enter>", self.precaution)
177
178
179       
180    # Define a notice box (one button only)
181    def createNoticeBox1(self, title, message, command, buttonText = "Dismiss"):
182       
183        self.noticeBox = Toplevel(width = 200, borderwidth = 20)
184        self.noticeBox.title(title)
185       
186        self.noticeMsg = Message(self.noticeBox, text = message)
187        self.noticeMsg.grid(row = 1, column = 1, columnspan = 2)
188       
189        self.noticeBoxButton = Button(self.noticeBox, text = buttonText, command = command)
190        self.noticeBoxButton.grid(row = 2, column = 1, pady = 5, columnspan = 2)
191       
192
193    # Define a notice box (two buttons)
194    def createNoticeBox2(self, title, message, command1, command2, buttonText1 = "Yes", buttonText2 = "No"):
195
196        self.noticeBox = Toplevel(width = 200, borderwidth = 20)
197        self.noticeBox.title(title)
198       
199        self.noticeMsg = Message(self.noticeBox, text = message)
200        self.noticeMsg.grid(row = 1, column = 1, columnspan = 2)
201       
202        self.noticeBoxButton1 = Button(self.noticeBox, text = buttonText1, command = command1)
203        self.noticeBoxButton1.grid(row = 2, column = 1, pady = 5)
204       
205        self.noticeBoxButton2 = Button(self.noticeBox, text = buttonText2, command = command2)
206        self.noticeBoxButton2.grid(row = 2, column = 2, pady = 5)
207
208    # This destroys notice box
209    def dismissNotice(self):
210
211        self.noticeBox.destroy()
212       
213       
214    # This checks if file is missing or corrupted or now
215    def precaution(self, event):
216
217        d = [len(self.defaultParameters), len(self.description), len(self.paramType), len(self.paramFormat)]
218        s = ["Default Parameter", "Description", "Type", "Format"]
219       
220        # Firstly, if the default parameter file was not loaded, notify the user
221        if min(d) == 0:
222
223            which = s[d.index(min(d))]
224
225            self.createNoticeBox1(title = "Notice", message = "Input data file missing or corrupted. " + which + " data missing. Close the window and restart.", command = self.frame.quit, buttonText = "Okay")
226            self.frame.bind("<Button-1>", self.quitNow)
227            self.frame.bind("<Button-3>", self.quitNow)
228
229        # Also, check if all of the loaded dictionaries have the same number of elements
230        if max(d) != min(d):
231
232            if d.count(min(d)) == 3:
233                print(1)
234                which = s[d.index(max(d))]
235            elif d.count(max(d)) == 3:
236                print(2)
237                which = s[d.index(min(d))]
238            else:
239                which = "Multiple"
240
241            self.createNoticeBox1(title = "Notice", message = "Input data file corrupted. " + which + " data corrupted. Close the window and restart.", command = self.frame.quit, buttonText = "Okay")
242            self.frame.bind("<Button-1>", self.quitNow)
243            self.frame.bind("<Button-3>", self.quitNow)
244           
245
246    # This quits the frame by events
247    def quitNow(self, event):
248
249        self.frame.quit()
250       
251
252    # A notice for functions being not implemented yet
253    def notImplementedYet(self):
254
255        self.createNoticeBox1(title = "Be Patient!", message = "Wait! This button is still under developement!", command = self.dismissNotice, buttonText = "Alright!")
256       
257
258    # Some commands want both checking and describing parameters to be done
259    def checkParameterWithDescription(self):
260       
261        self.checkParameter()
262        self.showDescription()
263
264
265    # Allow checking and describing parameters to be driven by events
266    def checkParameterEvent(self, event):
267
268        self.checkParameterWithDescription()
269
270
271    # Allow updating parameters to be driven by events
272    def updateParameterEvent(self, event):
273
274        self.updateParameter()
275
276       
277    # This checks the value of the parameter entered in the parameter entry box
278    def checkParameter(self):
279
280        # Determine which parameter the user wants to check
281        par = self.parameterEntry.get()
282
283        # Find which list it is in and determine its value
284        # Note that specified list takes priority
285        if par.lower() in lower(self.orderedSpecifiedParameters):
286            index = lower(self.orderedSpecifiedParameters).index(par.lower())
287            parameter2check = self.orderedSpecifiedParameters[index]
288            value = self.userSpecifiedParameters[parameter2check]
289            paramInfo = par + ': ' + value
290            self.color.set("Forest Green")
291            defaultYN = "Specified Value"
292        elif par.lower() in lower(self.orderedParameters):
293            index = lower(self.orderedParameters).index(par.lower())
294            parameter2check = self.orderedParameters[index]
295            value = self.defaultParameters[parameter2check]
296            paramInfo = parameter2check + ': ' + value
297            self.color.set("Forest Green")
298            defaultYN = "Default Value"
299        else:
300            value = "N/A"
301            paramInfo = '"' + par + '" does not exist'
302            self.color.set("Red")
303            defaultYN = "N/A"
304
305
306        # Store the results from the above
307        self.resultTitle.set("Parameter Information")
308        self.result.set(paramInfo)
309        self.notesTitle.set("Default/Specified")
310        self.notes.set(defaultYN)
311
312        self.valueEntry.delete(0, END)
313        self.valueEntry.insert(0, value)
314
315        # --------------------------------------------------
316        # Windows that correspond to the variables above
317        self.resultLabel = Label(self.frame, textvariable = self.resultTitle)
318        self.resultLabel.grid(row = 14, column = 1, pady = 0, columnspan = 2)
319
320        self.resultValue = Label(self.frame, textvariable = self.result, foreground = self.color.get())
321        self.resultValue.grid(row = 15, column = 1, pady = 10, columnspan = 2)
322
323        self.notesLabel = Label(self.frame, textvariable = self.notesTitle)
324        self.notesLabel.grid(row = 14, column = 3, pady = 0, columnspan = 2)
325
326        self.notesValue = Label(self.frame, textvariable = self.notes)
327        self.notesValue.grid(row = 15, column = 3, pady = 10, columnspan = 2)
328        # --------------------------------------------------
329       
330       
331    # This updates the value of the parameter entered in the parameter entry box
332    def updateParameter(self):
333
334        # Determine which parameter the user wants to update
335        par = self.parameterEntry.get()
336
337        # Update the value and determine if the parameter is being changed or added into the list
338        if par.lower() in lower(self.orderedSpecifiedParameters):
339            value2write = self.valueEntry.get()
340            index = lower(self.orderedSpecifiedParameters).index(par.lower())
341            parameter2update = self.orderedSpecifiedParameters[index]
342            self.userSpecifiedParameters[parameter2update] = value2write
343            paramInfo = parameter2update + ': ' + value2write
344            newParamYN = "Updated specified parameter list"
345            self.color.set("Blue")
346        elif par.lower() in lower(self.orderedParameters):
347            index = lower(self.orderedParameters).index(par.lower())
348            parameter2update = self.orderedParameters[index]
349            value2write = self.valueEntry.get()
350            self.userSpecifiedParameters[parameter2update] = value2write
351            paramInfo = parameter2update + ': ' + value2write
352            newParamYN = "Added in specified parameter list"
353            self.color.set("Blue")
354
355            self.orderedSpecifiedParameters = self.orderedSpecifiedParameters + [parameter2update]
356        else:
357            paramInfo = '"' + par + '" does not exist'
358            newParamYN = "-"
359            self.color.set("Red")
360
361        # Store the results from above
362        self.resultTitle.set("Parameter Information")
363        self.result.set(paramInfo)
364        self.notesTitle.set("Notes")
365        self.notes.set(newParamYN)
366
367        # --------------------------------------------------
368        # Windows that correspond to the variables above
369        self.resultLabel = Label(self.frame, textvariable = self.resultTitle)
370        self.resultLabel.grid(row = 14, column = 1, pady = 0, columnspan = 2)
371
372        self.resultValue = Label(self.frame, textvariable = self.result, foreground = self.color.get())
373        self.resultValue.grid(row = 15, column = 1, pady = 10, columnspan = 2)
374
375        self.notesLabel = Label(self.frame, textvariable = self.notesTitle)
376        self.notesLabel.grid(row = 14, column = 3, pady = 0, columnspan = 2)
377
378        self.notesValue = Label(self.frame, textvariable = self.notes)
379        self.notesValue.grid(row = 15, column = 3, pady = 10, columnspan = 2)
380        # --------------------------------------------------
381
382        # Update the effective parameters
383        self.effectiveParameters.update(self.defaultParameters) # In case default wasn't loaded before
384        self.effectiveParameters.update(self.userSpecifiedParameters)
385
386        # List specified parameters
387        self.listParameters("Specified")
388       
389
390    # This displays a description of the parameter entered in the parameter entry box
391    def showDescription(self):
392
393        # Determine which parameter to describe
394        par = self.parameterEntry.get()
395
396        # Determine if the parameter is within the description file
397        if par.lower() in lower(self.orderedParameters):
398            index = lower(self.orderedParameters).index(par.lower())
399            parameter2describe = self.orderedParameters[index]           
400            description = self.description[parameter2describe]
401        else:
402            parameter2describe = par
403            description = "No description available"
404
405        # Create the description
406        self.descriptionList = Listbox(self.frame, width = longestLineLength(self.defaultParameters) + 5, font = ('courier', (10)))
407        self.descriptionList.grid(row = 30, column = 1, columnspan = 4)
408
409        try:
410            self.descriptionList.insert(END, "Description of '" + parameter2describe + "'")
411            self.descriptionList.insert(END, "Class: " + self.classOfParameter[parameter2describe])
412            self.descriptionList.insert(END, "Type: " + self.paramType[parameter2describe])
413            self.descriptionList.insert(END, "Format: " + self.paramFormat[parameter2describe])
414            self.descriptionList.insert(END, " ")
415           
416        except KeyError:
417            self.descriptionList.delete(0, END)
418            self.descriptionList.insert(END, "Please Enter a parameter")
419            return
420       
421
422        descriptionWords = description.split()
423
424        largestWordLength = 0
425
426        for word in descriptionWords:
427            if len(word) > largestWordLength:
428                largestWordLength = len(word)
429        b = 0
430
431        for i in range(len(descriptionWords)):
432                           
433            phrase = ' '.join(descriptionWords[b:i])
434                           
435            if len(phrase) > longestLineLength(self.defaultParameters) - largestWordLength:
436                line = phrase
437
438                self.descriptionList.insert(END, line) 
439                b = i
440
441        self.descriptionList.insert(END, ' '.join(descriptionWords[b:]))
442
443    # This allows the user to revert a parameter to its default value   
444    def revertDefault(self):
445
446        # Determine which parameter the user wants to revert
447        parameter2revert = self.parameterEntry.get()
448
449        finalValue = self.defaultParameters.get(parameter2revert, "N/A")
450        paramInfo = parameter2revert + ': ' + finalValue
451
452        # Revert the value and determine if the parameter was already default
453        if parameter2revert in self.userSpecifiedParameters:
454
455            del(self.userSpecifiedParameters[parameter2revert])
456            self.orderedSpecifiedParameters.remove(parameter2revert)
457            alreadyDefaultYN = "Reverted back to default"
458            self.color.set("Sky Blue")
459        elif parameter2revert in self.defaultParameters:
460
461            alreadyDefaultYN = "Already default"
462            self.color.set("Sky Blue")
463        else:
464            paramInfo = '"' + parameter2revert + '" does not exist'
465            alreadyDefaultYN = "-"
466            self.color.set("Red")
467
468        # Store the results from above
469        self.resultTitle.set("Parameter Information")
470        self.result.set(paramInfo)
471        self.notesTitle.set("Notes")
472        self.notes.set(alreadyDefaultYN)
473
474        self.valueEntry.delete(0, END)
475        self.valueEntry.insert(0, finalValue)
476
477        # --------------------------------------------------
478        # Windows that correspond to the variables above
479        self.resultLabel = Label(self.frame, textvariable = self.resultTitle)
480        self.resultLabel.grid(row = 14, column = 1, pady = 0, columnspan = 2)
481
482        self.resultValue = Label(self.frame, textvariable = self.result, foreground = self.color.get())
483        self.resultValue.grid(row = 15, column = 1, pady = 10, columnspan = 2)
484
485        self.notesLabel = Label(self.frame, textvariable = self.notesTitle)
486        self.notesLabel.grid(row = 14, column = 3, pady = 0, columnspan = 2)
487
488        self.notesValue = Label(self.frame, textvariable = self.notes)
489        self.notesValue.grid(row = 15, column = 3, pady = 10, columnspan = 2)
490        # --------------------------------------------------
491
492        # Update the effective parameters
493        self.effectiveParameters.update(self.defaultParameters) # In case default wasn't loaded before
494        self.effectiveParameters.update(self.userSpecifiedParameters)
495       
496        # List the specified parameter values
497        self.listParameters("Specified")
498
499       
500    # This displays a list of parameters sets (depending on user command)
501    def listParameters(self, parameterSet):
502
503        paramOrder = self.orderedParameters
504       
505        if parameterSet == "Default":
506            self.parameters = self.defaultParameters
507        elif parameterSet == "Specified":
508            self.parameters = self.userSpecifiedParameters
509            paramOrder = self.orderedSpecifiedParameters
510        elif parameterSet == "Effective":
511            self.parameters = self.effectiveParameters
512        elif parameterSet == "Class":
513            self.effectiveParameters.update(self.defaultParameters) # In case default wasn't loaded before
514            self.effectiveParameters.update(self.userSpecifiedParameters)
515            self.parameters = self.effectiveParameters
516            className = self.whichClass.get()
517        else:
518            print("Coding Error: Used wrong parameter set.")
519            return
520
521        # If the list is empty, it means we haven't loaded it yet
522        if self.parameters == {}:
523           
524            self.createNoticeBox1(title = "Notice", message = "No " + parameterSet + " Parameter File Loaded", command = self.dismissNotice, buttonText = "Okay")
525
526        # Otherwise we can print it using the specified format
527        else:
528
529
530            self.paramListScrollBar = Scrollbar(self.frame)
531            self.paramListScrollBar.grid(row = 30, column = 5, ipady = 65)
532           
533            self.parameterList = Listbox(self.frame, yscrollcommand = self.paramListScrollBar.set, width = longestLineLength(self.defaultParameters) + 5, font = ('courier', (10)))
534            self.parameterList.grid(row = 30, column = 1, columnspan = 4)
535
536            if parameterSet == "Class":
537                self.parameterList.insert(END, className)
538            else:
539                self.parameterList.insert(END, parameterSet + " set of Parameters")
540               
541            self.parameterList.insert(END, " ")
542
543            star = 0
544
545            for par in paramOrder:
546
547                if parameterSet == "Effective":
548                    if par in self.userSpecifiedParameters:
549                        star = 1
550                    else:
551                        star = 0
552                       
553                if parameterSet == "Class":
554
555                    if self.classOfParameter[par] == className:
556
557                        if par in self.userSpecifiedParameters:
558                            star = 1
559                        else:
560                            star = 0
561
562                        tabbedPar = tabbedDictionaryLine(self.parameters, par, star)
563                        self.parameterList.insert(END, tabbedPar + self.parameters[par])
564                   
565                else:
566                    tabbedPar = tabbedDictionaryLine(self.parameters, par, star)
567                    self.parameterList.insert(END, tabbedPar + self.parameters[par])
568
569                   
570
571            self.paramListScrollBar.config(command = self.parameterList.yview)
572
573            self.list2read = self.parameterList
574            self.parameterList.bind("<ButtonRelease-1>", self.checkItem)
575            self.parameterList.bind("<ButtonRelease-3>", self.checkItemDescript)
576            self.parameterList.bind("<Return>", self.checkItemDescript)
577
578
579    # When description is not needed
580    def checkItem(self, event):
581
582        self.doCheckItem(0)
583
584
585    # When description is needed
586    def checkItemDescript(self, event):
587
588        self.doCheckItem(1)
589
590    # When buttons are pressed on the lists, the items will be checked or described.
591    def doCheckItem(self, describeFlag):
592
593        try:
594            if int(self.list2read.curselection()[0]) != 0:
595
596                line = self.list2read.get(self.list2read.curselection())
597                linebits = line.split()
598                parameter = linebits[0]
599
600                self.parameterEntry.delete(0, END)
601                self.parameterEntry.insert(0, parameter)
602
603                if describeFlag == 0:
604                    self.checkParameter()
605                elif describeFlag == 1:
606                    self.checkParameterWithDescription()
607                else:
608                    print("Coding Error: Describe flag not binary")
609                   
610        except IndexError:
611            pass
612       
613
614    # This handles the input interface (loading a file)
615    def createInputInterface(self):
616
617        self.file_opt = options = {}
618        options['defaultextension'] = '.txt'
619        options['filetypes'] = [('text files', '.txt'), ('all files', '.*')]
620        options['initialdir'] = os.getcwd
621        options['initialfile'] = 'duchampHIPASS.txt'
622        options['parent'] = self.frame
623        options['title'] = 'Load Parameter File'
624
625        self.userSpecifiedFilePath = tkFileDialog.askopenfilename(**self.file_opt)
626
627        self.userSpecifiedFileName = self.userSpecifiedFilePath.split('/')[-1]
628        self.loadInputFile()
629       
630
631    # This handles the output interface for specified parameters (saving a file)
632    def createSpecifiedOutputInterface(self):
633       
634        self.file_opt = options = {}
635        options['defaultextension'] = '.txt'
636        options['filetypes'] = [('text files', '.txt'), ('all files', '.*')]
637        options['initialdir'] = os.getcwd
638        options['initialfile'] = self.userSpecifiedFileName.split('.')[0] + 'Edited.' + self.userSpecifiedFileName.split('.')[1]
639        options['parent'] = self.frame
640        options['title'] = 'Save User Specified Parameters'
641
642        self.newFilePath = tkFileDialog.asksaveasfilename(**self.file_opt)
643
644        writeParamFile(self.newFilePath, self.userSpecifiedParameters, self.orderedSpecifiedParameters, 1)
645
646
647    # This handles the output interface for effective parameters (saving a file)
648    def createEffectiveOutputInterface(self):
649       
650        self.file_opt = options = {}
651        options['defaultextension'] = '.txt'
652        options['filetypes'] = [('text files', '.txt'), ('all files', '.*')]
653        options['initialdir'] = os.getcwd
654        options['initialfile'] = self.userSpecifiedFileName.split('.')[0] + 'AllEdited.' + self.userSpecifiedFileName.split('.')[1]
655        options['parent'] = self.frame
656        options['title'] = 'Save List of Effective Parameters'
657
658        self.newFilePath = tkFileDialog.asksaveasfilename(**self.file_opt)
659
660        writeParamFile(self.newFilePath, self.effectiveParameters, self.orderedParameters, 1)
661       
662
663    # This decides whether to load or update the input files for specified parameters
664    def loadInputFile(self):
665
666        try:
667            fin = open(self.userSpecifiedFilePath, 'r')
668            fin.close()
669           
670            # If the list is empty, that means we are loading the file for the first time
671            if self.userSpecifiedParameters == {}:
672
673                self.createNoticeBox1(title = "Notice", message = "Input Files Loaded", command = self.load, buttonText = "Okay")
674
675            # If the list is non-empty, this means we risk rewritting any edits we have made
676            else:
677
678                msg = "Are you sure? Any edits you've made in the previous session will be lost and replaced with the contents of the new files."
679                self.createNoticeBox2(title = "Notice", message = msg, command1 = self.load, command2 = self.dismissNotice, buttonText1 = "Yes", buttonText2 = "No")
680        except IOError:
681            pass
682        except TypeError:
683            pass
684            print("TypeError")
685           
686       
687    # This loads or updates the input files for specified parameters
688    def load(self):
689
690        # The notice box can go away
691        self.noticeBox.destroy()
692
693        # Then we can determine the list of specified and effective parameters
694        (self.userSpecifiedParameters, self.orderedSpecifiedParameters) = readParamFile(self.userSpecifiedFilePath)
695        self.effectiveParameters.update(self.userSpecifiedParameters)
696       
697        messages = []
698       
699        # If the file is empty, let the user know.
700        if self.userSpecifiedParameters == {}:
701
702            messages += ["The file you loaded is empty. Parameter file discarded."]
703           
704        # Otherwise, determine if some parameters are not part of the default set of parameters.
705        else:
706            self.listParameters("Specified")
707
708            for par in self.orderedSpecifiedParameters:
709
710                if par not in self.defaultParameters:
711
712                    messages += ["Some parameters loaded are not part of the default set of parameters."]
713                    break
714
715        fin = open(self.userSpecifiedFilePath)
716
717        # Also, determine if the format was not correct.
718        for line in fin:
719
720            if line[0] != '#' and len(line) > 1 and len(line.split()) > 1:
721
722                if len(line.split()) != 2:
723
724                    messages += ["File loaded has the wrong format. Loaded inputs may be incorrect."]
725                    break
726
727        fin.close()
728
729        # Let the user know of the above detections
730        for msg in messages:
731
732            self.createNoticeBox1(title = "Notice", message = msg, command = self.dismissNotice, buttonText = "Dismiss")
Note: See TracBrowser for help on using the repository browser.