#!/usr/bin/env python
import os
import pygtk
pygtk.require('2.0')
import gtk
from export import Export
import Image
from my_exceptions import *
from  message import Message
from double_lin_reg import Double_Linear_Regression
from box_counting import Box_Counting,test_image
TMP_REP='/tmp'


class Xfrac_dim:
    "Graphic interface for frac_dim"
    
    def delete(self, widget, event=None):
        gtk.main_quit()
        return False 

    def switch(self,widget):
        widget.set_label(self.Etat)
        if self.Etat=="File mode":
            self.File_mode.hide()
            self.Directory_mode.show()
            self.Etat="Directory mode"
        else:
            self.Directory_mode.hide()
            self.File_mode.show()
            self.Etat="File mode"
        widget.show()

        
    def __init__(self):
        
        self.Window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.Window.connect("delete_event", self.delete)
        self.Window.set_border_width(10)
        Main_box=gtk.VBox(homogeneous=False , spacing=10)
        

        # Creation of the notebook
        self.Notebook = gtk.Notebook()
        self.Notebook.set_tab_pos(gtk.POS_TOP)
        Main_box.pack_start(self.Notebook,True,True,0)
        self.Notebook.show()
        self.show_tabs = True
        self.show_border = True

        #first frame of the notebook
        self.File_mode=file_mode(self.Notebook)
        self.Directory_mode=directory_mode(self.Notebook)
        self.File_mode.show()
        self.Etat="File mode"
        


       
        # Create the close button
        Bottom_box = gtk.HBox(homogeneous=False , spacing=10)

        self.Switch_button =gtk.Button("Directory mode")
        self.Switch_button.connect("clicked",self.switch)
        self.Switch_button.show()
        Bottom_box.pack_start(self.Switch_button,False ,False ,0)

        Quit_button = gtk.Button("close",gtk.STOCK_QUIT)
        Quit_button.connect("clicked", self.delete)
        Quit_button.show()
        Bottom_box.pack_start(Quit_button,False ,False ,0)
        Bottom_box.show()

        Main_box.pack_start(Bottom_box,False ,False ,0)
        

        Main_box.show()
        self.Window.add(Main_box)

        self.Window.show()









