# you really want to read the templates.py files before # hacking this file from copy import copy from gtk import * import string 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 #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_, TRUE, TRUE, 2) button_.set_flags(CAN_FOCUS) self.button_select=button_ button_.connect("clicked",self.select) self.entry_key=GtkEntry() if self.n_key!=None: l=GtkLabel(self.fields[self.n_key]+"=") hbox.pack_start(l,FALSE, FALSE, 2) l.show() self.entry_key.connect("changed", self.select) #FIXME this is not in 'characters':self.entry_key.set_usize(80,10) hbox.pack_start(self.entry_key,FALSE, FALSE, 2) self.entry_key.show() l=GtkLabel("&&") hbox.pack_start(l,FALSE, FALSE, 2) l.show() entry=GtkEntry() hbox.pack_start(entry, TRUE, TRUE, 2) entry.show() entry.set_flags(CAN_FOCUS) entry.connect("activate",self.select) self.entry_where=entry #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 * FROM " + self.table_name selkey=self.entry_key.get_text() selwhere=self.entry_where.get_text() if selkey or selwhere: sql=sql+" WHERE " if selkey != "": sql=sql + self.fields[self.n_key] + " LIKE '"+selkey+"%' " if selwhere != "": if selkey != "": sql=sql+" && " sql=sql + selwhere if self.cursor_query(sql): r=self.cursor_next(None) if not r: self.log(1,"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(3, "E: could not get a cursor (please retry)") return FALSE self.log(3, "SQL :"+query) try: self.__cursor.execute(query) except self.dbapi_exceptions.Warning, a: self.log(1,"WARNING: "+str(a)) self.__cursor=None return FALSE except self.dbapi_exceptions.Error, a: self.log(1,"ERROR: "+str(a)) self.__cursor=None return FALSE else: self.__cursor.backlist=[] self.__cursor.position=-1 return TRUE 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(1,"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(1,"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 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) # there is no __init__ #row_widget_template.__init__(self,db,db_name,table_name) 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() self.label_current=GtkLabel() self.label_current.show() b=GtkButton() b.show() b.add(self.label_current) b.connect("pressed",self.__popup) b.connect("released",self.__popdown) vbox.pack_start(b, FALSE, FALSE, 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() if self.n_primary == None: self.log(3,'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() cursor.execute(sql) self.set_row(cursor.fetchone()) del cursor else: self.set_row(None) #whatever it is... save it! self.__primary_value=data def set_row(self,r): self.__row=r if r != None: self.__primary_value=r[self.n_primary] self.label_current.set_text(str(r[self.n_key:])[:60]) else: #FIXME: is this the right thing to do? self.__primary_value=None self.label_current.set_text("NULL") 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={}): self.field_entry={} table_info.__init__(self,db,db_name,table_name) #row_widget_template.__init__(self,db,db_name,table_name) 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(); tooltip.set_tip(eventbox1,repr(columninfo) +"\n" + repr(description )) 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 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] if f == "id": #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(log.log_widget, form_widget, select_navigate_widget): def __init__(self,db,db_name,table_name, #api dbapi,dbapi_exceptions, #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 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 ###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.log_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_, "","") button_.show() button_.set_flags(CAN_FOCUS) self.button_insert=button_ self.button_insert.connect("clicked",self.insert) button_=GtkButton("edit") button_.show() tb.append_widget(button_, "","") 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_, "","") 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("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) 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_usize(20,20) self.button_next.set_usize(20,20) #add another callback self.button_prev.connect("clicked", self.editable) self.button_next.connect("clicked", self.editable) vbox1.pack_start(formwidget, FALSE, FALSE, 2) #the log widget (it is in log.py) vbox1.pack_start(self.log_thewidget, FALSE, FALSE, 2) vbox1.show() #export this self.widget=vbox1 #and keep a copy self.__widget=vbox1 #bring to initial state self.reset(None) ############################ def edit(self,button): self.set_editable(TRUE) if self.has_cursor(): self.button_update.set_sensitive(TRUE) else: self.button_insert.set_sensitive(TRUE) self.button_default.set_sensitive(TRUE) self.button_cancel.set_sensitive(TRUE) 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 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 editable(self,button): r=self.get_row() if r: self.button_edit.set_sensitive(None != r[self.n_primary]) 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(1,msg) return 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: 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)) 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: try: c.execute(sql, longrow ) except self.dbapi_exceptions.Warning, b: msg=msg+"\nSQL WARNING:"+str(b) except self.dbapi_exceptions.Error, b: self.log(1,"ERROR: "+str(b)+msg) else: self.set_row(r) #simple hack to show the new line self.cancel(None) if c.rowcount == 1: self.log(3,msg+"\nupdate was succesfull") else: self.log(3,msg+"\nWARNING update was done on %s rows" % c.rowcount ) del c def insert(self,bla): r= self.get_row() (r, msgs,msg) = checks.check_list_of_checks(self.checks,self,r) if r == None: self.log(1,msg) return 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() try: c.execute(sql , r) except self.dbapi_exceptions.Warning, b: self.log(3,"SQL WARNING: " + str(b)+"\n"+msg) except self.dbapi_exceptions.Error, b: self.log(3,"SQL ERROR: " + str(b)+"\n"+msg) else: self.log(1,"INSERT was succeful\n"+msg) del c def reset(self, bla): self.set_row(self.default_row) self.select_navigate_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_insert.set_sensitive(FALSE) self.button_cancel.set_sensitive(FALSE) self.log(1,"TABLE "+self.table_name) def editor(db, db_name, table_name, #api dbapi,dbapi_exceptions, #these are used for automatic joins join_rules=[],table_fields={}): x=editor_widget(db, db_name, table_name, #api dbapi,dbapi_exceptions, # 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