class TextMode(object):
def quit(self, widget):
self.window = None
del self
def __init__(self, canvas, monitor):
self.canvas = canvas
self.monitor = monitor
#Carrega a interface a partir do arquivo glade
self.gui = gtk.glade.XML('gui/text.glade')
self.window = self.gui.get_widget('mainWindow')
self.filename = None
self.textviewLogoProcedures = self.gui.get_widget('textviewLogoProcedures')
self.textviewByteCodes = self.gui.get_widget('textviewByteCodes')
self.textviewByteCodes.modify_font(pango.FontDescription('monospace').set_size(1252))
# Buffers das caixas de texto
self.LogoProceduresBuffer = gtk.TextBuffer()
self.ByteCodesBuffer = gtk.TextBuffer()
self.textviewLogoProcedures.set_buffer(self.LogoProceduresBuffer)
self.textviewByteCodes.set_buffer(self.ByteCodesBuffer)
self.LogoProceduresBuffer.set_modified(False)
self.radiobuttonDecimal = self.gui.get_widget("radiobuttonDecimal")
self.statusbar = self.gui.get_widget('statusbar')
self.statusbar_cid = self.statusbar.get_context_id(_("Logo Procedures Editor"))
self.reset_default_status()
#Conecta Sinais aos Callbacks:
dic = {"gtk_main_quit" : gtk.main_quit}
self.gui.signal_autoconnect(dic)
self.gui.signal_autoconnect(self)
self.window.connect("destroy", self.quit)
#Exibe toda interface:
self.window.show_all()
################
# When the window is requested to be closed, we need to check if they have
# unsaved work. We use this callback to prompt the user to save their work
# before they exit the application. From the "delete-event" signal, we can
# choose to effectively cancel the close based on the value we return.
def on_mainWindow_delete_event(self, widget, event, data=None):
if self.check_for_save(): self.on_save_menu_item_activate(None, None)
return False # Propogate event
# Called when the user clicks the 'New' menu. We need to prompt for save if
# the file has been modified, and then delete the buffer and clear the
# modified flag.
def on_new_menu_activate(self, menuitem, data=None):
if self.check_for_save(): self.on_save_menu_activate(None, None)
# clear editor for a new file
buff = self.textviewLogoProcedures.get_buffer()
buff.set_text("")
buff.set_modified(False)
self.ByteCodesBuffer.set_text("")
self.filename = None
self.reset_default_status()
# Called when the user clicks the 'Open' menu. We need to prompt for save if
# thefile has been modified, allow the user to choose a file to open, and
# then call load_file() on that file.
def on_open_menu_activate(self, menuitem, data=None):
if self.check_for_save(): self.on_save_menu_activate(None, None)
filename = self.get_open_filename()
if filename: self.load_file(filename)
# Called when the user clicks the 'Save' menu. We need to allow the user to choose
# a file to save if it's an untitled document, and then call write_file() on that
# file.
def on_save_menu_activate(self, menuitem, data=None):
if self.filename == None:
filename = self.get_save_filename()
if filename: self.write_file(filename)
else: self.write_file(None)
# Called when the user clicks the 'Save As' menu. We need to allow the user
# to choose a file to save and then call write_file() on that file.
def on_save_as_menu_activate(self, menuitem, data=None):
filename = self.get_save_filename()
if filename: self.write_file(filename)
# Called when the user clicks the 'Quit' menu. We need to prompt for save if
# the file has been modified and then break out of the GTK+ main loop
def on_quit_menu_activate(self, menuitem, data=None):
if self.check_for_save(): self.on_save_menu_activate(None, None)
self.window.destroy()
# Called when the user clicks the 'Cut' menu.
def on_cut_menu_activate(self, menuitem, data=None):
buff = self.textviewLogoProcedures.get_buffer();
buff.cut_clipboard (gtk.clipboard_get(), True);
# Called when the user clicks the 'Copy' menu.
def on_copy_menu_activate(self, menuitem, data=None):
buff = self.textviewLogoProcedures.get_buffer();
buff.copy_clipboard (gtk.clipboard_get());
# Called when the user clicks the 'Paste' menu.
def on_paste_menu_activate(self, menuitem, data=None):
buff = self.textviewLogoProcedures.get_buffer();
buff.paste_clipboard (gtk.clipboard_get(), None, True);
# Called when the user clicks the 'Delete' menu.
def on_delete_menu_activate(self, menuitem, data=None):
buff = self.textviewLogoProcedures.get_buffer();
buff.delete_selection (False, True);
# We call error_message() any time we want to display an error message to
# the user. It will both show an error dialog and log the error to the
# terminal window.
def error_message(self, message):
# log to terminal window
print message
# create an error message dialog and display modally to the user
dialog = gtk.MessageDialog(None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, message)
dialog.run()
dialog.destroy()
# This function will check to see if the text buffer has been
# modified and prompt the user to save if it has been modified.
def check_for_save (self):
ret = False
buff = self.textviewLogoProcedures.get_buffer()
if buff.get_modified():
# we need to prompt for save
message = _("Do you want to save the changes you have made?")
dialog = gtk.MessageDialog(self.window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO,
message)
dialog.set_title(_("Save?"))
if dialog.run() == gtk.RESPONSE_NO: ret = False
else: ret = True
dialog.destroy()
return ret
def check_for_overwrite (self):
ret = False
buff = self.textviewLogoProcedures.get_buffer()
if buff.get_modified():
# we need to prompt for save
message = _("This file already exists. Want to overwrite?")
dialog = gtk.MessageDialog(self.window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO,
message)
dialog.set_title(_("Overwrite?"))
if dialog.run() == gtk.RESPONSE_NO: ret = False
else: ret = True
dialog.destroy()
return ret
# We call get_open_filename() when we want to get a filename to open from the
# user. It will present the user with a file chooser dialog and return the
# filename or None.
def get_open_filename(self):
filename = None
chooser = gtk.FileChooserDialog(_("Open File..."), self.window,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OPEN, gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.add_pattern("*."+"logo")
filter.set_name(_("project")+" logo")
chooser.add_filter(filter)
try:
os.path.exists(self.filename)
chooser.set_current_folder( os.path.dirname(self.filename) )
except:
home = os.getenv('USERPROFILE') or os.getenv('HOME')
chooser.set_current_folder(home)
response = chooser.run()
if response == gtk.RESPONSE_OK: filename = chooser.get_filename()
chooser.destroy()
return filename
# We call get_save_filename() when we want to get a filename to save from the
# user. It will present the user with a file chooser dialog and return the
# filename or None.
def get_save_filename(self):
filename = None
chooser = gtk.FileChooserDialog(_("Save File..."), self.window,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.add_pattern("*."+"logo")
filter.set_name(_("project")+" logo")
chooser.add_filter(filter)
try:
os.path.exists(self.filename)
chooser.set_current_folder( os.path.dirname(self.filename) )
except:
home = os.getenv('USERPROFILE') or os.getenv('HOME')
chooser.set_current_folder(home)
response = chooser.run()
if response == gtk.RESPONSE_OK: filename = chooser.get_filename()
chooser.destroy()
if os.path.exists(filename):
if self.check_for_overwrite():
return filename
else:
if not '.' in filename:
return filename+".logo"
else:
message = _("The file may not have dot")
self.error_message(message)
# We call load_file() when we have a filename and want to load it into the
# buffer for the GtkTextView. The previous contents are overwritten.
def load_file(self, filename):
# add Loading message to status bar and ensure GUI is current
self.statusbar.push(self.statusbar_cid, _("Loading %s") % filename)
while gtk.events_pending(): gtk.main_iteration()
try:
# get the file contents
fin = open(filename, "r")
text = fin.read()
fin.close()
# disable the text view while loading the buffer with the text
self.textviewLogoProcedures.set_sensitive(False)
buff = self.textviewLogoProcedures.get_buffer()
buff.set_text(text)
buff.set_modified(False)
self.textviewLogoProcedures.set_sensitive(True)
# now we can set the current filename since loading was a success
self.filename = filename
except:
# error loading file, show message to user
self.error_message (_("Could not open file: %s") % filename)
# clear loading status and restore default
self.statusbar.pop(self.statusbar_cid)
self.reset_default_status()
def write_file(self, filename):
# add Saving message to status bar and ensure GUI is current
if filename:
self.statusbar.push(self.statusbar_cid, _("Saving %s") % filename)
else:
self.statusbar.push(self.statusbar_cid, _("Saving %s") % self.filename)
while gtk.events_pending(): gtk.main_iteration()
try:
# disable text view while getting contents of buffer
buff = self.textviewLogoProcedures.get_buffer()
self.textviewLogoProcedures.set_sensitive(False)
text = buff.get_text(buff.get_start_iter(), buff.get_end_iter())
self.textviewLogoProcedures.set_sensitive(True)
buff.set_modified(False)
# set the contents of the file to the text from the buffer
if filename: fout = open(filename, "w")
else: fout = open(self.filename, "w")
fout.write(text)
fout.close()
if filename: self.filename = filename
except:
# error writing file, show message to user
self.error_message (_("Could not save file: %s") % filename)
# clear saving status and restore default
self.statusbar.pop(self.statusbar_cid)
self.reset_default_status()
def reset_default_status(self):
if self.filename:
status = _("File: %s") % os.path.basename(self.filename)
else:
status = _("File:")+"(UNTITLED)"
self.statusbar.pop(self.statusbar_cid)
self.statusbar.push(self.statusbar_cid, status)
##############
def button_get_from_blocks_clicked_cb(self, widget):
if self.LogoProceduresBuffer.get_char_count() > 1:
if message(_("The procedures will be overwritten, are you sure you want to proceed?"), gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO) == gtk.RESPONSE_YES:
self.LogoProceduresBuffer.set_text(self.canvas.get_code())
else:
self.LogoProceduresBuffer.set_text(self.canvas.get_code())
def button_compile_clicked_cb(self, widget):
from pyLogoCompiler.Communication import GoGoComms
if self.monitor:
self.GoGo = self.monitor.GoGo
else:
self.GoGo = GoGoComms()
text = self.LogoProceduresBuffer.get_text(self.LogoProceduresBuffer.get_start_iter(),self.LogoProceduresBuffer.get_end_iter())
result, ERCP = self.GoGo.compile(text)
if result:
byteCodes = self.GoGo.returnByteCode()
if self.radiobuttonDecimal.get_active():
self.ByteCodesBuffer.set_text(str(byteCodes))
else:
temp = []
for x in byteCodes:
temp.append(hex(x))
self.ByteCodesBuffer.set_text(str(temp).upper().replace('X', 'x'))
else:
text = "ERROR->Look for a text containing one of the words: "+ERCP[0]
message(_(text), gtk.MESSAGE_WARNING, gtk.BUTTONS_OK)
return result
def button_download_clicked_cb(self, widget):
if self.button_compile_clicked_cb(widget):
if not self.monitor:
self.GoGo.autoConnect()
self.GoGo.download()
if not self.monitor:
self.GoGo.closePort()
class BoardMonitor(object):
def showDialog(self,text,dialog_type,parent):
dialog = gtk.MessageDialog(parent, gtk.DIALOG_MODAL, dialog_type, gtk.BUTTONS_OK, text)
dialog.run()
dialog.destroy()
def showInfo(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_INFO,parent)
def showWarning(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_WARNING,parent)
def showError(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_ERROR,parent)
def quit(self, widget):
self.window = None
self.GoGo.closePort()
del self
def __init__(self):
#Carrega a interface a partir do arquivo glade
self.gui = gtk.glade.XML('gui/monitor.glade')
self.window = self.gui.get_widget('mainWindow')
self.GoGo = GoGoComms()
self.statusbar=self.gui.get_widget('statusbar')
self.gui.get_widget('statusbarVersion').push(0,'Versão '+VERSION)
self.notebookMain = self.gui.get_widget('notebookMain')
self.liststore=gtk.ListStore(str,str,str) # Name, Unit, #Description
self.sensorsTab = SensorsTab(self.gui, self.statusbar, self.liststore)
self.sensorTypes = self.sensorsTab.sensorTypes
self.consoleTab = ConsoleTab(self.gui, self.GoGo, self.statusbar, self.liststore, self.sensorTypes)
self.uploadTab = UploadTab(self.gui, self.GoGo, self.liststore, self.sensorTypes)
self.notebookMain.set_current_page(0)
self.notebookMain.set_show_tabs(True)
#Conecta Sinais aos Callbacks:
dic = {"gtk_main_quit" : gtk.main_quit}
self.gui.signal_autoconnect(dic)
self.gui.signal_autoconnect(self)
self.window.connect("destroy", self.quit)
#Exibe toda interface:
self.window.show_all()
# Tenta conectar-se à GogoBoard
if self.GoGo.autoConnect():
i = self.GoGo.getPort()
if os.name == 'nt':
self.statusbar.push(0,_("GoGo connected on:")+" COM "+str(i+1)+" "+"port")
else:
self.statusbar.push(0,_("GoGo connected on:")+" /dev/ttyS"+str(i)+" "+"port")
else:
print "Gogo not found"
self.showWarning(_("There was a problem with the connection\nVerify that the board is properly connected with your computer"))
self.window.destroy()
return
### Main Window Callbacks:
def imagemenuitemAbout_activate_cb(self,widget):
about = gtk.AboutDialog()
about.set_name(NAME)
about.set_version(VERSION)
#about.set_copyright(copyright)
#about.set_comments(comments)
#about.set_license(license)
#about.set_wrap_license(license)
#about.set_website(website)
#about.set_website_label(website_label)
about.set_authors(AUTHORS)
#about.set_documenters(documenters)
#about.set_artists(artists)
#about.set_translator_credits(translator_credits)
#about.set_logo(gtk.gdk.pixbuf_new_from_file("gui/gogo.png"))
about.set_logo(self.gui.get_widget('imageMonitor').get_pixbuf())
#about.set_logo_icon_name(icon_name)
about.run()
about.destroy()
def imagemenuitemHelp_activate_cb(self,widget):
pass
### Board Console Callbacks:
def buttonBeep_clicked_cb(self, widget):
self.consoleTab.buttonBeep_clicked_cb(widget)
def buttonLedOn_clicked_cb(self, widget):
self.consoleTab.buttonLedOn_clicked_cb(widget)
def buttonLedOff_clicked_cb(self, widget):
self.consoleTab.buttonLedOff_clicked_cb(widget)
# def buttonRun_clicked_cb(self, widget):
# self.consoleTab.buttonRun_clicked_cb(widget)
def checkbuttonMotor_toggled_cb(self,widget):
self.consoleTab.checkbuttonMotor_toggled_cb(widget)
def buttonMotorControlOn_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlOn_clicked_cb(widget)
def buttonMotorControlOff_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlOff_clicked_cb(widget)
def buttonMotorControlBreak_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlBreak_clicked_cb(widget)
def buttonMotorControlCoast_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlCoast_clicked_cb(widget)
def buttonPowerSet_clicked_cb(self, widget):
self.consoleTab.buttonPowerSet_clicked_cb(widget)
def buttonMotorControlThisway_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlThisway_clicked_cb(widget)
def buttonMotorControlThatway_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlThatway_clicked_cb(widget)
def buttonMotorControlReverse_clicked_cb(self, widget):
self.consoleTab.buttonMotorControlReverse_clicked_cb(widget)
# def entryMinPwmDuty_changed_cb(self,widget):
# print "entryMinPwmDuty_changed_cb"
# #self.consoleTab.entryMaxPwmDuty_changed_cb(widget)
# def entryMaxPwmDuty_changed_cb(self,widget):
# print "entryMaxPwmDuty_changed_cb"
# #self.consoleTab.entryMaxPwmDuty_changed_cb(widget)
def entryMinPwmDuty_changed_cb(self,widget):
self.consoleTab.entryMinPwmDuty_changed_cb(widget)
def entryMaxPwmDuty_changed_cb(self,widget):
self.consoleTab.entryMaxPwmDuty_changed_cb(widget)
def buttonSetPwmDuty_clicked_cb(self,widget):
print "buttonSetPwmDuty_clicked_cb"
self.consoleTab.buttonSetPwmDuty_clicked_cb(widget)
def buttonRefreshAll_clicked_cb(self,widget):
self.consoleTab.buttonRefreshAll_clicked_cb(widget)
def buttonSensorBurstOn_clicked_cb(self,widget):
self.consoleTab.buttonSensorBurstOn_clicked_cb(widget)
def radiobuttonBurstFast_toggled_cb(self,widget):
self.consoleTab.radiobuttonBurstFast_toggled_cb(widget)
def radiobuttonBurstSlow_toggled_cb(self,widget):
self.consoleTab.radiobuttonBurstSlow_toggled_cb(widget)
def buttonSensorBurstOff_clicked_cb(self,widget):
self.consoleTab.buttonSensorBurstOff_clicked_cb(widget)
### /Board Console
### Upload Data Callbacks:
def buttonStartUpload_clicked_cb(self,widget):
self.uploadTab.buttonStartUpload_clicked_cb(widget)
def buttonSaveData_clicked_cb(self,widget):
self.uploadTab.buttonSaveData_clicked_cb(widget)
def buttonClearData_clicked_cb(self,widget):
self.uploadTab.buttonClearData_clicked_cb(widget)
def spinbuttonColumns_changed_cb(self,widget):
self.uploadTab.spinbuttonColumns_changed_cb(widget)
def colSpec_changed_cb(self,widget):
self.uploadTab.colSpec_changed_cb(widget)
def checkbuttonShowHeaders_toggled_cb(self,widget):
self.uploadTab.checkbuttonShowHeaders_toggled_cb(widget)
def checkbuttonTwoLineHeader_toggled_cb(self,widget):
self.uploadTab.checkbuttonTwoLineHeader_toggled_cb(widget)
def notebookDataView_switch_page_cb(self,widget,page,page_num):
self.uploadTab.notebookDataView_switch_page_cb(widget,page,page_num)
### /Recorded Data
### SensorLab Callbacks:
def sensorPoint_edited_cb(self,cell, path, new_text, column):
self.sensorsTab.sensorPoint_edited_cb(cell, path, new_text, column)
def treeviewSensors_edited_cb(self,cell, path, new_text, column):
self.sensorsTab.edited_cb(cell, path, new_text, column)
def treeviewSensors_cursor_changed_cb(self,treeviewSensors):
self.sensorsTab.treeviewSensors_cursor_changed_cb(treeviewSensors)
def buttonAddSensor_clicked_cb(self,widget):
self.sensorsTab.buttonAddSensor_clicked_cb(widget)
def buttonRemoveSensor_clicked_cb(self,widget):
self.sensorsTab.buttonRemoveSensor_clicked_cb(widget)
def buttonImportSensors_clicked_cb(self,widget):
self.sensorsTab.buttonImportSensors_clicked_cb(widget)
def buttonExportSensors_clicked_cb(self,widget):
self.sensorsTab.buttonExportSensors_clicked_cb(widget)
def buttonExportSensorsCSV_clicked_cb(self,widget):
self.sensorsTab.buttonExportSensorsCSV_clicked_cb(widget)
def buttonInsertPoint_clicked_cb(self,widget):
self.sensorsTab.buttonInsertPoint_clicked_cb(widget)
def buttonRemovePoint_clicked_cb(self,widget):
self.sensorsTab.buttonRemovePoint_clicked_cb(widget)
class TextMode(object):
def showDialog(self,text,dialog_type,parent):
dialog = gtk.MessageDialog(parent, gtk.DIALOG_MODAL, dialog_type, gtk.BUTTONS_OK, text)
dialog.run()
dialog.destroy()
def showInfo(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_INFO,parent)
def showWarning(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_WARNING,parent)
def showError(self,text,parent=None):
self.showDialog(text,gtk.MESSAGE_ERROR,parent)
def quit(self, widget):
self.window = None
self.GoGo.closePort()
del self
def __init__(self):
#Carrega a interface a partir do arquivo glade
self.gui = gtk.glade.XML('gui/text.glade')
self.window = self.gui.get_widget('mainWindow')
self.GoGo = GoGoComms()
self.statusbar=self.gui.get_widget('statusbar')
self.gui.get_widget('statusbarVersion').push(0,'Versão '+VERSION)
self.notebookMain = self.gui.get_widget('notebookMain')
self.liststore=gtk.ListStore(str,str,str) # Name, Unit, #Description
self.sensorsTab = SensorsTab(self.gui, self.liststore)
self.sensorTypes = self.sensorsTab.sensorTypes
self.proceduresTab = ProceduresTab(self.gui, self.GoGo)
self.consoleTab = ConsoleTab(self.gui, self.GoGo, self.statusbar, self.liststore, self.sensorTypes)
self.uploadTab = UploadTab(self.gui, self.GoGo, self.liststore, self.sensorTypes)
self.notebookMain.set_current_page(0)
self.notebookMain.set_show_tabs(True)
#Conecta Sinais aos Callbacks:
dic = {"gtk_main_quit" : gtk.main_quit}
self.gui.signal_autoconnect(dic)
self.gui.signal_autoconnect(self)
self.window.connect("destroy", self.quit)
#Exibe toda interface:
self.window.show_all()
# Tenta conectar-se à GogoBoard
if self.GoGo.autoConnect():
i = self.GoGo.getPort()
if os.name == 'nt':
self.statusbar.push(0,"Gogo connected on"+" COM "+str(i+1)+" "+"port")
else:
self.statusbar.push(0,"Gogo connected on"+" /dev/ttyS"+str(i)+" "+"port")
else:
print "Gogo not found"
self.showWarning("There was a problem with the connection\nVerify that the board is properly connected with your computer")
self.window.destroy()
return
def __init__(self):
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_size_request(600, 600)
window.connect("destroy", self.close_application)
window.set_title("PyCricketLogo")
window.set_border_width(10)
box1 = gtk.VBox(False, 0)
window.add(box1)
box1.show()
label = gtk.Label("Codigo")
label.set_alignment(0, 0)
box1.pack_start(label, False, False, 0)
label.show()
box2 = gtk.VBox(False, 0)
box2.set_border_width(10)
box1.pack_start(box2, True, True, 0)
box2.show()
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
textview = gtk.TextView()
textbuffer = textview.get_buffer()
sw.add(textview)
sw.show()
textview.show()
box2.pack_start(sw)
# Load the file textview-basic.py into the text window
#infile = open("editor.py", "r")
#if infile:
# string = infile.read()
# infile.close()
# textbuffer.set_text(string)
separator2 = gtk.HSeparator()
box1.pack_start(separator2, False, True, 0)
separator2.show()
label2 = gtk.Label("Resultado")
label2.set_alignment(0, 0)
box1.pack_start(label2, False, False, 0)
label2.show()
box3 = gtk.HBox(False, 20)
box3.set_border_width(10)
box1.pack_start(box3, True, True, 0)
box3.show()
sw2 = gtk.ScrolledWindow()
sw2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
textview2 = gtk.TextView()
textbuffer2 = textview2.get_buffer()
sw2.add(textview2)
sw2.show()
textview2.show()
box3.pack_start(sw2)
separator = gtk.HSeparator()
box1.pack_start(separator, False, True, 0)
separator.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
box1.pack_start(box2, False, True, 0)
box2.show()
button = gtk.Button("Compilar")
button.connect("clicked", self.compilar, textbuffer, textbuffer2)
box2.pack_start(button, True, True, 0)
button.show()
button1 = gtk.Button("Enviar")
button1.connect("clicked", self.enviarGogo, textbuffer, textbuffer2)
box2.pack_start(button1, True, True, 0)
button1.show()
button2 = gtk.Button("Fechar")
button2.connect("clicked", self.close_application)
box2.pack_start(button2, True, True, 0)
button2.set_flags(gtk.CAN_DEFAULT)
button2.grab_default()
button2.show()
window.show()
def toggle_editable(self, checkbutton, textview):
textview.set_editable(checkbutton.get_active())
def toggle_cursor_visible(self, checkbutton, textview):
textview.set_cursor_visible(checkbutton.get_active())
def toggle_left_margin(self, checkbutton, textview):
if checkbutton.get_active():
textview.set_left_margin(50)
else:
textview.set_left_margin(0)
def toggle_right_margin(self, checkbutton, textview):
if checkbutton.get_active():
textview.set_right_margin(50)
else:
textview.set_right_margin(0)
def new_wrap_mode(self, radiobutton, textview, val):
if radiobutton.get_active():
textview.set_wrap_mode(val)
def new_justification(self, radiobutton, textview, val):
if radiobutton.get_active():
textview.set_justification(val)
def close_application(self, widget):
gtk.main_quit()
def compilar(self, widget, textbuffer, textbuffer2):
compilado = '%s ' % self.ler_token(widget, textbuffer, textbuffer2)
if len(compilado) <= 5 :
global ERCP
#print "CCCCCCCCCCCCCCCCOMPILOU COM ERRRO ?"
textbuffer2.set_text("ERROR->Look for a text containing one of the words: " + ERCP[0] )
#print "????????erroCOMP"
#print ERCP[0]
#print "????????ERCP"
else :
textbuffer2.set_text(compilado)
def enviarGogo(self, widget, textbuffer, textbuffer2):
codigo = self.ler_token(widget, textbuffer, textbuffer2)
c = pyCricketComunic.Comunic(0)
result = c.enviar(codigo)
c.fechaPorta()
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO,
gtk.BUTTONS_NONE, result)
dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
dialog.run()
dialog.destroy()
def ler_token(self, widget, textbuffer, textbuffer2):
global ERCP
start = textbuffer.get_start_iter()
end = textbuffer.get_end_iter()
texto = pyYacc.analisarCodigo(textbuffer.get_text(start, end),ERCP)
print "ERCP", ERCP[0]
return texto
#for i in texto:
# armazena = armazena + str(i) + '\n'
class Main( object ):
"""
Classe principal
"""
def __init__(self):
#----------------
#atributos
#----------------
self.maxblockwidth = 0 # Tamanho horizontal do bloco mais largo
self.project = None # Nome do projeto atual aberto
self.menu = {} # Contém os tipos de blocos
self.monitor = None
self.textmode = None
self.codegui = None
self.load_widgets()
self.generate_blocklist()
self.get_lastproject()
#Conecta Sinais aos Callbacks:
dic = {"gtk_main_quit" : self.quit}
self.maingui.signal_autoconnect(dic)
self.mainwindow.connect("delete-event", self.close)
def quit_by_menu(self,widget):
val=self.close(self,widget)
if not val :
self.quit(self)
def close(self,widget,event = None):
def showdialog(text, type):
dialog = gtk.MessageDialog(None, gtk.DIALOG_NO_SEPARATOR, type, gtk.BUTTONS_NONE, text)
button_ok = dialog.add_button("OK",gtk.RESPONSE_OK)
button_save = dialog.add_button("Save",gtk.RESPONSE_YES)
button_cancel = dialog.add_button("Cancel",gtk.RESPONSE_CLOSE)
value = dialog.run()
dialog.hide()
return value
if not self.canvas.is_saved(): #o metodo is_saved() mostra se houve alguma alteração no programa.
text = _("There are unsaved alterations in your project, press OK to close without saving, Save to save and close, or Cancel.")
response = showdialog(text, gtk.DIALOG_DESTROY_WITH_PARENT)
if response == gtk.RESPONSE_OK:
return False
elif response == gtk.RESPONSE_CLOSE:
return True
elif response == gtk.RESPONSE_YES:
self.save_proj(self)
return False
def quit(self, widget):
"""
Sai do programa
"""
gtk.main_quit()
#salva o projeto atual para
#abrir na próxima execução
f = open("user.dat","w")
f.write(self.project)
f.close()
def get_lastproject(self):
"""
lê qual foi o último projeto e abre
"""
try:
if os.path.exists("user.dat"):
f = open("user.dat","r+")
else:
f = open("user.dat","w+")
except:
self.set_project("")
return
projectfile = f.read()
print projectfile
if os.path.exists(projectfile):
self.canvas.load_proj(projectfile)
self.set_project(projectfile)
else:
self.set_project("")
f.close()
def set_project(self, name):
self.project = name
if self.project != "":
self.mainwindow.set_title(self.project+" - "+NAME)
else:
self.mainwindow.set_title(_("<no title project>")+" - "+NAME)
def hide_generatedCode(self, widget):
self.wincode.destroy()
self.codegui = None
def show_generatedCode(self, widget):
"""
mostra uma janela com o código gerado pelos blocos
"""
if self.codegui:
self.wincode.present()
else:
self.codegui = gtk.glade.XML(config.glade_dir+"code.glade" )
self.wincode = self.codegui.get_widget("winCode")
exitbutton = self.codegui.get_widget("btnExit")
exitbutton.connect("clicked", self.hide_generatedCode)
txtcode = self.codegui.get_widget("txtCode")
self.wincode.set_title(_("Code"))
txtbuffer = gtk.TextBuffer()
txtbuffer.set_text(self.canvas.get_code())
txtcode.set_buffer(txtbuffer)
self.wincode.show_all()
def close_monitor(self, widget):
self.monitor = None
if self.textmode:
self.textmode.monitor = None
def show_monitor(self, widget):
from monitor import BoardMonitor
if self.monitor:
self.monitor.window.present()
else:
self.monitor = BoardMonitor()
if self.monitor.window:
self.monitor.window.connect("destroy", self.close_monitor)
else:
self.monitor = None
if self.textmode:
self.textmode.monitor = self.monitor
def close_textmode(self, widget):
self.textmode = None
def show_textmode(self, widget):
if self.textmode:
self.textmode.window.present()
else:
from textmode import TextMode
self.textmode = TextMode(self.canvas, self.monitor)
if self.textmode.window:
self.textmode.window.connect("destroy", self.close_textmode)
else:
self.textmode = None
def about(self, *args):
"""
Mostra uma janela com informações sobre o programa
"""
aboutgui = gtk.AboutDialog()
aboutgui.set_name(NAME)
aboutgui.set_version(VERSION)
#aboutgui.set_copyright(copyright)
#aboutgui.set_comments(comments)
#aboutgui.set_license(license)
#aboutgui.set_wrap_license(license)
#aboutgui.set_website(website)
#aboutgui.set_website_label(website_label)
aboutgui.set_authors(AUTHORS)
#aboutgui.set_documenters(documenters)
#aboutgui.set_artists(artists)
#aboutgui.set_translator_credits(translator_credits)
aboutgui.set_logo(gtk.gdk.pixbuf_new_from_file("gui/splash.png"))
#aboutgui.set_logo(self.gui.get_widget('imageMonitor').get_pixbuf())
#aboutgui.set_logo_icon_name(icon_name)
aboutgui.run()
aboutgui.destroy()
def help(self, *args):
import webbrowser
webbrowser.open('http://br-gogo.sourceforge.net/')
def load_widgets(self):
def undo(*args):
self.canvas.undo()
"""
Carrega e configura a maioria dos widgets do programa
"""
#janela principal
self.maingui = gtk.glade.XML(config.glade_dir+"main.glade" )
self.mainwindow = self.maingui.get_widget( "mainwindow" )
self.mainwindow.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.mainwindow.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.mainwindow.connect("destroy", self.quit)
self.maingui.get_widget( "statusbarVersion" ).push(0,_("Version")+' '+VERSION)
#self.mainwindow.maximize()
#labels das tabs de seleção de blocos
label = [None]*8
label[0] = self.maingui.get_widget( "lblControl" )
label[1] = self.maingui.get_widget( "lblFlow" )
label[2] = self.maingui.get_widget( "lblCondition" )
label[3] = self.maingui.get_widget( "lblNumbers" )
label[4] = self.maingui.get_widget( "lblTime" )
label[5] = self.maingui.get_widget( "lblOthers" )
label[6] = self.maingui.get_widget( "lblProcedure" )
label[7] = self.maingui.get_widget( "lblDisp" )
map(lambda lbl: lbl.modify_font(pango.FontDescription("sans 13")), label)
#em cada tab existe uma tree com seus respectivos blocos
self.tree = [None]*8
self.tree[0] = self.maingui.get_widget("treecontrol")
self.tree[1] = self.maingui.get_widget("treecond")
self.tree[2] = self.maingui.get_widget("treeflow")
self.tree[3] = self.maingui.get_widget("treenumbers")
self.tree[4] = self.maingui.get_widget("treetime")
self.tree[5] = self.maingui.get_widget("treeothers")
self.tree[6] = self.maingui.get_widget("treeproc")
self.tree[7] = self.maingui.get_widget("treedisp")
#cria a treelist e a treefilter associada a cada tree
self.treeList = [None]*8
self.treeList = map( lambda i: gtk.TreeStore(gtk.gdk.Pixbuf), self.treeList )
self.treeFilter = [None]*8
self.treeFilter = map( lambda list: list.filter_new(), self.treeList )
for i in xrange( len(self.tree) ):
self.tree[i].set_model( self.treeFilter[i] )
self.tree[i].get_selection().set_mode(gtk.SELECTION_SINGLE)
column = gtk.TreeViewColumn(_("Tools"), gtk.CellRendererPixbuf() , pixbuf=0)
self.tree[i].append_column(column)
self.tree[i].connect("cursor-changed", self.treeblock_select, self.treeList[i] )
self.downbutton = self.maingui.get_widget("downloadbutton")
self.downbutton.connect("clicked", self.download)
#Nesse box serão colocadas as propriedades dos blocos
self.PropBox = self.maingui.get_widget("BoxProperties")
self.scrollCanvas = self.maingui.get_widget("scrollCanvas")
self.canvas = Canvas(self.PropBox)
self.scrollCanvas.add(self.canvas)
self.menu_new = self.maingui.get_widget("menu_new")
self.menu_new.connect("activate", self.new_proj)
self.button_new = self.maingui.get_widget("button_new")
self.button_new.connect("clicked", self.new_proj)
self.menu_quit = self.maingui.get_widget("menu_quit")
self.menu_quit.connect("activate", self.quit_by_menu)
self.menu_save = self.maingui.get_widget("menu_save")
self.menu_save.connect("activate", self.save_proj)
self.button_save = self.maingui.get_widget("button_save")
self.button_save.connect("clicked", self.save_proj)
self.menu_saveas = self.maingui.get_widget("menu_saveas")
self.menu_saveas.connect("activate", self.saveas_proj)
self.menu_load = self.maingui.get_widget("menu_load")
self.menu_load.connect("activate", self.load_proj)
self.button_load = self.maingui.get_widget("button_load")
self.button_load.connect("clicked", self.load_proj)
self.menu_code = self.maingui.get_widget("menu_code")
self.menu_code.connect("activate", self.show_generatedCode)
self.button_code = self.maingui.get_widget("button_code")
self.button_code.connect("clicked", self.show_generatedCode)
self.menu_monitor = self.maingui.get_widget("menu_monitor")
self.menu_monitor.connect("activate", self.show_monitor)
self.button_monitor = self.maingui.get_widget("button_monitor")
self.button_monitor.connect("clicked", self.show_monitor)
self.button_textmode = self.maingui.get_widget("button_textmode")
self.button_textmode.connect("clicked", self.show_textmode)
self.menu_cut = self.maingui.get_widget("menu_cut")
self.menu_cut.connect("activate", self.cut)
self.menu_copy = self.maingui.get_widget("menu_copy")
self.menu_copy.connect("activate", self.copy)
self.menu_paste = self.maingui.get_widget("menu_paste")
self.menu_paste.connect("activate", self.paste)
self.menu_clear = self.maingui.get_widget("menu_clear")
self.menu_clear.connect("activate", self.clear)
self.menu_about = self.maingui.get_widget("menu_about")
self.menu_about.connect("activate", self.about)
self.menu_about = self.maingui.get_widget("menu_help")
self.menu_about.connect("activate", self.help)
self.menu_undo = self.maingui.get_widget("menu_undo")
self.menu_undo.connect("activate", undo)
self.mainwindow.show_all()
self.movebar1 = self.maingui.get_widget("movebar1")
self.movebar2 = self.maingui.get_widget("movebar2")
def download(self, widget):
"""
Envia o código gerado para a gogoBoard
"""
from pyLogoCompiler import pyYacc
from pyLogoCompiler.Communication import GoGoComms
def showdialog(text, type):
dialog = gtk.MessageDialog(None, gtk.DIALOG_NO_SEPARATOR, type, gtk.BUTTONS_NONE, text)
#dialog.add_button("OK",gtk.RESPONSE_CLOSE)
dialog.show()
#dialog.destroy()
v = self.canvas.code_ok()
if v == 0:
if self.monitor:
self.GoGo = self.monitor.GoGo
else:
self.GoGo = GoGoComms()
self.GoGo.autoConnect()
if self.GoGo.compile(self.canvas.get_code()):
self.GoGo.download()
if not self.monitor:
self.GoGo.closePort()
else:
if self.GoGo.returnByteCode() == None:
showdialog(_("Empty program."), gtk.MESSAGE_WARNING)
else:
showdialog(_("There was a problem with the connection\nVerify that the board is properly connected with your computer"), gtk.MESSAGE_ERROR)
self.GoGo.closePort()
return
showdialog(_("Code successfully sent!\nClick the 'x' above to close"),gtk.MESSAGE_INFO)
elif v == 1:
showdialog(_("Some connections are missing in selected blocks"),gtk.MESSAGE_WARNING)
elif v == 2:
showdialog(_("Set Variable block only accepts variables"),gtk.MESSAGE_WARNING)
def cut(self, *args):
"""
Evento de recortar blocos
"""
self.canvas.cut()
def copy(self, *args):
"""
Evento de copiar blocos
"""
self.canvas.copy()
def paste(self, *args):
"""
Evento de colar blocos
"""
self.canvas.paste()
def clear(self, *args):
"""
Apaga todos os blocos da tela
"""
self.canvas.clear()
def add_block_tree(self, treelist, node, block):
"""
Adiciona um ícone de bloco em uma treeview
"""
pixbuf = block.get_menu_image()
iter = treelist.append( node, [pixbuf,] )
#Assim através de onde o mouse clicou
#e de que lista está sendo usada, temos
#o tipo de bloco que deve ser criado
self.menu[(treelist, iter)] = block
#atualiza a máxima largura de bloco
if block.get_width() > self.maxblockwidth:
self.maxblockwidth = block.get_width()
return iter
def del_block_tree(self, treelist, node):
"""
Remove um ícone de bloco em uma treeview
"""
treelist.remove( node )
del self.menu[(treelist,node)]
def generate_blocklist(self):
"""
Cria árvores com listas de tipos de blocos
para criar blocos do respectivo tipo
"""
#newprocedure_block precisa saber qual é a
#sua árvore, pois ele vai adicionar um ícone
#para cada procedimento novo
newprocedure_block.set_tree( self.treeList[6], self.add_block_tree, self.del_block_tree )
#controle
self.add_block_tree( self.treeList[0], None, on_block() )
self.add_block_tree( self.treeList[0], None, off_block() )
self.add_block_tree( self.treeList[0], None, brake_block() )
self.add_block_tree( self.treeList[0], None, thisway_block() )
self.add_block_tree( self.treeList[0], None, thatway_block() )
self.add_block_tree( self.treeList[0], None, reverse_block() )
self.add_block_tree( self.treeList[0], None, onfor_block() )
self.add_block_tree( self.treeList[0], None, setpower_block() )
self.add_block_tree( self.treeList[0], None, setposition_block() )
#fluxo
self.add_block_tree( self.treeList[2], None, if_block() )
self.add_block_tree( self.treeList[2], None, ifelse_block() )
self.add_block_tree( self.treeList[2], None, loop_block() )
self.add_block_tree( self.treeList[2], None, repeat_block() )
self.add_block_tree( self.treeList[2], None, wait_until_block() )
self.add_block_tree( self.treeList[2], None, stop_block() )
self.add_block_tree( self.treeList[2], None, while_block() )
#comparação
self.add_block_tree( self.treeList[1], None, comp_block() )
self.add_block_tree( self.treeList[1], None, and_block() )
self.add_block_tree( self.treeList[1], None, or_block() )
self.add_block_tree( self.treeList[1], None, xor_block() )
self.add_block_tree( self.treeList[1], None, not_block() )
self.add_block_tree( self.treeList[1], None, switch_block() )
#números
self.add_block_tree( self.treeList[3], None, number_block() )
self.add_block_tree( self.treeList[3], None, random_block() )
self.add_block_tree( self.treeList[3], None, sensor_block() )
self.add_block_tree( self.treeList[3], None, variable_block() )
self.add_block_tree( self.treeList[3], None, set_variable_block() )
self.add_block_tree( self.treeList[3], None, op_add_block() )
self.add_block_tree( self.treeList[3], None, op_sub_block() )
self.add_block_tree( self.treeList[3], None, op_mul_block() )
self.add_block_tree( self.treeList[3], None, op_div_block() )
self.add_block_tree( self.treeList[3], None, op_mod_block() )
#outros
self.add_block_tree( self.treeList[5], None, beep_block() )
self.add_block_tree( self.treeList[5], None, comm_block() )
self.add_block_tree( self.treeList[5], None, ledon_block() )
self.add_block_tree( self.treeList[5], None, ledoff_block() )
self.add_block_tree( self.treeList[5], None, show_block() )
self.add_block_tree( self.treeList[5], None, send_block() )
self.add_block_tree( self.treeList[5], None, recall_block() )
self.add_block_tree( self.treeList[5], None, record_block() )
self.add_block_tree( self.treeList[5], None, resetdp_block() )
#tempo
self.add_block_tree( self.treeList[4], None, time_block() )
self.add_block_tree( self.treeList[4], None, wait_block() )
self.add_block_tree( self.treeList[4], None, resett_block() )
self.add_block_tree( self.treeList[4], None, timer_block() )
#procedimentos
self.add_block_tree( self.treeList[6], None, newprocedure_block() )
self.add_block_tree( self.treeList[6], None, endprocedure_block() )
#disposicao
self.add_block_tree( self.treeList[7], None, null_block() )
self.add_block_tree( self.treeList[7], None, null2_block() )
self.add_block_tree( self.treeList[7], None, null3_block() )
#Posiciona as barras de acordo com o maior largura de bloco
self.movebar1.set_position(self.maxblockwidth+100)
self.movebar2.set_position(gtk.gdk.screen_width()*1/3-self.maxblockwidth+100)
#self.canvas.set_size_request( gtk.gdk.screen_width()*2/3 - (self.maxblockwidth+100), 0 )
def treeblock_select(self, tree, treelist):
"""
Verifica qual é o tipo de bloco clicado na árvore
e faz o canvas pedir a posição para a criação
"""
(model, _iter) = tree.get_selection().get_selected()
if _iter == None: return
p = model.get_string_from_iter(_iter)
self.canvas.grab_focus()
#descobre o tipo do bloco
#através do caminho e da árvore
for (t, it) in self.menu.keys():
if t == treelist and p == t.get_string_from_iter(it):
self.canvas.set_create_block( self.menu[ (t, it) ] )
cursor = gtk.gdk.Cursor(gtk.gdk.display_get_default(), gtk.gdk.CROSS)
self.mainwindow.window.set_cursor( cursor )
break
def new_proj(self, widget):
"""
Tela para o usuário criar
um novo projeto
"""
dialog = gtk.FileChooserDialog("", None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_NEW, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
proj = self.do_dialog(dialog)
if proj and ((os.path.exists(proj) and warning_message(_("File %s will be overwritten, are you sure you want to proceed?") % proj) == gtk.RESPONSE_OK) or not os.path.exists(proj)):
self.canvas.restart()
self.canvas.save_proj( proj )
self.set_project( proj )
def save_proj(self, widget):
"""
Se o projeto nunca tiver sido salvo,
pergunta onde salva, senão, salva em
cima da versão antiga
"""
if self.project == "":
self.saveas_proj(None)
else:
self.canvas.save_proj(self.project)
def saveas_proj(self, widget):
"""
Tela para o usuário salvar
o projeto em uso
"""
dialog = gtk.FileChooserDialog(_("Save..."), None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
proj = self.do_dialog(dialog)
if proj and ((os.path.exists(proj) and warning_message(_("File %s will be overwritten, are you sure you want to proceed?") % proj) == gtk.RESPONSE_OK) or not os.path.exists(proj)):
self.canvas.save_proj( proj )
self.set_project( proj )
def load_proj(self, widget):
"""
Tela para o usuário carregar
um novo projeto e fechar o que
estiver em uso
"""
dialog = gtk.FileChooserDialog(_("Open..."), None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
proj = self.do_dialog(dialog)
if os.path.exists(proj):
self.canvas.load_proj(proj)
self.set_project(proj)
def do_dialog(self, dialog):
"""
Abre uma tela de seleção
de arquivo
"""
result = ""
filter = gtk.FileFilter()
filter.add_pattern("*."+config.EXT)
filter.set_name(_("project")+" "+config.EXT)
dialog.add_filter(filter)
if os.path.exists(self.project):
dialog.set_current_folder( os.path.dirname(self.project) )
else:
home = os.getenv('USERPROFILE') or os.getenv('HOME')
dialog.set_current_folder(home)
response = dialog.run()
if response == gtk.RESPONSE_OK:
result = dialog.get_filename()
if result and os.path.splitext(result)[1] == "":
result+="."+config.EXT
else:
result = ""
dialog.destroy()
return result