class file_mode:
    "define the file_mode"

    def load_image(self,widget,entry):
        try:
            self.Bc.set_image(entry.get_text())
            self.Image=entry.get_text()
            self.preview.destroy()
            self.preview.set_from_file(self.Image)
            self.preview.show()

            self.scrolled_image.destroy()
            self.scrolled_image = gtk.ScrolledWindow()
            self.scrolled_image.set_border_width(10)
            self.scrolled_image.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)

            self.scrolled_image.add_with_viewport(self.preview)    
            self.scrolled_image.show()
            self.bc_left_box.pack_start(self.scrolled_image,True,True,10)
            self.bc_left_box.show()
            self.bc_box.show()
            self.Button_compute.set_sensitive(True)
            
        except InvalidImage, detail:
            print "This image is not a valid one : " + detail
            self.Button_compute.set_sensitive(False )


        
    def file_selection(self,widget,output=""):
        filew = gtk.FileSelection("File selection")
        filew.connect("destroy", lambda w: filew.destroy())
        filew.ok_button.connect("clicked", self.file_ok_sel,filew)
        filew.cancel_button.connect("clicked", lambda w: filew.destroy())
        filew.set_filename(output)
        filew.show()


    def file_ok_sel(self, widget,filew):
        self.entry.set_text(filew.get_filename())
        self.load_image(self,self.entry)
        filew.destroy()


    def compute(self,widget):
        self.Method.set_method(self.Bc)
        self.Bc.compute()
        self.DLR=Double_Linear_Regression(self.Bc.plot())        
        ex=export_page(self.Notebook,self.entry.get_text(),self.Bc,self.DLR.coefficient())



    def __init__(self,Notebook):
        self.Exp=Export()
        self.Bc=Box_Counting()


        self.frame_name = "File mode" 
        self.Notebook=Notebook
        self.bc_frame = gtk.Frame(self.frame_name)
        self.bc_frame.set_border_width(10)
        self.bc_frame.set_size_request(700, 500)
        self.bc_frame.show()

        self.bc_box=gtk.HBox(homogeneous=False , spacing=10)

        #left part
        self.bc_left_box=gtk.VBox(homogeneous=False , spacing=10)

        self.file_selection_box = gtk.HBox(homogeneous=False , spacing=10)
        
        self.entry = gtk.Entry()
        self.entry.set_max_length(70)
        self.entry.connect("activate", self.load_image, self.entry)
        self.entry.set_text("Monfichier")
        self.entry.show()
        
        self.file_selection_box.pack_start(self.entry,True,True,10)

        button_browse=gtk.Button("Browse",gtk.STOCK_FIND)
        button_browse.connect("clicked",self.file_selection)
        button_browse.show()

        self.file_selection_box.pack_start(button_browse,False ,False ,10)

        self.file_selection_box.show()        
        self.bc_left_box.pack_start(self.file_selection_box,False ,False ,10)

        self.scrolled_image = gtk.ScrolledWindow()
        self.scrolled_image.set_border_width(10)
        self.scrolled_image.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)

        self.preview = gtk.Image()

        self.bc_left_box.pack_start(self.scrolled_image,True,True,10)
        self.bc_left_box.show()
        self.bc_box.pack_start(self.bc_left_box,True,True,10)

        #right part 
        bc_right_box=gtk.VBox(homogeneous=False , spacing=10)

        self.Method=Method()

        bc_right_box.pack_start(self.Method.get_object(),False ,False ,10)

        self.Button_compute=gtk.Button("Compute",gtk.STOCK_EXECUTE)
        self.Button_compute.set_sensitive(False )
        self.Button_compute.connect("clicked",self.compute)
        self.Button_compute.show()

        bc_right_box.pack_start(self.Button_compute,False ,False ,10)
        bc_right_box.show()

        self.bc_box.pack_start(bc_right_box,False ,False ,10)

        self.bc_box.show()    
        self.bc_frame.add(self.bc_box)
        self.bc_frame.show()



    def show(self):
        Label = gtk.Label(self.frame_name)
        Label.show()
        self.Notebook.insert_page(self.bc_frame, Label,0)
        self.Notebook.set_current_page(0)

    
    def hide(self):       
        self.Notebook.remove_page(0)




class work_data:
    def __init__(self):
        self.data={}

    def add_image(self,image):
        self.data[image]={'status':'TODO'}
        self.data[image]["bc"]=Box_Counting()
        self.data[image]["bc"].set_image(image)

    def compute(self,image):
        if self.data[image]['status'] =='TODO':
            self.data[image]["bc"].compute()
            self.data[image]["DLR"]=Double_Linear_Regression(self.data[image]["bc"].plot())
        else:
            print "Error : Computation already done (or in progress)"

    def set_method(self,image,method,precision=None):
        self.data[image]["bc"].set_method(method)
        if method== "exponential":
            if precision != None:
                self.data[image]["bc"].set_precision(precision)
            else:
                raise "Precision needed for exponential method"
            

    def get_DLR(self,image):
        return self.data[image]["DLR"]

    def get_bc(self,image):
        return self.data[image]["bc"]


    def get_text_dim(self,image):
        if self.data[image]['status']=="TODO":
            raise "NOT_YET_CALCULATED"
            
        return  - self.data[image]["DLR"].coefficient()[0][0]


    def get_struct_dim(self,image):
        if self.data[image]['status']=="TODO":
            raise "NOT_YET_CALCULATED"
        return - self.data[image]["DLR"].coefficient()[1][0]

                

    def set_status(self,image,status):
        self.data[image]['status']=status

    def get_status(self,image):
        return self.data[image]['status']


    def set_textural_dim(self,image,textural_dim):
         self.data[image]['tex_dim']=textural_dim

    def set_structural_dim(self,image,structural_dim):
         self.data[image]['struct_dim']=structural_dim

    def get_textural_dim(self,image):
         return self.data[image]['tex_dim']

    def get_structural_dim(self,image):
         return self.data[image]['struct_dim']

    def list_images(self):
        return self.data.keys()


