F:/thesis_austausch/dissertation/code_docu_doxygen/Visualiser/gui_classes.py

Go to the documentation of this file.

#!/usr/bin/env python

'''
This module contains the classes for the display tool. It is needed by the module "gui.py".

Reading University
MSc in Network Centred Computing
a.weise - a.weise@reading.ac.uk - December 2005
'''

from gui_utils import find_item, complete_days, complete_hours, complete_ticks
import Tkinter
import tkFileDialog
import tkMessageBox
import Graphs
import tooltips
from gui_utils import second, second_string_to_int, second_string_only


class Colour:
    '''
    This class uses the ANSI escape sequences to color the output !
    '''
    color = {"reset":"\x1b[0m",
            "bold":"\x1b[01m",
            "teal":"\x1b[36;06m",
            "turquoise":"\x1b[36;01m",
            "fuscia":"\x1b[35;01m",
            "purple":"\x1b[35;06m",
            "blue":"\x1b[34;01m",
            "darkblue":"\x1b[34;06m",
            "green":"\x1b[32;01m",
            "darkgreen":"\x1b[32;06m",
            "yellow":"\x1b[33;01m",
            "brown":"\x1b[33;06m",
            "red":"\x1b[31;01m",
            "darkred":"\x1b[31;06m"}
    
    def __init__(self):
        '''
        Constructor 
        '''
        pass
    
    def green(self, text):
        '''
        dye green
        '''
        return self.color['green']+text+self.color['reset']
        
    def red(self, text):
        '''
        dye red
        '''
        return self.color['red']+text+self.color['reset']
    
    def bold(self, text):
        '''
        dye bold
        '''
        return self.color['bold']+text+self.color['reset']
    
    def teal(self, text):
        '''
        dye teal
        '''
        return self.color['teal']+text+self.color['reset']
    
    def turquoise(self, text):
        '''
        dye turquoise
        '''
        return self.color['turquoise']+text+self.color['reset']
    
    def fuscia(self, text):
        '''
        dye fuscia
        '''
        return self.color['fuscia']+text+self.color['reset']
    
    def purple(self, text):
        '''
        dye purple
        '''
        return self.color['purple']+text+self.color['reset']
    
    def darkred(self, text):
        '''
        dye darkred
        '''
        return self.color['darkred']+text+self.color['reset']    
    
    def darkblue(self, text):
        '''
        dye darkblue
        '''
        return self.color['darkblue']+text+self.color['reset']

    def blue(self, text):
        '''
        dye blue
        '''
        return self.color['blue']+text+self.color['reset']
    
    def darkgreen(self, text):
        '''
        dye darkgreen
        '''
        return self.color['darkgreen']+text+self.color['reset']
    
    def yellow(self, text):
        '''
        dye yellow
        '''
        return self.color['yellow']+text+self.color['reset']
    
    def brown(self, text):
        '''
        dye brown
        '''
        return self.color['brown']+text+self.color['reset']    
    
    
