source: branches/GUIdev/Original Trial Files (9 December 2013)/ParameterEdit6.py @ 1441

#-------------------------------------------------------------------------------
# Name:        ParameterEdit6
# Purpose:
#
# Author:      Kelvin
#
# Created:     4/12/2013
#-------------------------------------------------------------------------------

# Note to self: Make this program more modular and readable by splitting it into distinct parts and use perhaps use functions to implement them.
# Note to self: Python can also be made into multi-file programs, so that it looks neater. Use 'import' to achieve that.


# Define the file names involved.
defaultParamFileName = '/u/hsu004/IntroToDuchamp/duchampDefaultParameters'
oldParamFileName = '/u/hsu004/IntroToDuchamp/duchampHIPASS.in'
newParamFileName = '/u/hsu004/Kelvin/duchampHIPASSedited.in'
userSpecifiedParamFileName = newParamFileName
edittedParamFileName = '/u/hsu004/Kelvin/duchampHIPASSeditedNEW.in'


# Define a simple function to determine the user's intent.
# Note that this may be very inefficient.
YES = 1
NO = 0
INVALID = -1
def toEdit(response):
    if (response == 'y') | (response == 'Y') | (response == 'yes'):
        return(YES)
    elif (response == 'n') | (response == 'N') | (response == 'no'):
        return(NO)
    else:
        return(INVALID)

    
# Define a function to read parameter files with the specified format.
def readParamFile(paramFileName):

    # Initialise an empty Dictionary.
    parameters = {}

    # Open the given parameter file.
    paramFile = open(paramFileName)

    # Load files for lines of parameter data in the specified format and
    # store them into the dictionary.
    for line in paramFile:
        if line[0] != '#' and len(line) > 1:
            linebits = line.split()
            parameters[linebits[0]] = linebits[1]

    # Go back to the start of the file.
    paramFile.seek(0, 0)

    paramFile.close()

    return parameters

# Define a function to create a parameter file with the specified format.
def writeParamFile(newParamFileName, parameters):

    # Create a new file.
    newParamFile = open(newParamFileName, 'w')

    # Write the editted set of parameters into the new file.
    for par in parameters:
        newParamFile.write('%s    %s\n'%(par, parameters[par]))

    newParamFile.close();

# Define a function to print a list of parameters listed in a dictionary.
def listParameters(parameters):

    for par in parameters:
        print(par, parameters[par])
        
    print('\n')

# Firstly, determine the default list of parameters
defaultParameters = readParamFile(defaultParamFileName)   

# Then, determine the user specified list of parameters
userSpecifiedParameters = readParamFile(userSpecifiedParamFileName)
        
# This is the function that defines the shell interface
# which prompts the user with options to edit the parameters in a given file.
def editParameter():
    
    # Firstly, determine the default list of parameters
    defaultParameters = readParamFile(defaultParamFileName)

    # Display the default set of parameters.
    print('Original set of Parameters: \n')
    listParameters(defaultParameters)

    parameters = readParamFile(oldParamFileName)

    # Display the original set of parameters.
    print('Original set of Parameters: \n')
    listParameters(parameters)

    # Prompt the user about whether they want to edit any parameters.
    keepEditting = raw_input('\nWould you like to edit any of the parameters? (Type "y" for yes): ')

    # This handles the case when no parameters are to be editted.
    if toEdit(keepEditting) == NO:
        print('\nNo parameters will be editted.')
        
    if toEdit(keepEditting) == INVALID:
        keepEditting = raw_input('\nInvalid Input. Did you mistype something? Did you want to edit any of the parameters? (Type "y" for yes): ')


    # This handles the case when the parameters are to be editted.
    while toEdit(keepEditting) == YES:

        # Prompt the user for the parameter name.
        parameter2edit = raw_input('\nWhich parameter would you like to edit? \n\tParameter: ')

        # If the parameter exists, edit the parameter value.
        # Note that the value is always stored as a string, even if the value is a 'number'.
        if parameter2edit in parameters:

            oldValue = parameters[parameter2edit]
            newValue = raw_input('\nPlease enter a new value or setting for "' + parameter2edit + '": ')
            parameters[parameter2edit] = newValue
            print('\n"' + parameter2edit + '" has been updated from ' + str(oldValue) + ' to ' + str(newValue) + '!')

        # Otherwise, if no such parameters exist, tell the user.    
        else:
            print('\nThere is no such parameter as "' +  parameter2edit + '" in your file "' + oldParamFileName + '"')

        # Prompt the user again if editting is to be continued.
        keepEditting = raw_input('\nWould you like to edit any other parameters? (Type "y" for yes): ')

        # Sometimes people mistype...
        if toEdit(keepEditting) == INVALID:
            keepEditting = raw_input('\nInvalid Input. Did you mistype something? Would you like to edit any other parameters? (Type "y" for yes): ')

    # Let the user know that the editting process has ended.
    if toEdit(keepEditting) == NO:
        print('\nFinished Editting.')
    elif toEdit(keepEditting) == INVALID:
        print('\nInvalid Input. No parameters will be editted.')
        

    # Display the editted set of parameters.
    print('\nEditted set of Parameters: \n');
    listParameters(parameters)
        
    writeParamFile(newParamFileName, parameters)