class directory_mode:
    "define the directory_mode"

    def __init__(self,Notebook):
        
        self.wdata=work_data()

        self.frame_name = "Directory mode" 
        self.Notebook=Notebook
        self.bc_frame = gtk.Frame(self.frame_name)
        self.bc_frame.set_border_width(10)
        self.bc_frame.set_size_request(700, 500)

        
        self.bc_box=gtk.HBox(homogeneous=False , spacing=10)

        #left part
        self.bc_left_box=gtk.VBox(homogeneous=False , spacing=10)

        self.Directory_selection_box = gtk.HBox(homogeneous=False , spacing=10)
        
        self.Entry = gtk.Entry()
        self.Entry.set_max_length(70)
        self.Entry.connect("activate", self.load_rep)
        self.Entry.set_text("My directory")
        self.Entry.show()
        
        self.Directory_selection_box.pack_start(self.Entry,True,True,10)

        button_browse=gtk.Button("Browse",gtk.STOCK_FIND)
        button_browse.connect("clicked",self.directory_selection)
        button_browse.show()

        self.Directory_selection_box.pack_start(button_browse,False ,False ,10)


        self.Directory_selection_box.show()        
        self.bc_left_box.pack_start(self.Directory_selection_box,False ,False ,10)

        self.fshow=files_show(self.wdata,self.Notebook)
        self.bc_left_box.pack_start(self.fshow.gtk_ref() ,True ,True ,10)###False false avant



        self.bc_left_box.show()
        self.bc_box.pack_start(self.bc_left_box,True,True,10)

        #right part 
        bc_right_box=gtk.VBox(homogeneous=False , spacing=10)

        self.Method=Method()

        bc_right_box.pack_start(self.Method.get_object(),False ,False ,10)



        self.Button_compute=gtk.Button("Compute",gtk.STOCK_EXECUTE)
        self.Button_compute.set_sensitive(False )
        self.Button_compute.connect("clicked",self.compute)
        self.Button_compute.show()

        bc_right_box.pack_start(self.Button_compute,False ,False ,10)

        bc_right_box.show()

        self.bc_box.pack_start(bc_right_box,False ,False ,10)
        self.bc_box.show()
        self.bc_frame.add(self.bc_box)
        self.bc_frame.show()

    


    def load_rep(self,widget):
        self.Directory=widget.get_text()
        try:
            Files=os.listdir(self.Directory)
            self.Images=filter(test_image,Files)
            self.Button_compute.set_sensitive(True)        
        except OSError:
            print "You have to select a directory!"


       
    
        
    def directory_selection(self,widget,output=""):
        dialog = gtk.Dialog("merde", widget, 0,[])
        dialog.show()

        filew = gtk.FileSelection("Directory selection")
        filew.connect("destroy", lambda w: filew.destroy())
        filew.ok_button.connect("clicked", self.file_ok_sel,filew)
        filew.cancel_button.connect("clicked", lambda w: filew.destroy())
        filew.set_filename(output)
        filew.show()


    def file_ok_sel(self, widget,filew):
        self.Directory=(filew.get_filename())
     #   self.Entry.set_text(self.Directory)
        try:
            Files=os.listdir(self.Directory)
            for i in filter(test_image,Files):
                self.wdata.add_image(i)
            self.Button_compute.set_sensitive(True)
            self.fshow.update()
        except OSError:
            print "You have to select a directory!"
        filew.destroy()


    def compute(self,widget):
        #self.Bcs={}
        #self.DLRs={}
        for image in self.wdata.list_images():
            print image
            #self.Bcs[image]=Box_Counting()
            #self.Bcs[image].set_image(image)
            #self.Method.set_method(self.Bcs[image])

            (method,parameter)=self.Method.get_method()
            self.wdata.set_method(image,method,parameter)
            self.wdata.compute(image)
            self.wdata.set_status(image,"DONE")

            self.fshow.update()

            #self.Bcs[image].compute()
#            self.DLRs[image]=Double_Linear_Regression(self.Bcs[image].plot())        
#            ex=export_page(self.Notebook,image,self.wdata.get_bc(image),self.wdata.get_DLR(image).coefficient())





        

    def show(self):
        Label = gtk.Label(self.frame_name)
        Label.show()
        self.Notebook.insert_page(self.bc_frame, Label,0)
        self.Notebook.set_current_page(0)

    
    def hide(self):       
        self.Notebook.remove_page(0)






