# you really want to read the templates.py files before
# hacking this file

from copy import copy
import sys

if not sys.modules.has_key('gtk'):
    import pygtk
    pygtk.require('1.2')

from gtk import *
import GtkExtra
import string
import os

from specific import *
from entry_classes import *
import joins
import log
import checks

################ row widgets


class select_navigate_widget:
    "provides facility for doing a SELECT and for navigating it"

    __cursor=None
    #easy type-in key
    __easyselect_key=None

    #button_next button_prev may be accessed from outside
    def __init__(self):  
        hbox=GtkHBox()
        self.widget=hbox
        self.__widget=hbox
        
        hbox.show()

        prev=GtkButton()
        a=GtkArrow(ARROW_LEFT, SHADOW_OUT)
        a.show()
        prev.add(a)
        prev.show()
        hbox.pack_start(prev, FALSE, FALSE, 2)
        #this may be overridden
        prev.connect("clicked", self.cursor_prev)
        self.button_prev=prev
        
        next=GtkButton()
        a=GtkArrow(ARROW_RIGHT, SHADOW_OUT)
        a.show()
        next.add(a)
        next.show()
        hbox.pack_start(next, FALSE, FALSE, 2)
        #this may be overridden
        next.connect("clicked", self.cursor_next)
        self.button_next=next

        button_=GtkButton("select where")
        button_.show()
        hbox.pack_start(button_, FALSE, FALSE, 2)
        button_.set_flags(CAN_FOCUS)
        self.button_select=button_
        button_.connect("clicked",self.select)
                         
        self.__entry_where=GtkEntry()
        hbox.pack_start(self.__entry_where, TRUE, TRUE, 2)
        self.__entry_where.show()
        self.__entry_where.set_flags(CAN_FOCUS)
        self.__entry_where.connect("activate",self.select)

        l=GtkButton()
        self.__easyselect_button=l
        hbox.pack_start(l,FALSE, FALSE, 2)
        l.show()
        self.__lbes=GtkLabel('')
        self.__lbes.show()
        l.add(self.__lbes)
                
        self.__entry_key=GtkEntry()
        self.__entry_key.connect("activate", self.select)
        #FIXME this is not in 'characters':self.entry_key.set_usize(80,10)
        hbox.pack_start(self.__entry_key,FALSE, FALSE, 2)


        mf = GtkExtra.MenuFactory()        
        z=[('?/-',None,self.easyselect_set,None)]
        for i in self.fields:
            z.append(('?/'+i,None,self.easyselect_set,i))
            if self.field_join.has_key(i) :
                (t2,f2)=self.field_join[i]
                for j in self.field_entry[i].fields :
                    z.append(('?/'+i+'.../'+j,None,
                              self.easyselect_set,t2+'/'+f2+'/'+i+'/'+j))
        mf.add_entries(z)
        mf.show()
        hbox.pack_start(mf,FALSE, FALSE,2)

        l.connect("clicked",self.easyselect_set,None)

    
    def reset(self):
        self.__widget.set_sensitive(TRUE)
        self.__entry_key.set_text('')
        self.__entry_where.set_text('')
        self.easyselect_set(None,None)

    
    def easyselect_get(self):
        "gets easy key"
        #if self.__easyselect_key==None:            
        #    return None
        #else:
        return self.__easyselect_key

    def easyselect_set_text(self,key):
        self.__entry_key.set_text(key)
    
    def easyselect_set(self,button,i):
        "sets easy key"
        try:
            if i != None and type(1) == type(i):
                i=self.fields.index(i)
        except:
            self.log(log.LOG_WARNING, "UNKNOWN RECORD "+str(i))
            return
        self.__easyselect_key=i
        self.__easyselect_button.remove(self.__lbes)
        if i!=None:
            if '/' in self.__easyselect_key:
                a=string.split(self.__easyselect_key,'/')
                l=GtkLabel('&& '+a[0]+'/'+a[3] +" LIKE")
            else:
                l=GtkLabel('&& '+self.__easyselect_key+" LIKE")
            self.__entry_key.show()
            self.__easyselect_button.show()
        else:
            l=GtkLabel("...")
            self.__entry_key.hide()
            self.__easyselect_button.hide()
        self.__lbes=l
        l.show()
        self.__easyselect_button.add(l)
            
    #useful methods to use the cursor in a consistent way

    def select(self,button):
        self.cursor_del()
        #FIXME THIS DOESNT WORK
        #sql="SELECT ("+self.keyfield+", id) FROM " + self.table_name
        sql="SELECT " + self.table_name + ".* FROM " + self.table_name
        
        #if button:
        #    logging=self.log
        #else:
        #    logging=lambda *x: None

        selkey=self.__entry_key.get_text()
        selwhere=self.__entry_where.get_text()
        where=" WHERE "
        if selkey != "" and self.__easyselect_key!=None:
            if '/' in self.__easyselect_key:
                a=string.split(self.__easyselect_key,'/')
                sql=sql +','+a[0]+' '+where+\
                     a[0]+'.'+a[1]+' = '+self.table_name+'.'+a[2]+\
                     ' && '+a[0]+'.'+a[3] + " LIKE '"+selkey+"%' "
                where=' && '
            else:
                sql=sql +where+ self.__easyselect_key + " LIKE '"+selkey+"%' "
                where=' && '
        if selwhere:
            sql=sql +where+ selwhere
            where=' && '
        #if selkey != "" and self.__easyselect_key!=None:
        #    sql=sql+" ORDER BY "+self.fields[self.__easyselect_key]
        result=self.cursor_query(sql)
        if result:
            r=self.cursor_next(None)
            if not r:
                self.log(log.LOG_ERROR,"no matching line for:" +sql)
                self.cursor_del()
            else:
                if button or result == 1:
                    self.log(log.LOG_INFO,"%d matches in %s" %
                             (result,self.table_name))                    
                else:
                    #if this is an automatic search, it should return 1 result
                    self.log(log.LOG_WARNING,"%d matches in %s" %
                             (result,self.table_name))
        else:
            self.log(log.LOG_ERROR,"no matches for:" +sql)
            self.cursor_del()
            
    def has_cursor(self):
        return not not self.__cursor
    
    def cursor_query(self,query):
        #prepares the cursor for a SELECT query
        if self.__cursor:
            del self.__cursor
            
        self.__cursor=self.db.cursor()
        if self.__cursor == None:
            self.log(log.LOG_ERROR, "E: could not get a cursor (please retry)")
            return 0
                   
        self.log(log.LOG_SQL, "SQL :"+query)

        try:            
            self.__cursor.execute(query)
        except self.dbapi_exceptions.Warning, a:
            self.log(log.LOG_WARNING,"WARNING: "+str(a))
            self.__cursor=None
            return 0
        except self.dbapi_exceptions.Error, a:
            self.log(log.LOG_ERROR,"ERROR: "+str(a))
            self.__cursor=None
            return 0
        else:
            self.__cursor.backlist=[]
            self.__cursor.position=-1
            return self.__cursor.rowcount
        
    def cursor_next(self,b):
        if len(self.__cursor.backlist) > self.__cursor.position+1:
            self.__cursor.position = 1 + self.__cursor.position
            r=self.__cursor.backlist[self.__cursor.position]
        else:
            r=self.__cursor.fetchone()
            if r:
               self.__cursor.backlist.append(r)
               self.__cursor.position = 1 + self.__cursor.position
        if r:
            self.set_row(r)
        else:
            #if called from a button...
            if b:
                self.log(log.LOG_MESSAGE,"no more matches")
            self.set_row(None)
            #self.cursor=None
        self.button_next.set_sensitive(not not r)
        self.button_prev.set_sensitive(self.__cursor.position>0)
        #print "NEXT"+str(self.__cursor.position)
        return r

    def cursor_prev(self,b):
        if self.__cursor.position>0:
            self.__cursor.position = self.__cursor.position - 1
        else:        
            self.log(log.LOG_MESSAGE,"already on first row")        
        r=self.__cursor.backlist[self.__cursor.position]
        self.set_row(r)
        self.button_prev.set_sensitive(self.__cursor.position>0)
        self.button_next.set_sensitive(TRUE)
        #print "PREV"+str(self.__cursor.position)
        return r

    def cursor_del(self):
        if self.__cursor:
            del self.__cursor
            self.__cursor=None
        self.button_next.set_sensitive(FALSE)
        self.button_prev.set_sensitive(FALSE)


    