class Picture(Tkinter.Tk):
    '''
    This class provides functions around the "diplay diagrams" issues.
    '''
    
    def __init__(self, color, windows):
        '''
        Constructor
        '''
        self._col = color
        self._windows = []
        # needed to close all windows properly
        self._all_windows = windows
        # needed for deactivate and activate all window buttons properly
        self._all_windows.append(self)
        # initialise tkinter
        Tkinter.Tk.__init__(self)
        # set min size
        self.minsize(width=500, height=400)
        #create frame, where the diagram is drawn later
        self.framus = Tkinter.Frame(self)
        # add frame to dialog
        self.framus.grid(
            column = 0,
            row = 0,
            columnspan = 7,
            sticky = "news" #north east west south
            )
        # "QUIT" BUTTON
        self.button_quit = Tkinter.Button(self, text="quit")
        self.button_quit.grid(
            column = 6,
            row = 1,
            columnspan = 1,
            sticky = "e"
                         )
        # tooltips for "QUIT" button        
        tooltips.ToolTip(self.button_quit, follow_mouse=1, text="Please press \"quit\" to close this window. Note, all windows, which are opened from this window (child windows) are closed as well !", delay=3500)
        self.button_quit.configure(command = self.pre_shutdown)
        # "SAVE AS" BUTTON
        self.button_save = Tkinter.Button(self, text = "save as")
        self.button_save.grid(
            column = 5,
            row = 1,
            columnspan = 1,
            sticky = "e"
                        )
        self.button_save.configure(command = self.save_as)
        # status bar
        self.status = Tkinter.Label(self)
        self.status.grid(
            column = 0,
            row = 3,
            columnspan = 7,
            sticky = "w"
                        )
        # configure grid
        self.grid_columnconfigure(0, weight = 1)
        self.grid_rowconfigure(0, weight = 1)
        
        # overwrite function
        self.protocol("WM_DELETE_WINDOW", self.shutdown)
        
        # saves as button hoover method
        self.button_save.bind("<Enter>", self._show_save_as_description)
        self.button_save.bind("<Leave>", self._hide_description)
        # tooltips for "SAVE AS" button        
        tooltips.ToolTip(self.button_save, follow_mouse = 1, text = "Please press \"save as\" to save the diagram as a postscript file.",  delay = 3500)
        
    def deactivate(self):
        '''
        This function deactivates all buttons.
        '''
        self.protocol("WM_DELETE_WINDOW", self._dummy)
        self.button_quit.configure(command = self._dummy)
        self.button_save.configure(command = self._dummy)
        if self._select_type == 'error' or self._select_type == 'date':
            self.button_select.configure(command = self._dummy)
    
    def activate(self):
        '''
        This function activates all buttons.
        '''
        self.protocol("WM_DELETE_WINDOW", self.shutdown)
        self.button_quit.configure(command = self.pre_shutdown)
        self.button_save.configure(command = self.save_as)
        if self._select_type == 'error':
            self.button_select.configure(command = self._select_error)
        elif self._select_type == 'date':
            self.button_select.configure(command = self._select_date)
        
    def save_as(self):
        '''
        This function saves the diagram picture as postscript.
        '''
        # deactivate all buttons
        try:
            for i in range(len(self._all_windows)):
                self._all_windows[i].deactivate()
        except Tkinter.TclError:
            pass
        # save as dialog
        result = tkFileDialog.asksaveasfilename(filetypes = [('postscript', '*.ps')], title = 'Save graph as ... ')
        # activate all buttons
        try:
            for i in range(len(self._all_windows)):
                self._all_windows[i].activate()
        except Tkinter.TclError:
            pass

        if result != '':
            # save diagram in file
            self.graph.canvas.postscript(file = result, colormode = 'color')
            ###Graphs.canvas.postscript(file = result, colormode = 'color')
        
    def _dummy(self, event = None):
        '''
        This function is doing nothing, it serves as a dummy.
        '''
        return 'break'
    
    def show_barchart(self, window_name, listus, label, xlabel, ylabel,  data, select_type=None, filus_fd = None, descript = None):
        '''
        This function shows a barchart diagram.
        '''
        self.title(window_name)
        self._data = data
        self._file_fd = filus_fd
        self._select_type = select_type
        # generate barchart diagram
        line = Graphs.GraphBars(listus, color  ='green', size = 6)
        graphObject = Graphs.GraphObjects([line])
        self.graph = Graphs.GraphBase(self.framus, 400, 400, relief = 'sunken', border = 2, listerus = label, x_label = xlabel, y_label = ylabel, header = window_name, description = descript, label_interval = 10)
        self.graph.pack(side = Tkinter.LEFT, fill = Tkinter.BOTH, expand = Tkinter.YES)
        self.graph.draw(graphObject, 'automatic', 'automatic')
        
        # sort items for listbox
        self.items = []
        self.search_label = []
        self.search_value = []
        for i in range(len(label)):
            self.items.append(label[i][1])
            self.search_value.append(listus[i])
            self.search_label.append(label[i])

        self.create_listbox()
        
    def show_line(self, window_name, listus, label, xlabel, ylabel,  data, select_type = None, error = None, labelamount = 10,  filus_fd = None, descript = None, typ = None):
        '''
        This functions shows a line chart diagram.
        
        window_name = name of the new window
        listus = value list
        label = label list for x-axis
        xlabel = description of x-axis
        ylabel = description of y-axis
        select_type = type of items are listed in listbox
        data = dataset which comes from the database query
        error = chosen error from listbox
        labelamount = amount of possible labels for the x-axis
        '''
        self.title(window_name)
        self._data = data
        self._file_fd = filus_fd
        self._select_type = select_type
        
        values = []
        
        # only draw a dot where is a real value
        for i in range(len(listus)):
            if listus[i][1] != 0 :
                values.append(listus[i])
      
        dot = Graphs.GraphSymbols(values,  color = 'green', marker = 'dot', fillcolor = 'darkgreen')
        
        if len(listus) > 1:
            line = Graphs.GraphLine(listus, color='green', size=6)
            graphObject = Graphs.GraphObjects([line, dot])
        else:
            graphObject = Graphs.GraphObjects([dot])
        
        self.graph = Graphs.GraphBase(self.framus, 600, 400, relief = 'sunken', border = 2, listerus = label, x_label = xlabel, y_label = ylabel, header = window_name, description = descript, label_interval = labelamount, type = typ)
        self.graph.pack(side = Tkinter.LEFT, fill = Tkinter.BOTH, expand = Tkinter.YES)
        self.graph.draw(graphObject, 'automatic', 'automatic')
        
        if select_type == "date":
            
            self.items = []
            self.search_label = []
            self.search_value = []
            #rearrange labels for listbox
            for i in range(len(label)):
                if listus[i][1] != 0 :
                    self.items.append(label[i][1])
                    self.search_value.append(listus[i])
                    self.search_label.append(label[i])

            # create listbox with dates
            self.create_listbox(error)

    def create_listbox(self,  error = None):
        '''
        This function creates a listbox with the given items.
        '''
         # listbox
        list_scrollbar = Tkinter.Scrollbar(self, orient=Tkinter.VERTICAL)
        list_scrollbar.grid ( row = 1, column = 1, columnspan = 1, sticky = "ns" )
         
        self.listbox = Tkinter.Listbox(self, height = 4, cursor = "plus", bg = "#ffffff", bd = 1, highlightcolor = "#00ff00",  yscrollcommand=list_scrollbar.set)
        self.listbox.grid(
            column = 0,
            row = 1,
            columnspan = 1,
            sticky = "news"
                         )
            
        self.listbox.bind("<Enter>", self._show_description)
        self.listbox.bind("<Leave>", self._hide_description)
        
        list_scrollbar["command"] = self.listbox.yview

        # "PLOT" button
        self.button_select = Tkinter.Button(self, text = "plot")
        self.button_select.grid(
            column = 3,
            row = 1,
            columnspan = 1,
            sticky = "w"
                        )
        
        self._the_error = error
        
        if self._select_type == 'error':
            self.button_select.configure(command = self._select_error)
        elif self._select_type == 'date':
            self.button_select.configure(command = self._select_date)
            
        self.button_select.bind("<Enter>", self._show_plot_description)
        self.button_select.bind("<Leave>", self._hide_description)
        # tooltips for "PLOT" button
        tooltips.ToolTip(self.button_select, follow_mouse = 1, text = "Please press \"plot\" to generate a new diagram with the selected item from the listbox.", delay = 3500)
        
        # OPTION (dropdown) menu
        if self._select_type == 'error':
            self._ldate = "%15s" % ("error")
            tooltips.ToolTip(self.listbox, follow_mouse = 1, text = "Please select an error and then press \"plot\" to view this error number only.")
            tooltips.ToolTip(self.listbox, follow_mouse = 1, text = "Please select an error and then press \"plot\" to view this error number only.")
        elif self._select_type == 'date':
            self._ldate = "%15s" % ("date")
            tooltips.ToolTip(self.listbox, follow_mouse = 1, text = "Please select a date and then press \"plot\" to view this date only.")
        self._lfreq = "%12s" % ("frequency")
        self.var = Tkinter.StringVar(self)
        # activate a trace, which monitores the changes, so in case the drop down menu is used a function is called
        self.var.trace('w', self.menu_change)
        self.var.set(self._ldate) # initial value
        
        option = Tkinter.OptionMenu(self, self.var, self._ldate, self._lfreq)

        option.bind("<Enter>", self._show_dropdown_description)
        option.bind("<Leave>", self._hide_description)
        
        if self._select_type == 'error':
            tooltips.ToolTip(option, follow_mouse = 1, text = "Select \"error\" or \"frequency\" to change the order in the listbox:\nerror -> order by error numbers (ascending)\nfrequency -> order by frequency (ascending).")
        elif self._select_type == 'date':
            tooltips.ToolTip(option, follow_mouse = 1, text = "Select \"date\" or \"frequency\" to change the order in the listbox:\ndate -> order by dates (ascending)\nfrequency -> order by frequency (ascending).")
        
        option.grid(
            column = 2,
            row = 1,
            columnspan = 1,
            sticky = "w"
                   )
        
        # SPACE LABEL
        labelus = Tkinter.Label(self)
        labelus.grid(
            column = 4,
            row = 1,
            columnspan = 1,
            sticky = "news"
                    )
 
    def menu_change(self, name, index, mode):
        '''
        This function changes the order in the listbox according to the chosen item in the drop down menu.
        '''
        temp_listus = []
        temp_search_label = []
        
        change = self.var.get()
        # for dates
        if change == self._ldate:

            if self._select_type == 'error':
                self.search_label.sort(second_string_to_int)
                self._dropdown_description = "change order in listbox, currently ordered by \"error number\""
            elif self._select_type == 'date':
                self.search_label.sort(second_string_only)
                self._dropdown_description = "change order in listbox, currently ordered by \"date\""
            

            for i in range(len(self.search_label)):
                # save label
                temp = self.search_label[i][1]
                 # search for corresponding label in label array
                for j in range(len(self.search_value)):
                    if self.search_label[i][0] == self.search_value[j][0]:
                        # save corresponding label
                        temp_listus.append([i+1, self.search_value[j][1]])
                # adjust items
                temp_search_label.append([i+1, temp])
                
                self.items[i] = "%s  (%s)" % (temp_search_label[len(temp_search_label)-1][1], temp_listus[len(temp_listus)-1][1])
            
            self.search_value = temp_listus[:]
            self.search_label = temp_search_label[:]
 
            # delete old items and write new items in listbox
            self.listbox.delete(0, Tkinter.END)
            for i in range(len(self.items)):
                self.listbox.insert(Tkinter.END, self.items[i])
        
        # for frequency
        elif change == self._lfreq:

            self._dropdown_description = "change order in listbox, currently ordered by \"frequency\""
            self.search_value.sort(second)
            
            # rearrange order of array
            for i in range(len(self.search_value)):
                #save value
                temp = self.search_value[i][1]
                # search for corresponding label in label array
                for j in range(len(self.search_label)):
                    if self.search_label[j][0] == self.search_value[i][0]:
                        # save corresponding label
                        self.items[i] = "%s  (%s)" % (self.search_label[j][1], self.search_value[i][1])
                        temp_search_label.append([i+1, self.search_label[j][1]])
                # adjust number in value array
                self.search_value[i][0] = i+1
                self.search_value[i][1] = temp
                
            # rearrange label array description
            self.search_label = temp_search_label[:]
                
            # delete old items and write new items in listbox
            self.listbox.delete(0, Tkinter.END)
            for i in range(len(self.items)):
                self.listbox.insert(Tkinter.END, self.items[i])

    def pre_shutdown(self):
        '''
        This function calls a message box and make sure the user really wants to shutdown.
        '''
        # deactivate all buttons
        try:
            for i in range(len(self._all_windows)):
                self._all_windows[i].deactivate()
        except Tkinter.TclError:
            pass
        # queston message box
        status = tkMessageBox.askquestion("Close Window", "Do you really want to close this and all child windows ?")
        # activate all buttons
        try:
            for i in range(len(self._all_windows)):
                self._all_windows[i].activate()
        except Tkinter.TclError:
            pass            
        if status == 'yes':
            self.shutdown()
        
    def shutdown(self):
        '''
        This function closes all open child windows and itself
        '''
        
        if self._file_fd != None:
            if self._all_windows[0] == self:
                # only main windows closes file
                self._file_fd.close()
        
        # destroy all cildren windows
        for i in range(len(self._windows)):
            try:
                self._windows[i].shutdown()
                
            except Tkinter.TclError:
                pass
            
        # destroy myself            
        try:
            self.destroy()
        except Tkinter.TclError:
            pass

    def _select_error(self):
        '''
        This function get the selected item from the listbox
        '''
        try:
            # get index of chosen listbox item
            firstIndex = self.listbox.curselection()[0]
        except IndexError:
            firstIndex = None
            
        if firstIndex != None:

            # convert index to int            
            firstIndex = int(firstIndex)
            
            # print data
            title = "Diagram Error %s \"Frequency - Date\"" % self.search_label[firstIndex][1]
            
            field = []
            field_label = []
            data_new = []
            # work up the given data and prepare for display
            for i in range(len(self._data)):
                if (int(self._data[i]['error.e_number']) == int(self.search_label[firstIndex][1])):
                    data_new.append(self._data[i]) # get new dataset (only interesting data is taken)
                    index = find_item(self._data[i]['messages.m_date'], field)
                    if (None == index):
                        field.append([self._data[i]['messages.m_date'], 1])
                        field_label.append([self._data[i]['messages.m_date'], 1])
                    else:
                        count = field[index][1]
                        count += 1
                        field[index][1] = count
                        field_label[index][1] = count
  
            field.sort()
            field_label.sort()           
           
            # print result table                 
            h_line = "------------------------------------"
            v_line = "|"
            header = "\nFrequency of Error \"%s\":\n" % self.search_label[firstIndex][1]
            
            # write in file
            if self._file_fd != None:
                content =  "\n"+header
                content += "\n\n Nr.   | Date\t\t| Frequency\n\n"
                self._file_fd.write(content)
            
            if self._col == 1:
                col_obj = Colour()
                
                header = col_obj.yellow(header)
                h_line = col_obj.yellow(h_line)
                v_line = col_obj.yellow(v_line)
                
            print header
            print h_line
            print " Nr.   "+v_line+" Date\t\t"+v_line+" Frequency"
            print h_line
            
            for i in range(len(field)):
                print " %5d %s %s\t%s %s" % ((i+1), v_line, field[i][0], v_line, field[i][1])
                
                # write in file
                if self._file_fd != None:
                    content = " %5d | %s\t| %s\n" % ((i+1),  field[i][0], field[i][1])
                    self._file_fd.write(content)                
                
            print h_line

            for i in range(len(field_label)):
                temp = field_label[i][0]
                field_label[i][0] = field_label[i][1]
                field_label[i][1] = temp
            
            for i in range(len(field)):
                field_label[i][0] = (i+1)
                field_label[i][1] = "%s" % field[i][0]
                field[i][0] = (i+1)
                    
            field_label, field = complete_days(field_label, field)

            pic_obj = Picture(self._col, self._all_windows)

            self._windows.append(pic_obj)
            
            title = "Diagram \"Frequency - Date\" - Error: %s" % self.search_label[firstIndex][1]
            descr = title+" - Range: "+field_label[0][1]+"  -  "+field_label[len(field_label)-1][1]#+" )"
            pic_obj.show_line(title, field, field_label, "DATE", "FREQUENCY", data_new, select_type = "date", error = self.search_label[firstIndex][1], labelamount = 10, filus_fd = self._file_fd, descript = descr, typ = "date" )

            pic_obj.mainloop()
            
        else:
            # disable all buttons within the windows
            for i in range(len(self._all_windows)):
                self._all_windows[i].deactivate()
                
            tkMessageBox.showerror("Error", "No item selected !")
            # enable all buttons within the windows
            for i in range(len(self._all_windows)):
                self._all_windows[i].activate()
            
    def _select_date(self):
        '''
        This functions take a date and generates a new graph 
        '''
        
        try:
            firstIndex = self.listbox.curselection()[0]
        except IndexError:
            firstIndex = None
            
        if firstIndex != None:
            
            firstIndex = int(firstIndex)

            # print data
            title = "Diagram \"Frequency - Time\" - Date %s" % self.search_label[firstIndex][1]
            
            field = []
            field_label = []
            data_new = []
            for i in range(len(self._data)):
                if self._data[i]['messages.m_date'] == self.search_label[firstIndex][1] and int(self._the_error) == int(self._data[i]['error.e_number']):
                    
                    data_new.append(self._data[i])
                    hour = self._data[i]['messages.m_time'].split(":")

                    hour[0] = int(hour[0])# hour
                   
                    index = find_item(hour[0], field)
                    if (None == index):
                        field.append([hour[0], 1])
                        field_label.append([hour[0], 1])
                    else:
                        count = field[index][1]
                        count += 1
                        field[index][1] = count
                        field_label[index][1] = count
        
            field.sort()
            field_label.sort()
            
            # rearrange arrays for use within the picture and graph class
            for i in range(len(field_label)):
                temp = field_label[i][0]
                field_label[i][0] = field_label[i][1]
                field_label[i][1] = temp
            
            for i in range(len(field)):
                field_label[i][0] = (i+1)
                field_label[i][1] = "%s" % field[i][0]
                field[i][0] = (i+1)
                    
            field_label, field = complete_hours(field_label, field)
            field_label, field = complete_ticks(field_label, field)
           
            h_line = "-------------------------------"
            v_line = "|"
            header = "\nFrequency on Date \"%s\":\n" % self.search_label[firstIndex][1]
            
            # write in file
            if self._file_fd != None:
                content = "\n"+header
                content += "\n\n Time of Day\t| Frequency\n\n"
                self._file_fd.write(content)            
            
            if self._col == 1:
                col_obj = Colour()
                print col_obj.yellow(header)
                h_line = col_obj.yellow(h_line)
                v_line = col_obj.yellow(v_line)
                
            print h_line
            print " Time of Day\t"+v_line+" Frequency"
            print h_line
            
            for i in range(len(field)):
                print " %2s h - %2s h\t%s %s" % (i, i+1, v_line, field[i][1])
                
                if self._file_fd != None:
                    content = " %2s h - %2s h\t| %s\n" % (i , i+1, field[i][1])
                    self._file_fd.write(content)                 
                
            print h_line           
            
            pic_obj = Picture(self._col, self._all_windows)
            self._windows.append(pic_obj)

            pic_obj.show_line(title, field, field_label, "TIME OF DAY (hrs)", "FREQUENCY", data_new , select_type = "time", labelamount=24, filus_fd = self._file_fd, descript = title  )
            pic_obj.mainloop()
        
        else:
            
            for i in range(len(self._all_windows)):
                self._all_windows[i].deactivate()
            tkMessageBox.showerror("Error", "No item selected !")
            for i in range(len(self._all_windows)):
                self._all_windows[i].activate()
            
        
    def _show_description(self, event):
        '''
        This function displays the description for the listbox in the status bar.
        '''
        if self._select_type == 'error':
            self.status.config(text = "listbox: error number (frequency) -> select error to zoom", anchor = "w")
        if self._select_type == 'date':
            self.status.config(text = "listbox: date (frequency) for the choosen error -> select date to zoom", anchor = "w")
        self.status.update_idletasks()
    
    def _show_plot_description(self, event):
        '''
        This function displays the description of the "plot" button in the status bar.
        '''
        self.status.config(text = "plot new diagram", anchor = "w")
        self.status.update_idletasks()        

    def _hide_description(self, event):
        '''
        This function deletes the status bar content.
        '''
        self.status.config(text="")
        self.status.update_idletasks()
        
    def _show_save_as_description(self, event):
        '''
        This function show the description of the "save as" button in the status bar.
        '''
        self.status.config(text = "save diagram as postscript file", anchor = "w")
        self.status.update_idletasks()
        
    def _show_dropdown_description(self, event):
        '''
        This function shows a short description for the dropdown menu in the status bar.
        '''
        
        self.status.config(text = self._dropdown_description, anchor = "w")
        self.status.update_idletasks()
        

---