class files_show:
    """Define an object to print a list of file and parameter corresponding to this files"""


    def __init__(self, wdata,notebook):
        self.Notebook=notebook
        cell_data_funcs = (self.file_name, self.status,self.struct_dim, self.tex_dim)
        self.column_names=["File","Status","Structural dimension","Textural dimension"]

        self.wdata=wdata #use reference 
 
        
        # create the TreeView
        self.treeview = gtk.TreeView()
 
        # create the TreeViewColumns to display the data
        self.tvcolumn = [None] * len(self.column_names)

        cell = gtk.CellRendererText()
        self.tvcolumn[0] = gtk.TreeViewColumn(self.column_names[0], cell)        
        self.tvcolumn[0].set_cell_data_func(cell, self.file_name)
        self.treeview.append_column(self.tvcolumn[0])
        for n in range(1, len(self.column_names)):
            cell = gtk.CellRendererText()
            self.tvcolumn[n] = gtk.TreeViewColumn(self.column_names[n], cell)
            if n == 1:
                cell.set_property('xalign', 1.0)
            self.tvcolumn[n].set_cell_data_func(cell, cell_data_funcs[n])
            self.treeview.append_column(self.tvcolumn[n])

        self.treeview.connect('row-activated', self.export_result)

        self.scrolledwindow = gtk.ScrolledWindow()
        self.scrolledwindow.set_border_width(10)
        self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)


        self.scrolledwindow.add(self.treeview)
        self.scrolledwindow.show()
        
 
    def export_result(self, treeview, path, column):
         model = treeview.get_model()
         iter = model.get_iter(path)
         image = model.get_value(iter, 0)
         print image
         ex=export_page(self.Notebook,image,self.wdata.get_bc(image),self.wdata.get_DLR(image).coefficient())
         return



    #def add_files(self,files):
    #    self.files=files
    #    listmodel = self.make_list()
    #    self.treeview.set_model(listmodel)
    #    self.treeview.show()

    def update(self):
        listmodel = self.make_list()
        self.treeview.set_model(listmodel)
        self.treeview.show()

       
    def make_list(self):
        listmodel = gtk.ListStore(object)
        for f in self.wdata.list_images():
            listmodel.append([f])
        return listmodel


    def file_name(self, column, cell, model, iter):
        cell.set_property('text', model.get_value(iter, 0))
        return

    def status(self,column,cell,model,iter):
        image=model.get_value(iter, 0)
        cell.set_property('text', str(self.wdata.get_status(image) ))
        return
        

    def tex_dim(self, column, cell, model, iter):
        try:
            image=model.get_value(iter, 0)
            cell.set_property('text', str(self.wdata.get_text_dim(image)))
        except "NOT_YET_CALCULATED":
            cell.set_property('text', "")            
        return

    def struct_dim(self, column, cell, model, iter):
        try:
            image=model.get_value(iter, 0)
            cell.set_property('text', str(self.wdata.get_struct_dim(image)))
        except "NOT_YET_CALCULATED":
            cell.set_property('text', "")            
        return



    def gtk_ref(self):
        return self.scrolledwindow