class fast_search_widget(table_info,row_widget_template,
                         select_navigate_widget):
    __row=None
    __popup_window=None
    __primary_value=None
    __n_primary=None
    def __init__(self,db,db_name,table_name,
                 #which field to use to select when doing set() or get()
                 join_field=None ):

        table_info.__init__(self,db,db_name,table_name)        
        row_widget_template.__init__(self)

        if join_field != None:
            self.__n_primary=self.fields.index(join_field)

        select_navigate_widget.__init__(self)
        #save it for future references
        self.select_navigate_thewidget=self.widget


        self.db_name=db_name
        self.table_name=table_name
        self.db=db

        #main widget
        vbox=GtkVBox()

        hbox=GtkHBox()
        hbox.show()

        self.label_current=GtkEntry()
        self.label_current.set_editable(FALSE)
        #self.label_current.set_sensitive(FALSE)
        self.label_current.show()
        #self.label_current.set_justify(JUSTIFY_RIGHT)
        #self.label_current.set_position(0)
        hbox.pack_start(self.label_current, TRUE, TRUE, 2)

        arr=GtkArrow(ARROW_UP, SHADOW_OUT)
        arr.show()
        b=GtkButton()
        b.add(arr)
        b.show()
        #b.add(self.label_current)
        b.connect("pressed",self.__popup)
        b.connect("released",self.__popdown)

        hbox.pack_start(b, FALSE, FALSE, 2)
        
        vbox.pack_start(hbox, TRUE, TRUE, 2)
        
        vbox.pack_start(self.select_navigate_thewidget, FALSE, FALSE, 2)

        vbox.show()
        self.widget=vbox
        self.__widget=vbox

    def __popup(self,b):
        if self.__row==None:
            return
        if not self.__popup_window:    
            f=form_widget(self.db,self.db_name,self.table_name)
            f.set_editable(FALSE)
            self.__popup_form=f
            window1=GtkWindow(WINDOW_POPUP)
            window1.set_policy(FALSE, TRUE, FALSE)
            window1.add(f.widget)
            window1.set_position(WIN_POS_MOUSE)
            self.__popup_window=window1
        self.__popup_window.show()
        self.__popup_form.set_row(self.__row)
        
    def __popdown(self,b):
        if self.__popup_window:
            self.__popup_window.hide()
            
        
    def get(self):
        return self.__primary_value
    
    def set(self,data):
        self.cursor_del()
        #whatever it is... save it!
        self.__primary_value=data
        
        if self.__n_primary == None:
            self.log(log.LOG_ERROR,'INTERNAL ERROR: cant "set" into table ' + self.table_name)
        if data != None:
            sql="SELECT * FROM " + self.table_name +\
                " WHERE " + self.fields[self.__n_primary] +   " = "+str(data)
            cursor=self.db.cursor()
            #self.log(log.LOG_SQL,repr(sql))
            cursor.execute(sql)        
            self.set_row(cursor.fetchone())
            del cursor
        else:
            self.set_row(None)


    def set_row(self,r):
        self.__row=r
        if r != None:
            if self.__n_primary:
                self.__primary_value=r[self.__n_primary]
            self.label_current.set_text(str(r))
            self.label_current.set_position(0)
        else:
            #FIXME: is this the right thing to do?
            self.__primary_value=None
            self.label_current.set_text("NULL")
            select_navigate_widget.reset(self)
            
    def get_row(self):
        return self.__row
    
    def set_editable(self,v):        
        self.select_navigate_thewidget.set_sensitive(v)            
        #self.select_navigate.set_editable(v)




        