# This is the function that checks the parameter value of a given parameter.
def checkParam():

    # Firstly, determine the default list of parameters
    defaultParameters = readParamFile(defaultParamFileName)   

    # Then, determine the user specified list of parameters
    userSpecifiedParameters = readParamFile(userSpecifiedParamFileName)

    parameter2check = raw_input('\nWhich parameter would you like to check? \n\tParameter: ')

    if parameter2check in userSpecifiedParameters:
        print(parameter2check + ': ' + userSpecifiedParameters[parameter2check])
    elif parameter2check in defaultParameters:
        print(parameter2check + ': ' + defaultParameters[parameter2check])
    else:
        print('\n"' + parameter2check + '" does not exist.')

#-------------------------------------------------------------------------------
# GUI - Tkinter section
from Tkinter import *
  
class mainInterface:
  
    def __init__(self, master):

        self.frame = Frame(master)
        
        self.frame.grid()

        self.parameterLabel = Label(self.frame, text = "Parameter: ", foreground = "Blue")
        #self.parameterLabel.pack()
        #self.parameterLabel.place(x = 0.10, y = 0.10)
        self.parameterLabel.grid(row = 1, column = 1, columnspan = 2)

        self.valueLabel = Label(self.frame, text = "Value: ", foreground = "Green")
        #self.valueLabel.pack()
        #self.valueLabel.place(x = 0.50, y = 0.10)
        self.valueLabel.grid(row = 1, column = 3, columnspan = 2)

        self.parameterEntry = Entry(self.frame, width = 25)
        self.parameterEntry.grid(row = 2, column = 1, padx = 10, columnspan = 2)

        self.valueEntry = Entry(self.frame, width = 25)
        self.valueEntry.grid(row = 2, column = 3, padx = 10, columnspan = 2)

        self.checkButton = Button(self.frame, text = "Check", command = self.checkParameter)
        self.checkButton.grid(row = 3, column = 1, padx = 10, pady = 10)

        self.updateButton = Button(self.frame, text = "Update", command = self.updateParameter)
        self.updateButton.grid(row = 3, column = 2, padx = 10, pady = 10)

        self.listDefault = Button(self.frame, text = "List Default Parameters", command = self.listDefaultParameters)
        self.listDefault.grid(row = 4, column = 1, padx = 10, columnspan = 2)

        self.listSpecified = Button(self.frame, text = "List User Specified Parameters", command = self.listSpecifiedParameters)
        self.listSpecified.grid(row = 5, column = 1, padx = 10, columnspan = 2)

        self.saveButton = Button(self.frame, text = "Save", command = self.saveParameter)
        self.saveButton.grid(row = 4, column  = 4, padx = 20, pady = 10, sticky = E)

        #self.printDefault = Button(self.frame, text = "Default Parameters", 
        
        self.buttonQUIT = Button(self.frame, text = "QUIT", fg = "red", command = self.frame.quit)
        #self.buttonQUIT.pack()
        #self.buttonQUIT.place(x = 100, y = 50)
        self.buttonQUIT.grid(row = 5, column = 4, padx = 20, pady = 10, sticky = E)

        

        self.resultTitle = StringVar()
            
        self.result = StringVar()

        self.notesTitle = StringVar()

        self.notes = StringVar()

    def checkParameter(self):

        parameter2check = self.parameterEntry.get()

        if parameter2check in userSpecifiedParameters:
            value = userSpecifiedParameters[parameter2check]
            paramInfo = parameter2check + ': ' + value
            color = "Green"
            defaultYN = "No"
        elif parameter2check in defaultParameters:
            value = defaultParameters[parameter2check]
            paramInfo = parameter2check + ': ' + value
            color = "Green"
            defaultYN = "Yes"
        else:
            paramInfo = '"' + parameter2check + '" does not exist.'
            color = "Red"
            defaultYN = "N/A"

        self.resultTitle.set("Parameter Information")
        self.result.set(paramInfo)
        self.notesTitle.set("Default Parameter?")
        self.notes.set(defaultYN)
        
        self.resultLabel = Label(self.frame, textvariable = self.resultTitle)
        self.resultLabel.grid(row = 1, column = 5, padx = 10, columnspan = 2)
        
        self.resultValue = Label(self.frame, textvariable = self.result, foreground = color)
        self.resultValue.grid(row = 2, column = 5, padx = 10, columnspan = 2)

        self.valueEntry.delete(0, END)
        self.valueEntry.insert(0, value)

        self.notesLabel = Label(self.frame, textvariable = self.notesTitle)
        self.notesLabel.grid(row = 1, column = 7, padx = 10)

        self.notesValue = Label(self.frame, textvariable = self.notes)
        self.notesValue.grid(row = 2, column = 7, padx = 10)

    def updateParameter(self):

        parameter2update = self.parameterEntry.get()
       
        if parameter2update in userSpecifiedParameters:
            value2write = self.valueEntry.get()
            userSpecifiedParameters[parameter2update] = value2write
            paramInfo = parameter2update + ': ' + value2write
            newParamYN = "Updated parameter in user specified parameter list"
        elif parameter2update in defaultParameters:
            value2write = self.valueEntry.get()
            userSpecifiedParameters[parameter2update] = value2write
            paramInfo = parameter2update + ': ' + value2write
            newParamYN = "Added new parameter in user specified parameter list."
        else:
            paramInfo = '"' + parameter2update + '" does not exist.'
            newParamYN = "-"

        self.resultTitle.set("Parameter Information")
        self.result.set(paramInfo)
        self.notesTitle.set("Notes")
        self.notes.set(newParamYN)

        self.resultLabel = Label(self.frame, textvariable = self.resultTitle)
        self.resultLabel.grid(row = 1, column = 5, padx = 10, columnspan = 2)
        
        self.resultValue = Label(self.frame, textvariable = self.result)
        self.resultValue.grid(row = 2, column = 5, padx = 10, columnspan = 2)

        self.notesLabel = Label(self.frame, textvariable = self.notesTitle)
        self.notesLabel.grid(row = 1, column = 7, padx = 10)

        self.notesValue = Label(self.frame, textvariable = self.notes)
        self.notesValue.grid(row = 2, column = 7, padx = 10)

    def listDefaultParameters(self):
        listParameters(defaultParameters)

    def listSpecifiedParameters(self):
        listParameters(userSpecifiedParameters)

    def saveParameter(self):
        writeParamFile(edittedParamFileName, userSpecifiedParameters)
        


        

       
        
        
  
def main():
    root = Tk()
    root.wm_title("Duchamp Parameters")
  
    interface = mainInterface(root)

  
    root.mainloop()
    root.destroy()

#-------------------------------------------------------------------------------     
    
##def main():
##    editParameter()
##    checkParameter()
    
if __name__ == '__main__':
    main()