class export_page:
    "define the export page"    
    
    def directory_selection(self,widget,output=""):
        filew = gtk.FileSelection("Directory selection")
        filew.connect("destroy", lambda w: filew.destroy())
        filew.ok_button.connect("clicked", self.directory_ok_sel,filew)
        
        filew.cancel_button.connect("clicked", lambda w: filew.destroy())
        filew.set_filename(output)
        
        filew.show()


    def directory_ok_sel(self, widget,filew):
        self.Directory_entry.set_text(filew.get_filename())
        filew.destroy()


    def select_export(self,widget,export):
        if widget.get_active():
            self.Export_list.append(export)
        else:
            self.Export_list.remove(export)


    def export(self,widget):
        self.Exp.set_export_list(self.Export_list)
        self.Exp.set_output_file_name(os.path.join(self.Directory_entry.get_text(), self.File_name_entry.get_text()))
        self.Exp.export()


    def close(self,widget):
        for i in range(1,self.Notebook.get_n_pages()):
            child=self.Notebook.get_nth_page(i)
            if self.Notebook.get_tab_label(child)==widget.get_parent():
                page=i   
        #print page
        self.Notebook.remove_page(page)
        self.Notebook.queue_draw_area(0,0,-1,-1)
        

    def __init__(self,Notebook, image_path,Bc,Coeff):
        self.Notebook=Notebook
        self.Exp=Export()
        self.Exp.set_plot(Bc.plot())
        self.Exp.set_reg(Coeff)
        self.Image_path=image_path
        self.Export_list=[]
        
        Frame_name="Export"
        self.Export_frame = gtk.Frame(Frame_name)

        Export_box=gtk.HBox(homogeneous=False , spacing=10)

        Left_export_box=gtk.VBox(homogeneous=False , spacing=10)
        #begin of definition of inside left_export box
        
        Reminder_frame=gtk.Frame('Reminder')
        Text="File : "+ image_path +"\nMethod : " + Bc.get_method()
        if Bc.get_method()=="exponential":
            Text+="\nPrecison :  "+ str(Bc.get_precision())

        Reminder_label=gtk.Label(Text)
        Reminder_label.show()
        Reminder_frame.add(Reminder_label)
        Reminder_frame.show()
        Left_export_box.pack_start(Reminder_frame,False ,False ,10)

        Text_result_frame=gtk.Frame('Result')
        Text="Textural dimension : "+ str(- self.Exp.Reg[0][0]) +"\nStructural dimension : "+ str(- self.Exp.Reg[1][0])

        Result_label=gtk.Label(Text)
        Result_label.show()
        Text_result_frame.add(Result_label)
        Text_result_frame.show()
        Left_export_box.pack_start(Text_result_frame,False ,False ,10)
        
        Check_frame=gtk.Frame('Export format')
        Check_box=gtk.VBox(homogeneous=False , spacing=10)
        file_list=self.Exp.file_list()
        n=len(file_list)
        i_n=4
        c=0
        while c < n:
            Check_box_h=gtk.HBox(homogeneous=False , spacing=10)
            i=0
            while (i < i_n) and c<n:
                format=file_list[c]
                button = gtk.CheckButton(format)
                button.connect("toggled",  self.select_export, format)
                Check_box_h.pack_start(button, False , False , 10)
                button.show()
                i+=1
                c+=1
            Check_box_h.show()
            Check_box.pack_start(Check_box_h, False , False , 10)

        Check_box.show()
        Check_frame.add(Check_box)
        
        Left_export_box.pack_start(Check_frame,False ,False ,10)
        Check_frame.show()

        File_frame=gtk.Frame('Export file')
        File_box=gtk.VBox(homogeneous=False , spacing=10)
       # choisir le repertoire

        self.Directory_selection_box = gtk.HBox(homogeneous=False , spacing=10)
        
        self.Directory_entry = gtk.Entry()
        self.Directory_entry.set_max_length(70)
        self.Directory_entry.set_text("My_Directory")
        self.Directory_entry.show()
        
        self.Directory_selection_box.pack_start(self.Directory_entry,True,True,10)

        button_browse=gtk.Button()
        button_browse.connect("clicked",self.directory_selection)
        label=gtk.Label("Browse")
        label.show()
        button_browse.add(label)
        button_browse.show()

        self.Directory_selection_box.pack_start(button_browse,False ,False ,10)

        self.Directory_selection_box.show()        

        File_box.pack_start(self.Directory_selection_box,False ,False ,10)
    
       #choisir le nom
        self.File_name_entry = gtk.Entry()
        self.File_name_entry.set_max_length(50)
        self.File_name_entry.set_text("File_name")
        self.File_name_entry.show()

        File_box.pack_start(self.File_name_entry,False ,False ,20)

        File_box.show()
        File_frame.add(File_box)

        File_frame.show()
        Left_export_box.pack_start(File_frame,False ,False ,10)

        Button=gtk.Button()
        Button.connect("clicked",self.export)
        label=gtk.Label("Export")
        label.show()
        Button.add(label)
        Button.show()
        
        Left_export_box.pack_start(Button,False ,False ,10)
        
        #end of definition of inside left_export box
        Left_export_box.show()
        Export_box.pack_start(Left_export_box,False ,False ,10)
        Right_export_box=gtk.HBox(homogeneous=False , spacing=10)

        #begin of definition of inside right_export box

        Frame_interpretation=gtk.Frame('Interpolation Graph')
        
        self.Exp.set_export('png')
        name=os.path.join(TMP_REP,'xfracdim-' +str(os.getpid()))
        self.Exp.set_output_file_name(name) 
        if(self.Exp.check_right()):
            self.Exp.export()
                
        Result_image=gtk.Image()
        Result_image.set_from_file(name+'.png')
        Result_image.show()
        Frame_interpretation.add(Result_image)
        Frame_interpretation.show()
        
        Right_export_box.pack_start(Frame_interpretation,False ,False ,10)
        #end of definition of inside right_export box

        Right_export_box.show()
        Export_box.pack_start(Right_export_box,False ,False ,10)
        Export_box.show()
        self.Export_frame.add(Export_box)
        self.Export_frame.show()

        Label_box=gtk.HBox(homogeneous=False , spacing=10)
        Label=gtk.Label(os.path.basename(self.Image_path))
        Label.show()
        Label_box.pack_start(Label,False ,False ,10)

        Close_button=gtk.Button('X')

        Close_button.connect("clicked",self.close)
        Close_button.set_relief(False )
        Close_button.set_border_width(0)
        Close_button.show()
        
        Label_box.pack_start(Close_button,False ,False ,10)
        Label_box.show()
        
        self.Notebook.append_page(self.Export_frame, Label_box)
                    