class form_widget(table_info,row_widget_template):
    __current_row=None
    
    def __init__(self,db,db_name,table_name,
                 #these are used for automatic joins
                 join_rules=[],table_fields={}):

        table_info.__init__(self,db,db_name,table_name)
        row_widget_template.__init__(self)

        self.__table_name=table_name
        
        frame=GtkFrame(table_name)
        frame.show()

       #export this
        self.widget=frame
        #and keep a copy
        self.__widget=frame
        
        vbox2=GtkVBox()
        vbox2.show()
        
        frame.add(vbox2)

 
        ########fields
        for f in self.fields:
            columninfo=self.field_columninfo[f]
            description=self.field_description[f]
            (Field, Type, Null, Key, Default, Extra) = columninfo

            hbox1=GtkHBox()
            vbox2.pack_start(hbox1, FALSE, TRUE, 0)
            #hbox1.set_usize(-1, -1)
            hbox1.set_homogeneous(FALSE)
            hbox1.set_spacing(0)

            eventbox1=GtkEventBox()
            hbox1.pack_start(eventbox1, FALSE, FALSE, 0)
            #eventbox1.set_usize(-1, -1)
            label1=GtkLabel()
            eventbox1.add(label1)
            tooltip = GtkTooltips();
            tup=''
            lists=map(None,
                      ('Field', 'Type', 'Null', 'Key', 'Default', 'Extra'),
                      columninfo)+\
                      map(None,
                          ('name', 'type_code', 'display_size', 'internal_size', 'precision', 'scale', 'null_ok'),
                          description)
            for (a,b) in lists:
                tup=tup+str(a)+'='+str(b)+'\n'
            tooltip.set_tip(eventbox1,tup)
            eventbox1.show()

            label1.set_justify(JUSTIFY_CENTER)
            label1.set_alignment(0.5, 0.5)
            label1.set_padding(0, 0)
            label1.show()

            join=None
            if join_rules != []:
                join=joins.find_join(self.table_name, Field,
                                     #these are used for automatic joins
                                     join_rules,table_fields)
            if join != None:
                (t2, f2)=join
                #print "join " + repr(join)
                entry1=fast_search_widget(self.db,self.db_name,t2,f2)
                entry1.dbapi_exceptions=self.dbapi_exceptions
                self.field_join[Field]=(t2,f2)
                self.join_field[t2]=Field
                label1.set_text(Field+'=\n='+t2+'.'+f2)
            else:
                label1.set_text(Field)
                entry1=appropriate_entry_widget(columninfo,description)
            #redirect log messages                
            entry1.log=self.log
            hbox1.pack_start(entry1.widget, TRUE, TRUE, 0)
            hbox1.show()
            self.field_entry[Field]=entry1

    #template methods
    def set_editable(self,v):
        for f in self.fields:
            e=self.field_entry[f]
            #print 'self.primary_key_fields'+str(self.primary_key_fields)
            if f in self.primary_key_fields:
                #e.entry_widget
                e.set_editable(FALSE)
            else:
                #e.entry_widget
                e.set_editable(v)
                
    def get_row(self):
        r=[]
        for i in range(self.n_fields):
            entry=self.field_entry[ self.fields[i] ]
            r.append(entry.get())
        return r
    
    def get_current_row(self):
        """this is the row that was set into this class, not the one that the
        user edits"""
        return self.__current_row

    def set_row(self,row):
        if row != None:
            for i in  range(len(row)):
                entry=self.field_entry[ self.fields[i] ]
                entry.set(row[i])
                self.__current_row=copy(row)
        #else:
        #    self.log(1,"Can't set row to None in form for table "+self.__table_name)






