source: branches/GUIdev/DuchampParameterGUI_mainInterfaceClass.py @ 1441

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

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