class Method:
    """Class to manipulate an object(GTK) to select Method and eventualy precision"""
    
    def __init__(self):
        self.Method_frame=gtk.Frame("Method")
        self.Method_frame.set_border_width(10)
        self.Method_frame.set_size_request(225, 275)


        Method_box = gtk.VBox(False , 3)
        Method_box.set_border_width(3)
        Method_box.show()  

        self.Button_all = gtk.RadioButton(None, "All")
        self.Button_all.connect("toggled", self.private_set_method,"all")
        self.Button_all.set_active(True)
        
        Method_box.pack_start(self.Button_all, False , False , 10)
        self.Button_all.show()

        self.Button_pair = gtk.RadioButton(self.Button_all, "Pair")
        self.Button_pair.connect("toggled", self.private_set_method,"pair")
        self.Button_pair.show()
       
        Method_box.pack_start(self.Button_pair, False , False , 10)
        

        self.Button_exponential = gtk.RadioButton(self.Button_pair, "Exponential")
        self.Button_exponential.connect("toggled", self.private_set_method, "exponential")
        Method_box.pack_start(self.Button_exponential, False , False , 10)
        self.Button_exponential.show()

        self.Precision_box = gtk.HBox(False , 2)
        
        Label = gtk.Label("Precision :")
        Label.show()
        self.Precision_box.pack_start(Label, False , False , 0)
        

        self.Adj = gtk.Adjustment(1.2, 1.001, 2.2, 0.01, 0.1, 0.2)
        
        
        Scale = gtk.HScale(self.Adj)
        Scale.set_digits(3)
        Scale.show()
        self.Precision_box.pack_start(Scale, True, True, 0)
        
        Method_box.pack_start(self.Precision_box,False ,False ,0)

        
        self.Method_frame.add(Method_box)
        
        self.Method_frame.show()


    def private_set_method(self,widget,method):
        if method=='exponential':
            self.Precision_box.show()
        else:
            self.Precision_box.hide()


    def set_method(self,Objet):
        """
        Execute the method set_method et set_precision of objet passed in parameter
        Warning : Deprecated!!!
        Prefere use get_method and get_precision
        """
        print "Warning Use of the Deprecated Method set_method of the class Method"
        
        if self.Button_all.get_active():
            Objet.set_method("all")
        elif self.Button_pair.get_active():
            Objet.set_method("pair")
        elif self.Button_exponential.get_active():
            Objet.set_method("exponential")
            
            Objet.set_precision(self.Adj.get_value())
        else:
            raise "Error : this method doesnt exit"


    def update_method_(self):
        if self.Button_all.get_active():
            self.method_="all"
            self.precision_= None
        elif self.Button_pair.get_active():
            self.method_="pair"
            self.precision_= None
        elif self.Button_exponential.get_active():
            self.method_="exponential"
            self.precision_=self.Adj.get_value()
        else:
            raise "Error : this method doesnt exit"

    def get_method(self):
        self.update_method_()
        return (self.method_,self.precision_)

    def get_object(self):
        return self.Method_frame





def main():
    gtk.main()
    return 0

if __name__ == "__main__":
    Xfrac_dim()
    main()