class editor_widget(form_widget, select_navigate_widget):
    def __init__(self,db,db_name,table_name,
                 #api
                 dbapi,dbapi_exceptions,
                 #if there is an extra main widget for loggin, we call it with
                 main_log=None,
                 #these are used for automatic joins
                 join_rules=[],table_fields={},
                 #list of functions that will check the row (see checks.py)
                 checks=[checks.extra_spaces,checks.empty_null,
                         checks.not_null_not_empty]):
        
        self.dbapi_exceptions=dbapi_exceptions        
        self.checks=checks

        ###the log widget (it is in log.py)
        #log.log_widget.__init__(self)
        #self.log=logwidget.log
        #use it also for the form widget
        #formwidget.log=logwidget.log
        ##save it for future references
        #
        self.logger=log.log_widget(main_log)
        self.log_thewidget=self.logger.widget
        self.log=self.logger.log
        
        ###the form widget
        form_widget.__init__(self,db,db_name,table_name,
                             #these are used for automatic joins
                             join_rules,table_fields)
        #save it for future references
        formwidget=self.widget

        ### the select navigate widget
        select_navigate_widget.__init__(self)
        #save it for future references
        self.select_navigate_thewidget=self.widget

        
        vbox1=GtkVBox()

        vbox1.set_spacing(2)

        
        #hbox4=GtkHBox()
        handlebox=GtkHandleBox()
        vbox1.pack_start(handlebox, FALSE, FALSE, 2)
        handlebox.show()

        vbox4=GtkVBox()
        handlebox.add(vbox4)
        vbox4.show()

        ### toolbar of buttons
        tb=GtkToolbar()
        tb.show()
        tb.set_space_style(TOOLBAR_SPACE_LINE)
        tb.set_space_size(20)
        
        vbox4.pack_start(tb,FALSE,FALSE,2)



        button_=GtkButton("insert")
        tb.append_widget(button_, "insert the record","")
        button_.show()
        button_.set_flags(CAN_FOCUS)
        self.button_insert=button_
        self.button_insert.connect("clicked",self.insert)
                         
        button_=GtkButton("new")
        button_.show()
        tb.append_widget(button_, "reset and edit","")
        button_.set_flags(CAN_FOCUS)
        self.button_new=button_
        button_.show()                
        self.button_new.connect("clicked",self.new)
                         
        button_=GtkButton("edit")
        button_.show()
        tb.append_widget(button_, "edit this record","")
        button_.set_flags(CAN_FOCUS)
        self.button_edit=button_
        button_.show()                
        self.button_edit.connect("clicked",self.edit)
                         
        button_=GtkButton("update")
        button_.show()
        tb.append_widget(button_, "update the edited record to the new values","")
        button_.set_flags(CAN_FOCUS)
        self.button_update=button_
        self.button_update.connect("clicked",self.update)

        button_=GtkButton("cancel")
        button_.show()
        tb.append_widget(button_, "","")
        button_.set_flags(CAN_FOCUS)
        #button_.show()
        self.button_cancel=button_
        self.button_cancel.connect("clicked",self.cancel)

        tb.append_space()

        button_=GtkButton("delete")
        button_.show()
        tb.append_widget(button_, "","")
        button_.set_flags(CAN_FOCUS)
        #button_.show()
        self.button_delete=button_
        self.button_delete.connect("clicked",self.delete)

        tb.append_space()

        button_=GtkButton("default")
        button_.show()
        tb.append_widget(button_, "sets entry to default values","")
        button_.set_flags(CAN_FOCUS)
        #button_.show()
        self.button_default=button_
        self.button_default.connect("clicked",self.default)

        tb.append_space()

        button_=GtkButton("reset")
        tb.append_widget(button_, "returns this program to the starting state","")
        button_.set_flags(CAN_FOCUS)
        button_.show()
        self.button_reset=button_
        self.button_reset.connect("clicked",self.reset)

        tb.append_space()

        mf = GtkExtra.MenuFactory()
        mf.add_entries([
            ('Form/Save template', None,  self.gtk_form_save),
            ('Form/Load form',       None,         self.gtk_form_load),
            ('Form/Paste form',       None,         self.gtk_form_paste)
            ])
        # activate key bindings ...
        #self.add_accel_group(mf.accelerator)
        #self.mf = mf
        #returnmf
        mf.show()
        tb.append_widget(mf,"","")

        vbox4.pack_start(self.select_navigate_thewidget, FALSE,FALSE, 2)


        ###select stuff
        hbox=GtkHBox()        
        vbox4.pack_start(hbox, FALSE,FALSE, 2)
        hbox.show()

        #so we can show/hide
        self.widget_select=hbox

        #self.button_prev.set_size_request(20,20)
        #self.button_next.set_size_request(20,20)

        #add another callback
        self.button_prev.connect("clicked", self.editable)

        self.button_next.connect("clicked", self.editable)


        vbox1.pack_start(formwidget, TRUE, TRUE, 2)


        #the log widget (it is in log.py)
        vbox1.pack_start(self.log_thewidget, TRUE, TRUE, 2)

        vbox1.show()
        #export this
        self.widget=vbox1
        #and keep a copy
        self.__widget=vbox1

        #bring to initial state
        self.reset(None)

    ##############################
    def gtk_form_save(self,mi=None):
        fname = GtkExtra.file_open_box(modal=FALSE)
        if not fname: return        
        z=open(fname,'w')
        z.write("""################################################
##This form has been automatically generated.
##Lines starting with ## are comments, that are ignored
##Lines starting with the keyword  [[name]]=
##should be filled; you may write a paragraph following the keyword
##Please do not change what is inside the square brackets [[]]
""")
        self.form_save(z,[])
        z.write('[[END]]\n')
        z.close()

    def gtk_form_load(self,mi=None):
        fname = GtkExtra.file_open_box(modal=FALSE)
        if not fname: return        
        z=open(fname)
        self.__gtk_form_load(z)
        z.close()
        
    def gtk_form_paste(self,mi=None):
        #FIXME this is crude 
        t=GtkText()
        t.set_editable(TRUE)
        t.show()
        w=GtkWindow(WINDOW_TOPLEVEL)
        w.show()
        w.add(t)
        while events_pending():
            mainiteration()
        t.paste_clipboard()
        while events_pending() or  t.get_length() == 0 :
            mainiteration()
        ### this blocks
        #(i,o)=os.pipe()
        #z=os.fdopen(i,'r')
        #q=os.fdopen(o,'w')

        n='.sql-editor.stupidfile.'+str(os.getpid())
        q=open(n,'w')
        
        BLOCK_SIZE = 2048
        length = t.get_length()
        pos = 0
        while pos < length:
            buf = t.get_chars(pos,  min(pos+BLOCK_SIZE, length))
            if buf != None:
                q.write(buf)
            pos = pos + BLOCK_SIZE
        q.flush()
        q.close()
	
	z=open(n)
        self.__gtk_form_load(z)
        z.close()
	
        #os.close(i)
        #os.close(o)
	os.remove(n)
	w.destroy()
        while events_pending():
            mainiteration()
    def __DTE(self,DTE,content):
        zz=self.insert_DTE(DTE,string.replace(content,'\t','    '))
        if zz:
            (t,e)=zz
            if self.join_field.has_key(t):
                ff=self.join_field[t]
                hh=self.field_entry[ff]
                if hh.easyselect_get() == None:
                    self.log(log.LOG_VERBOSE,
                             'making '+str(zz)+' your current select key')
                    hh.easyselect_set(None,e)
                if hh.easyselect_get() == e:
                    self.log(log.LOG_VERBOSE,
                             'good '+str(zz)+' is your current select key')
                    hh.easyselect_set_text(string.replace(content[:-1],'\t\n\r','%%%'))
                    hh.select(None)
                else:
                    self.log(log.LOG_VERBOSE,
                             'sorry '+str(zz)+' is not your current select key')
            else:
                self.log(log.LOG_VERBOSE,
                         'sorry '+str(zz)+' is not a join')
    def __gtk_form_load(self,z):
        self.new(None)
        a=1
        DTE=None
        content=''
        while a:
            a=z.readline()
            if a[:5] == '[[END]]':
                break
            if a[:2] == '##':
                continue
            if a[:2] == '[[':
                #check line
                try:
                    l=a.index(']')
                except:
                    self.log(log.LOG_WARNING,  'Malformed form line '+a)
                    continue
                if len(a) <= l or a[l+1] != ']':
                    self.log(log.LOG_WARNING, 'Malformed form line '+a)
                    continue
                #insert this DTE if the next is different
                # otherwise it will join the values
                if DTE and DTE != a[2:l] :
                    zz=self.__DTE(DTE,content)
                    content=''
                DTE=a[2:l]
                a=a[l+2:]
                if a and a[0] == '=':
                    a=a[1:]
                if a and a[0] == ' ':
                    a=a[1:]
                content=content+a
                if content == '\n':
                    content=''
            else:
                content=content+a
        if DTE and content and DTE[:7] != '[[END]]' and DTE != 'END' :
            self.__DTE(DTE,content)
            content=''

    ############################
    def new(self,button):
        self.reset(None)
        self.edit(None)
        
    def edit(self,button):
        self.set_editable(TRUE)
        #we can update iff we have a (reasonable) row to update
        r=self.get_current_row()
        self.button_update.set_sensitive( r and  self.default_row != r)

        self.button_insert.set_sensitive(TRUE)
        self.button_default.set_sensitive(TRUE)
        self.button_cancel.set_sensitive(TRUE)
        
        self.button_delete.set_sensitive(FALSE)
        self.button_next.set_sensitive(FALSE)
        self.button_prev.set_sensitive(FALSE)

        self.button_edit.set_sensitive(FALSE)
        #self.button_select.set_sensitive(FALSE)
        #self.entry_select.set_sensitive(FALSE)
        self.select_navigate_thewidget.set_sensitive(FALSE)
        
    def default(self,button):        
        self.set_row(self.default_row)

    def editable(self,button):
        'can use edit button'
        r=self.get_row()
        if r:
            self.button_edit.set_sensitive(not self.n_primary or
                None != r[self.n_primary])        


    def delete(self,b):
        if len(self.primary_key_fields) != 1:
            self.log(log.LOG_ERROR,'sorry!  a record can be deleted only if the table has an unique primary key')
            return

        sql="DELETE FROM %s WHERE "  % self.table_name
        
        cr=self.get_current_row()

        if cr[self.n_primary] == None:
            self.log(log.LOG_WARNING,'cannot delete a null record')
            return
        
        sql=sql+self.fields[self.n_primary]+ "=%s LIMIT 1"
        longrow=(cr[self.n_primary])
        c=self.db.cursor()
        try:
            self.log(log.LOG_SQL,sql+'\n'+repr(longrow))
            try:
                c.execute(sql, longrow )
            except self.dbapi_exceptions.Warning, b:
                self.log(log.LOG_WARNING,"\nSQL WARNING:"+str(b))
        except self.dbapi_exceptions.Error, b:
            self.log(log.LOG_ERROR,"ERROR: "+str(b))
        else:          
            #self.set_row(r)
            #simple hack to show the new line
            self.reset(None)
            if  c.rowcount == 1:
                self.log(log.LOG_DONE,"delete was succesfull")
                self.reset(None)
            else:
                self.log(log.LOG_ERROR,"delete was done on %s rows" % c.rowcount )
        del c
        
            
    def update(self,b):
        r= self.get_row()
        (r, msgs,msg) = checks.check_list_of_checks(self.checks,self,r)        
        if r == None:
            self.log(log.LOG_ERROR,msg)
            return
        if msg:
            self.log(log.LOG_WARNING,msg)
        
        sql="UPDATE %s SET "  % self.table_name
        for i in range(self.n_fields):
            sql=sql+self.fields[i]+"=%s, "
        sql=sql[:-2]+" WHERE "

        cr=self.get_current_row()
        
        #FIXME: horrible fix for strange "cant update" problem
        if len(self.primary_key_fields)==1:            
            if cr[self.n_primary] == None:
                self.log(log.LOG_WARNING,'cannot update a record when the primary key value is NULL')
                return

            sql=sql+self.fields[self.n_primary]+ "=%s && "
            longrow=tuple(list(r) + [cr[self.n_primary]] )
        else:
            # this should work perfectly... but it does not!
            for i in range(self.n_fields):
                sql=sql+self.fields[i]+ "=%s && "
            longrow=tuple(list(r) + list(cr))
        #remove trailing ' && '
        sql=sql[:-4]
        
        #WHAT THE HELL IS WRONG
        #print "R " + repr (r)
        #print "CR " + repr(cr)
        #print "SQL " + repr(sql)

        self.db.select_db(self.db_name)
        self.db.paramstyle='format'
        c=self.db.cursor()
        try:
            self.log(log.LOG_SQL,sql+'\n'+repr(longrow))
            try:
                c.execute(sql, longrow )
            except self.dbapi_exceptions.Warning, b:
                self.log(log.LOG_WARNING,"\nSQL WARNING:"+str(b))
        except self.dbapi_exceptions.Error, b:
            self.log(log.LOG_ERROR,"ERROR: "+str(b))
        else:          
            self.set_row(r)
            #simple hack to show the new line
            self.cancel(None)
            if  c.rowcount == 1:
                self.log(log.LOG_DONE,"update was succesfull")
            else:
                self.log(log.LOG_ERROR,"update was done on %s rows" % c.rowcount )
        del c
        
    def insert(self,bla):
        r= self.get_row()
        if len(self.primary_key_fields) == 1 and r[self.n_primary] != None \
               and r[self.n_primary] != '':
            self.log(log.LOG_WARNING,'cannot insert a record when the primary key value is not NULL')
            return

        (r, msgs,msg) = checks.check_list_of_checks(self.checks,self,r)
        if r == None:
            self.log(log.LOG_ERROR,msg)
            return
        if msg:
            self.log(log.LOG_WARNING,msg)

        
        self.db.select_db(self.db_name)
        sql= "INSERT INTO " + self.table_name + " VALUES ( " + " %s, " *  (self.n_fields-1) + "%s )"
                
        
        self.db.select_db(self.db_name)
        self.db.paramstyle='format'
        c=self.db.cursor()

        self.log(log.LOG_SQL,sql+'\n'+repr(r))
        try:
            c.execute(sql ,  r)
        except self.dbapi_exceptions.Warning, b:
            self.log(log.LOG_WARNING,"SQL WARNING: " + str(b))
        except self.dbapi_exceptions.Error, b:
            self.log(log.LOG_ERROR,"SQL ERROR: " + str(b))
        else:
            self.log(log.LOG_DONE,"INSERT was succeful")
        del c

    def reset(self, bla):
        self.set_row(self.default_row)

        select_navigate_widget.reset(self)
        #_thewidget.set_sensitive(TRUE)
        
        self.set_editable(FALSE)
        self.cursor_del()

        self.button_prev.set_sensitive(FALSE)
        self.button_next.set_sensitive(FALSE)

        self.button_update.set_sensitive(FALSE)
        self.button_edit.set_sensitive(TRUE)
        self.button_new.set_sensitive(TRUE)
        self.button_insert.set_sensitive(FALSE)
        self.button_delete.set_sensitive(len(self.primary_key_fields) == 1)
        
        self.button_cancel.set_sensitive(FALSE)

        #self.log(0,"TABLE "+self.table_name)


    def cancel(self,button):            
        self.button_next.set_sensitive(self.has_cursor() )
        self.button_prev.set_sensitive(self.has_cursor() )
        self.select_navigate_thewidget.set_sensitive( self.has_cursor() )
        
        self.button_edit.set_sensitive(TRUE)        
        
        self.set_editable(FALSE)
        self.set_row(self.get_current_row())
        self.button_update.set_sensitive(FALSE)
        self.button_insert.set_sensitive(FALSE)
        self.button_cancel.set_sensitive(FALSE)

        


def editor(db, db_name, table_name,
           #api
           dbapi,dbapi_exceptions,
           #extra log
           main_log=None,
           #these are used for automatic joins
           join_rules=[],table_fields={}):
    x=editor_widget(db, db_name, table_name,
                    #api
                    dbapi,dbapi_exceptions,
                    #log
                    main_log,
                    #
                    join_rules, table_fields)

    window1=GtkWindow(WINDOW_TOPLEVEL)
    window1.set_title("sql:/"+db_name+"/"+table_name)
    #window1.set_usize(-1, -1)
    window1.set_policy(FALSE, TRUE, FALSE)
    
    #window1.connect("destroy", close_window, self)
    #window1.GTKPY_MAIN = self
    
    window1.add(x.widget)
    window1.show()
    return window1