def __init__(self, delegate=Delegate()):
gtk.VBox.__init__(self, 25)
self.set_border_width(25)
#
# model
self.delegate = delegate
self.instr_s = PrototypeController.PrototypeView.instructions()
self.instr_buf = gtk.TextBuffer()
self.instr_buf.set_text(self.instr_s)
#
# ui
self.vbox1 = gtk.VBox()
#
# vbox1
# top: instructions
# middle: entry
# bottom: generate code+unicode picker
#
#
# top
self.instr = gtk.TextView(self.instr_buf)
self.instr.set_editable(False)
self.instr.set_wrap_mode(gtk.WRAP_WORD)
#
# middle
hbox = gtk.HBox()
label = gtk.Label("Desired Button Label: ")
self.entry = gtk.Entry()
hbox.pack_start(label, False)
hbox.pack_start(self.entry)
#
# bottom
self.gen1button = gtk.Button("Generate Code")
self.unibutton = gtk.Button("Unicode Picker")
# hook up button clicks
self.gen1button.connect("clicked", self.gen1_clicked)
self.unibutton.connect("clicked", self.uni_clicked)
# add components to vbox
self.vbox1.pack_start(self.instr, False)
self.vbox1.pack_start(hbox)
self.vbox1.pack_start(self.unibutton, False)
self.vbox1.pack_start(self.gen1button, False)
self.vbox1.show()
self.add(self.vbox1)
#
# vbox2
# name field
# button layout info field
#
self.vbox2 = gtk.VBox()
hbox1 = gtk.HBox()
# title
title_label = gtk.Label('Controller Title: ')
self.title_entry = gtk.Entry()
hbox1.pack_start(title_label, False)
hbox1.pack_start(self.title_entry)
# tl
hbox2 = gtk.HBox()
tl_label = gtk.Label('Top-Left Description: ')
self.tl_entry = gtk.Entry()
hbox2.pack_start(tl_label, False)
hbox2.pack_start(self.tl_entry)
# tr
hbox3 = gtk.HBox()
tr_label = gtk.Label('Top-Right Description: ')
self.tr_entry = gtk.Entry()
hbox3.pack_start(tr_label, False)
hbox3.pack_start(self.tr_entry)
# bl
hbox4 = gtk.HBox()
bl_label = gtk.Label('Bottom-Left Description: ')
self.bl_entry = gtk.Entry()
hbox4.pack_start(bl_label, False)
hbox4.pack_start(self.bl_entry)
# bm
hbox5 = gtk.HBox()
bm_label = gtk.Label('Bottom-Middle Description: ')
self.bm_entry = gtk.Entry()
hbox5.pack_start(bm_label, False)
hbox5.pack_start(self.bm_entry)
# br
hbox6 = gtk.HBox()
br_label = gtk.Label('Bottom-Right Description: ')
self.br_entry = gtk.Entry()
hbox6.pack_start(br_label, False)
hbox6.pack_start(self.br_entry)
# buttons
self.back = gtk.Button('Go Back')
self.gen2button = gtk.Button('Generate Code')
# hook em up
self.back.connect('clicked', self.go2gen1)
self.gen2button.connect('clicked', self.gen2_clicked)
self.vbox2.pack_start(hbox1)
self.vbox2.pack_start(hbox2)
self.vbox2.pack_start(hbox3)
self.vbox2.pack_start(hbox4)
self.vbox2.pack_start(hbox5)
self.vbox2.pack_start(hbox6)
self.vbox2.pack_start(self.back, False)
self.vbox2.pack_start(self.gen2button, False)
self.vbox2.show_all()
#
# embed the unicode picker in the view
self.unicode_view = UnicodePickerView(self)
self.unicode_view.show_all()
def _create_widgets(self):
""""""
#vbox
self.all_box = HIGVBox()
self.soft_update_info_box = HIGHBox()
self.soft_update_list_box = HIGVBox()
self.check_btn_box = gtk.HButtonBox()
self.soft_update_detail_box = HIGVBox()
self.bottom_btn_box = gtk.HButtonBox()
#software update information title
self.update_icon = gtk.Image()
self.update_icon.set_from_file(
os.path.join(IMAGES_DIR, 'software_update.ico'))
self.version_information_label = HIGLabel(
_("The newest open monitor in your computer!"))
self.latest_time_information_label = HIGLabel(
_(self.latest_update_time))
self.soft_update_table = HIGTable()
#software list
self.column_names = ['Date', 'Version', 'Name']
self.vbox_list = gtk.VBox(False, 8)
self.scroll_window_vbox = gtk.ScrolledWindow()
self.scroll_window_vbox.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.scroll_window_vbox.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.vbox_list.pack_start(self.scroll_window_vbox, True, True, 0)
self.store = gtk.ListStore(str, str, str)
self.treeview = gtk.TreeView()
self.treeview.set_rules_hint(True)
self.treeview.set_sensitive(False)
self.vbox_list.set_size_request(100, 100)
self.scroll_window_vbox.add(self.treeview)
self._create_colums()
self.statusbar = gtk.Statusbar()
self.statusbar.push(0, 'No update!')
self.vbox_list.pack_start(self.statusbar, False, False, 0)
self.progress_bar = gtk.ProgressBar()
self.progress_bar.set_orientation(gtk.PROGRESS_LEFT_TO_RIGHT)
self.progress_bar.set_fraction(0.0)
self.vbox_list.pack_start(self.progress_bar, False, False, 0)
#button about the update
self.check_btn = HIGButton(_("Check"))
self.install_btn = HIGButton(_("Install"))
self.install_btn.set_sensitive(False)
#update details
self.detail_toggle_button = gtk.ToggleButton(_("Details"))
self.detail_btn_box = gtk.HButtonBox()
self.detail_btn_box.set_layout(gtk.BUTTONBOX_START)
self.details_vbox = HIGVBox()
self.details_scroll = gtk.ScrolledWindow()
self.details_textview = gtk.TextView()
self.details_textview.set_size_request(100, 120)
self.details_textview.set_editable(False)
self.details_textview.set_buffer(self._set_details_content())
#bottom button
self.close_btn = HIGButton(_("Close"))
self.settings_btn = HIGButton(_("Settings"))
class Burner:
def destroy(self, widget, data=None):
gtk.main_quit()
def usage():
print "Usage is not ready yet. See help button inside gcode-burner." # TODO
def help(self, widget):
self.help_dialog = gtk.MessageDialog(
self.window,
flags=gtk.DIALOG_DESTROY_WITH_PARENT,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format=None)
f = open("gcode-burner.info", "r")
self.help_dialog.set_markup(f.read())
f.close()
self.help_dialog.run()
self.help_dialog.destroy()
# g_signal_connect_swapped (dialog, "response",
# G_CALLBACK (gtk_widget_destroy),
# dialog);
def set_image(self, widget=None):
input_file = self.input_file.get_filename()
if input_file == None:
input_file = self.args_input_file
if not os.path.isfile(input_file):
message = gtk.MessageDialog(parent=None,
flags=0,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format=None)
message.set_markup('Wrong file!')
message.run()
message.destroy()
return
try:
self.pixbuf = gtk.gdk.pixbuf_new_from_file(input_file)
except:
message = gtk.MessageDialog(parent=None,
flags=0,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_NONE,
message_format=None)
message.set_markup('Wrong image!')
message.run()
message.destroy()
return
self.img_w, self.img_h = self.pixbuf.get_width(
), self.pixbuf.get_height()
if self.img_w == 0 or self.img_h == 0:
print '(Wrong img)'
return
scale = float(self.config.get('Global', 'image-scale'))
if self.img_w > self.img_h:
scaled_buf = self.pixbuf.scale_simple(
int(scale), int(scale * self.img_h / self.img_w),
gtk.gdk.INTERP_BILINEAR)
else:
scaled_buf = self.pixbuf.scale_simple(
int(scale * self.img_w / self.img_h), int(scale),
gtk.gdk.INTERP_BILINEAR)
self.image.set_from_pixbuf(scaled_buf)
self.set_hw()
def set_hw(self):
try:
self.w = self.spin_buttons["dots_x"].get_value()
self.h = self.spin_buttons["dots_y"].get_value()
if self.checkbuttons["aspect"].get_active():
self.h = self.w / self.img_w * self.img_h
self.spin_buttons["dots_y"].set_value(self.h)
except:
pass
def generate_gcode(self, arg):
output_file = self.output_file.get_text()
if self.checkbuttons['save_to_file'].get_active():
if self.checkbuttons['add_file_suffix'].get_active():
d = os.path.dirname(output_file)
l = os.listdir(d)
name = os.path.split(output_file)[-1]
name, ext = os.path.splitext(name)
max_n = 0
for s in l:
r = re.match(
r"^%s_0*(\d+)%s$" % (re.escape(name), re.escape(ext)),
s)
if r:
max_n = max(max_n, int(r.group(1)))
output_file = d + "/" + name + "_%04d" % (max_n + 1) + ext
try:
f = open(output_file, 'w')
except:
message = gtk.MessageDialog(parent=None,
flags=0,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_NONE,
message_format=None)
message.set_markup('Can not write to specified file! (%s)' %
output_file)
message.run()
message.destroy()
return
self.scaled_pixbuf = self.pixbuf.scale_simple(int(self.w), int(self.h),
gtk.gdk.INTERP_BILINEAR)
pixels = self.scaled_pixbuf.get_pixels_array()
zmin, zmax, ztr, x, y, x0, y0, feed = [
self.spin_buttons[key].get_value() for key in
'z_min z_max z_traverse dot_width dot_height x_offset y_offset feed'
.split()
]
header = self.header.get_text(self.header.get_start_iter(),
self.header.get_end_iter())
clean = self.clean_gcode.get_text(self.clean_gcode.get_start_iter(),
self.clean_gcode.get_end_iter())
clean_each = self.clean_each.get_text().lower()
try:
clean_v = float(clean_each)
except:
clean_v = None
if clean_v <= 0: clean_v = None
v_sum = 0.
gcode = header
parameterize = self.checkbuttons['paramtererization'].get_active()
if parameterize:
gcode += """
#<x-offset> = %s
#<y-offset> = %s
#<z-offset> = 0
#<x-scale> = 1
#<y-scale> = 1
#<z-scale> = 1
#<z-traverse> = %s
#<feed> = %s
""" % (x0, y0, ztr, feed)
gcode += '\n(Header end)\n'
gcode += 'G0 Z#<z-traverse>\n'
gcode += 'G0 X#<x-offset> Y#<y-offset>\n'
gcode += 'G1 X#<x-offset> Y#<x-offset> F#<feed>\n'
else:
gcode += '\n(Header end)\n'
gcode += 'G0 Z%f\n' % (ztr)
gcode += 'G0 X%f Y%f\n' % (x0, y0)
gcode += 'G1 X%f Y%f F%f\n' % (x0, y0, feed)
gcodel = []
for j in range(len(pixels[0])):
if "row" in clean_each:
gcodel.append(clean + "\n")
if self.checkbuttons['echo_filter_progress'].get_active():
print "FILTER_PROGRESS=%d" % int(100 * j / len(pixels[0]))
for k in range(len(pixels)):
# make zig-zag
i = k if j % 2 == 0 else len(pixels) - k - 1
#xy = j*rowstride+i*ch
r = pixels[i][j][0]
g = pixels[i][j][1]
b = pixels[i][j][2]
v = float(int(r) + int(g) + int(b)) / 255 / 3
v_sum += 1. - v
if clean_v != None and v_sum > clean_v:
gcodel.append(clean + "\n")
v_sum = 0
if v != 0:
depth = eval(self.z_func.get_text())
if depth != None:
if parameterize:
gcodel.append(
'G0 X[%s*#<x-scale>+#<x-offset>] Y[%s*#<y-scale>+#<y-offset>]\n'
% (x * i, y * j))
gcodel.append('G1 Z[%s*#<z-scale>+#<z-offset>]\n' %
depth)
gcodel.append('G0 Z#<z-traverse>\n')
else:
gcodel.append('G0 X%f Y%f\n' %
(x0 + x * i, y0 + y * j))
gcodel.append('G1 Z%f\n' % depth)
gcodel.append('G0 Z%f\n' % (ztr))
gcode += "".join(gcodel)
footer = self.footer.get_text(self.footer.get_start_iter(),
self.footer.get_end_iter())
gcode += '(Footer start)\n' + footer
if self.checkbuttons['save_to_file'].get_active():
f.write(gcode)
f.close()
else:
print gcode
if self.checkbuttons['save_options'].get_active():
for key in self.spin_buttons:
self.config.set('Spinners', key,
self.spin_buttons[key].get_value())
for key in self.checkbuttons:
self.config.set(
'CheckButtons', key,
1 if self.checkbuttons[key].get_active() else 0)
self.config.set('Global', 'header', header)
self.config.set('Global', 'footer', footer)
self.config.set('Global', 'clean-gcode', clean)
input_file = self.input_file.get_filename()
if input_file == None:
input_file = self.args_input_file
self.config.set('Global', 'input_file', input_file)
self.config.set('Global', 'output_file', self.output_file.get_text())
self.config.set('Global', 'clean-each', self.clean_each.get_text())
self.config.set('Global', 'z_func', self.z_func.get_text())
f = open(self.ini_file, "w")
self.config.write(f)
f.close()
self.destroy(None, None)
def set_spinners(self):
self.spin_buttons["dots_x"].set_value(self.w)
self.spin_buttons["dots_y"].set_value(self.h)
self.spin_buttons['dot_width'].set_value(
self.spin_buttons["width"].get_value() / self.w)
self.spin_buttons['dot_height'].set_value(
self.spin_buttons["height"].get_value() / self.h)
def change_spinners(self, widget, key):
if self.change_spinners_lock: return
self.change_spinners_lock = True
if key == 'dot_width':
self.spin_buttons['width'].set_value(
self.w * self.spin_buttons[key].get_value())
if key == 'width':
self.set_spinners()
if key == 'dot_height':
self.spin_buttons['height'].set_value(
self.h * self.spin_buttons[key].get_value())
if key == 'height':
self.set_spinners()
if key == 'dots_x':
self.w = self.spin_buttons[key].get_value()
if self.checkbuttons["aspect"].get_active():
self.h = self.w / self.img_w * self.img_h
self.set_spinners()
if key == 'dots_y':
self.h = self.spin_buttons[key].get_value()
if self.checkbuttons["aspect"].get_active():
self.w = self.h / self.img_h * self.img_w
self.set_spinners()
if self.checkbuttons["aspect"].get_active():
if key in ['dot_width', 'width']:
self.spin_buttons['height'].set_value(
self.spin_buttons['width'].get_value() * self.h / self.w)
self.spin_buttons['dot_height'].set_value(
float(self.spin_buttons['height'].get_value()) / self.h)
else:
self.spin_buttons['width'].set_value(
self.spin_buttons['height'].get_value() * self.w / self.h)
self.spin_buttons['dot_width'].set_value(
float(self.spin_buttons['width'].get_value()) / self.w)
self.change_spinners_lock = False
def show_filename(self, widget):
if widget.get_active():
self.output_file.show()
else:
self.output_file.hide()
def save_to_click(self, widget):
self.output_file_dialog.set_filename(self.output_file.get_text())
result = self.output_file_dialog.run()
if result == gtk.RESPONSE_OK:
self.output_file.set_text(self.output_file_dialog.get_filename())
self.output_file_dialog.hide()
def __init__(self):
self.change_spinners_lock = False
self.ini_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "gcode-burner.ini")
import ConfigParser
self.config = ConfigParser.RawConfigParser()
self.config.read(self.ini_file)
spinners = dict(self.config.items('Spinners'))
field_names = dict(self.config.items('Field_names'))
spinners_order = self.config.get('Global', 'spinners_order').split()
checkbuttons_order = self.config.get('Global',
'checkbuttons_order').split()
layout = self.config.get('Global', 'layout')
try:
opts, args = getopt.getopt(sys.argv[1:], "hi:", ["help", "input="])
except getopt.GetoptError, err:
# print help information and exit:
print str(
err) # will print something like "option -a not recognized"
usage()
sys.exit(2)
input_file = None
for o, a in opts:
if o in ("-h", "--help"):
usage()
sys.exit()
else:
assert False, "unhandled option"
if args == []:
self.args_input_file = self.config.get('Global', 'input_file')
else:
self.args_input_file = args[0]
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
table = gtk.Table(
2 + len(spinners_order) + len(checkbuttons_order) + 1, 4)
i = 0
self.image = gtk.Image()
if layout == "vertical":
table.attach(self.image, 0, 3, 0, 1)
else:
table.attach(self.image, 3, 4, 1,
2 + len(spinners_order) + len(checkbuttons_order) + 1)
i += 1
self.input_file = gtk.FileChooserButton('Open image', backend=None)
table.attach(self.input_file, 0, 2, i, i + 1, xoptions=gtk.FILL)
self.args_input_file = os.path.realpath(self.args_input_file)
self.input_file.select_filename(self.args_input_file)
self.input_file.connect("file-set", self.set_image)
self.set_image()
i += 1
self.spin_buttons = {}
self.z_func = gtk.Entry()
self.z_func.set_text(self.config.get('Global', 'z_func'))
table.attach(gtk.Label('Z function'), 0, 1, i, i + 1)
table.attach(self.z_func, 1, 2, i, i + 1)
i += 1
for key in spinners_order:
if key == '|':
table.attach(gtk.HSeparator(),
0,
2,
i,
i + 1,
xoptions=gtk.FILL)
i += 1
continue
adj = gtk.Adjustment(float(spinners[key]), -100000.0, 100000.0,
0.1, 100.0, 0.0)
self.spin_buttons[key] = gtk.SpinButton(adjustment=adj,
climb_rate=0.1,
digits=5)
table.attach(self.spin_buttons[key],
1,
2,
i,
i + 1,
xoptions=gtk.FILL)
table.attach(gtk.Label(field_names[key]),
0,
1,
i,
i + 1,
xoptions=gtk.FILL)
adj.connect("value_changed", self.change_spinners, key)
i += 1
self.set_hw()
self.clean_each = gtk.Entry()
self.clean_each.set_text(self.config.get('Global', 'clean-each'))
table.attach(gtk.Label(self.config.get('Field_names', 'clean-each')),
0, 1, i, i + 1)
table.attach(self.clean_each, 1, 2, i, i + 1)
i += 1
self.checkbuttons = {}
j = 0
for key in checkbuttons_order:
self.checkbuttons[key] = gtk.CheckButton(field_names[key])
self.checkbuttons[key].set_active(
bool(int(self.config.get('CheckButtons', key))))
table.attach(self.checkbuttons[key],
j,
j + 1,
i,
i + 1,
xoptions=gtk.FILL)
j = (j + 1) % 2
if j == 0:
i += 1
if j != 0:
i += 1
self.output_file = gtk.Entry()
self.output_file.set_text(self.config.get('Global', 'output_file'))
hbox = gtk.HBox()
hbox.pack_start(self.output_file)
self.output_file_dialog = gtk.FileChooserDialog(
title='Save Gcode to',
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE,
gtk.RESPONSE_OK))
self.output_file_dialog.set_default_response(gtk.RESPONSE_OK)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_SAVE_AS, gtk.ICON_SIZE_BUTTON)
self.save_to = gtk.Button(label=None)
self.save_to.set_image(image)
hbox.pack_start(self.save_to, expand=False)
self.save_to.connect("clicked", self.save_to_click)
table.attach(hbox, 1, 3, i, i + 1)
self.checkbuttons['save_to_file'].connect("toggled",
self.show_filename)
table.attach(gtk.Label('File name'), 0, 1, i, i + 1)
i += 1
button = gtk.Button("Generate Gcode")
table.attach(button, 2, 3, i, i + 1)
button.connect("clicked", self.generate_gcode)
button = gtk.Button("Help")
table.attach(button, 0, 1, i, i + 1)
button.connect("clicked", self.help)
i += 1
frame = gtk.Frame('Header')
textview = gtk.TextView()
self.header = textview.get_buffer()
self.header.set_text(self.config.get('Global', 'header'))
textview.set_wrap_mode(gtk.WRAP_NONE)
sw = gtk.ScrolledWindow()
sw.set_size_request(250, 150)
frame.add(sw)
sw.add(textview)
table.attach(frame,
2,
3,
1,
7,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=gtk.EXPAND | gtk.FILL,
xpadding=5,
ypadding=5)
frame = gtk.Frame('Footer')
textview = gtk.TextView()
self.footer = textview.get_buffer()
self.footer.set_text(self.config.get('Global', 'footer'))
textview.set_wrap_mode(gtk.WRAP_NONE)
sw = gtk.ScrolledWindow()
frame.add(sw)
sw.add(textview)
table.attach(frame,
2,
3,
7,
15,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=gtk.EXPAND | gtk.FILL,
xpadding=5,
ypadding=5)
frame = gtk.Frame('Clean Gcode')
textview = gtk.TextView()
self.clean_gcode = textview.get_buffer()
self.clean_gcode.set_text(self.config.get('Global', 'clean-gcode'))
textview.set_wrap_mode(gtk.WRAP_NONE)
sw = gtk.ScrolledWindow()
frame.add(sw)
sw.add(textview)
table.attach(frame,
2,
3,
15,
21,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=gtk.EXPAND | gtk.FILL,
xpadding=5,
ypadding=5)
self.window.add(table)
self.window.show_all()
def __init__(self, editor=None, render=None):
''' Contrução da interface gráfica'''
#print editor
self.__editor = editor
# Janela
self.__window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.__window.set_resizable(True)
self.__window.connect("destroy", gtk.main_quit)
self.__window.set_title("FACIL")
self.__window.set_border_width(0)
#self.__window.set_resizable(False)
#self.__window.set_decorated(False)
self.__window.set_default_size(600, 450)
# Encapsulamento por containers
# árvore dos widgets:
# window
# vbox
# (hbox_lateral)
# scrolledwindow
# textview
# (fixed_lateral)
# (vbox_lateral)
# (button)
# fixed
# hbox
# button
# obs.: se houver barra de ferramentas lateral, o widget
# scrolledwindow deve ser encapsulado em um hbox
vbox = gtk.VBox(False, 0)
self.__window.add(vbox)
# implementação da barra lateral
hbox_lateral = gtk.HBox(False, 0)
# Cria uma scrolledwindow para encapsular o texto
sw = gtk.ScrolledWindow()
#sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
# funciona melhor com AUTOMATIC na vertical e horizontal
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
if render == None:
#print 'criando um textview'
self.textview = gtk.TextView()
else:
print 'recebeu um renderizador'
self.textview = render
self.textview.set_wrap_mode(gtk.WRAP_WORD)
self.textview.show()
sw.add(self.textview)
#vbox.pack_start(sw, True, True, 0)
# implementação da barra lateral:
# @vbox encapsula @hbox_lateral
# @hbox_lateral encapsula @scrolledwindow e @fixed_lateral
# @fixed_lateral encapsula @vbox_lateral, que contém os botões
vbox.pack_start(hbox_lateral, True, True, 0)
hbox_lateral.pack_start(sw, True, True, 0)
fixed_lateral = gtk.Fixed()
hbox_lateral.pack_end(fixed_lateral, False, False, 0)
vbox_lateral = gtk.VBox()
fixed_lateral.put(vbox_lateral, 0, 0)
#### pode ser removido!!!
#b = gtk.Button('teste')
#vbox_lateral.pack_start(b, False, False, 0)
#b.show()
###
vbox_lateral.show()
fixed_lateral.show()
hbox_lateral.show()
# Encapsulamento da barra de ferramentas horizontal
fixed = gtk.Fixed()
vbox.pack_end(fixed, False, False, 0)
hbox = gtk.HBox()
fixed.put(hbox, 0, 0)
# empacota os botões dentro do hbox, total de 11 botões
for i in range(1, N_BOTOES + 1):
imagem = gtk.Image()
#nome = "pixmaps/button%s_peq.png" % repr(i)
nome = "pixmaps/button5_peq.png"
imagem.set_from_file(nome)
botao = gtk.Button()
botao.set_image(imagem)
botao.set_property("relief", gtk.RELIEF_NONE)
dica = gtk.Tooltips()
dica.set_tip(botao, self.__dicas[i])
#botao.set_label(self.__dicas[i])
if i < N_BOTOES_H + 1:
hbox.pack_start(botao, False, False, 0)
else:
vbox_lateral.pack_start(botao, False, False, 0)
botao.show()
# eventos para conectar
botao.connect("clicked", self.clique_botao, i)
botao.connect("enter", self.aumenta_imagem, i)
botao.connect("leave", self.diminui_imagem, i)
hbox.show()
fixed.show()
sw.show()
vbox.show()
#self.__window.reshow_with_initial_size()
self.__window.show()
print self.__window.get_size()
def __init__(self):
# Main Window
super(MainWindow, self).__init__()
self.set_title("Protocol Dissector Generator System")
self.set_default_size(500, 1000)
self.set_position(gtk.WIN_POS_CENTER)
# Title
title = gtk.Label("Protocol Dissector Generator System")
# Buttons' Box
vbox1 = gtk.VBox()
box1 = gtk.HButtonBox()
# Button1
btn1 = gtk.Button(label="Create Project")
btn1.connect("clicked", self.show_NewProjectWindow)
# Button2
btn2 = gtk.Button(label="Save Project")
# Button3
btn3 = gtk.Button(label="Close Project")
# Button4
btn4 = gtk.Button(label="Switch Workspace")
btn4.connect("clicked", self.show_WorkspaceLauncherWindow)
# Button5
btn5 = gtk.Button(label="Import Project")
btn5.connect("clicked", self.show_ProjectImportWindow)
# Button6
btn6 = gtk.Button(label="Export Project")
btn6.connect("clicked", self.show_ExportWindow)
# Button7
btn7 = gtk.Button(label="Generate Dissector Script")
btn7.connect("clicked", self.show_DissectorScriptWindow)
# Button8
btn8 = gtk.Button(label="Organize Views")
btn8.connect("clicked", self.show_OrganizeviewWindow)
# Button9
btn9 = gtk.Button(label="Open PCAP")
btn9.connect("clicked", self.show_PCAPWindow)
# Pack to box1
box1.pack_start(btn1, True, True, 0)
box1.pack_start(btn2, True, True, 0)
box1.pack_start(btn3, True, True, 0)
box1.pack_start(btn4, True, True, 0)
box1.pack_start(btn5, True, True, 0)
box1.pack_start(btn6, True, True, 0)
box1.pack_start(btn7, True, True, 0)
box1.pack_start(btn8, True, True, 0)
box1.pack_start(btn9, True, True, 0)
box1.set_border_width(5)
# VBox
vbox1.add(box1)
vbox1.set_border_width(5)
# Scrolled Window for Workspace
swWorkspace = gtk.ScrolledWindow()
swWorkspace.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
# Project Navigator Tree
pnLabel = gtk.Label("Project Navigator")
tree = gtk.TreeView()
languages = gtk.TreeViewColumn()
cwd = os.getcwd()
path = cwd.split('\\')
languages.set_title(path[-1])
cell1 = gtk.CellRendererText()
languages.pack_start(cell1, True)
languages.add_attribute(cell1, "text", 0)
treestore1 = gtk.TreeStore(str)
parents = {}
for dirname, subdirnames, files in os.walk('.'):
for subdirname in subdirnames:
parents[os.path.join(dirname, subdirname)] = treestore1.append(
parents.get(dirname, None), [subdirname])
for filename in files:
treestore1.append(parents.get(dirname, None), [filename])
tree.append_column(languages)
tree.set_model(treestore1)
tree.set_size_request(200, 590)
swWorkspace.add(tree)
# TextView
dbaLabel = gtk.Label("Dissector Builder Area")
dba = gtk.TextView()
dba.set_size_request(700, 350)
# Palette
paletteLabel = gtk.Label("Palette")
table = gtk.Table(23, 2, True)
table.set_row_spacings(2)
table.set_col_spacings(2)
# Scrolled Window for Palette
swPalette = gtk.ScrolledWindow()
swPalette.set_size_request(400, 350)
swPalette.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
# Field Section
fieldLbl = gtk.Label("Field")
table.attach(fieldLbl, 0, 2, 0, 1)
btnsf = gtk.Button(label="Start Field")
btnsf.connect('clicked', self.show_StartFieldWindow)
table.attach(btnsf, 0, 2, 1, 2)
vsbtn = gtk.Button(label="Field (Var Size)")
vsbtn.connect('clicked', self.show_FieldWindow)
table.attach(vsbtn, 0, 1, 2, 3)
btn1b = gtk.Button(label="Field (1 Byte)")
btn1b.connect('clicked', self.show_FieldWindow)
table.attach(btn1b, 1, 2, 2, 3)
btn2b = gtk.Button(label="Field (2 Byte)")
btn2b.connect('clicked', self.show_FieldWindow)
table.attach(btn2b, 0, 1, 3, 4)
btn4b = gtk.Button(label="Field (4 Byte)")
btn4b.connect('clicked', self.show_FieldWindow)
table.attach(btn4b, 1, 2, 3, 4)
btn8b = gtk.Button(label="Field (8 Byte)")
btn8b.connect('clicked', self.show_FieldWindow)
table.attach(btn8b, 0, 1, 4, 5)
btn16b = gtk.Button(label="Field (16 Byte)")
btn16b.connect('clicked', self.show_FieldWindow)
table.attach(btn16b, 1, 2, 4, 5)
rlbtn = gtk.Button(label="Reference List")
rlbtn.connect('clicked', self.show_ReferenceListWindow)
table.attach(rlbtn, 0, 1, 5, 6)
pibtn = gtk.Button(label="Packet Information")
pibtn.connect('clicked', self.show_PacketInformationWindow)
table.attach(pibtn, 1, 2, 5, 6)
efbtn = gtk.Button(label="End Field")
efbtn.connect('clicked', self.show_EndFieldWindow)
table.attach(efbtn, 0, 2, 6, 7)
# Construct Section
constructLbl = gtk.Label("Construct")
table.attach(constructLbl, 0, 2, 8, 9)
decisionBtn = gtk.Button(label="Decision")
table.attach(decisionBtn, 0, 2, 9, 11)
decisionBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
decisionBtn.connect("drag_data_get", self.on_drag_data_get)
connectorBtn = gtk.Button(label="Connector")
table.attach(connectorBtn, 0, 2, 11, 13)
connectorBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
connectorBtn.connect("drag_data_get", self.on_drag_data_get)
exprLabel = gtk.Label("Expression")
table.attach(exprLabel, 0, 1, 13, 14)
relatOprLabel = gtk.Label("Relational Operator")
table.attach(relatOprLabel, 0, 2, 14, 15)
lessBtn = gtk.Button("<")
table.attach(lessBtn, 0, 1, 15, 16)
lessBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
lessBtn.connect("drag_data_get", self.on_drag_data_get)
greaterBtn = gtk.Button(">")
table.attach(greaterBtn, 1, 2, 15, 16)
greaterBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)], gtk.gdk.ACTION_COPY)
greaterBtn.connect("drag_data_get", self.on_drag_data_get)
lessOrEqBtn = gtk.Button("<=")
table.attach(lessOrEqBtn, 0, 1, 16, 17)
lessOrEqBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
lessOrEqBtn.connect("drag_data_get", self.on_drag_data_get)
greaterOrEqBtn = gtk.Button(">=")
table.attach(greaterOrEqBtn, 1, 2, 16, 17)
greaterOrEqBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
greaterOrEqBtn.connect("drag_data_get", self.on_drag_data_get)
equalBtn = gtk.Button("==")
table.attach(equalBtn, 0, 1, 17, 18)
equalBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
equalBtn.connect("drag_data_get", self.on_drag_data_get)
notEqBtn = gtk.Button("~=")
table.attach(notEqBtn, 1, 2, 17, 18)
notEqBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
notEqBtn.connect("drag_data_get", self.on_drag_data_get)
lgcOprLabel = gtk.Label("Logical Operator")
table.attach(lgcOprLabel, 0, 2, 18, 19)
andBtn = gtk.Button("And")
table.attach(andBtn, 0, 2, 19, 20)
andBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
andBtn.connect("drag_data_get", self.on_drag_data_get)
orBtn = gtk.Button("Or")
table.attach(orBtn, 0, 2, 20, 21)
orBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
orBtn.connect("drag_data_get", self.on_drag_data_get)
notBtn = gtk.Button("Not")
table.attach(notBtn, 0, 2, 21, 22)
notBtn.drag_source_set(gtk.gdk.BUTTON1_MASK, [("text/plain", 0, 1)],
gtk.gdk.ACTION_COPY)
notBtn.connect("drag_data_get", self.on_drag_data_get)
operandBtn = gtk.Button("Operand")
table.attach(operandBtn, 0, 1, 22, 23)
operandBtn.drag_source_set(gtk.gdk.BUTTON1_MASK,
[("text/plain", 0, 1)], gtk.gdk.ACTION_COPY)
operandBtn.connect("drag_data_get", self.on_drag_data_get)
swPalette.add_with_viewport(table)
# Notebook
nb = gtk.Notebook()
nb.set_tab_pos(gtk.POS_TOP)
tv1 = gtk.TextView()
nb.append_page(tv1)
nb.set_tab_label_text(tv1, "Packet Stream Area")
tv2 = gtk.TextView()
nb.append_page(tv2)
nb.set_tab_label_text(tv2, "Dissected Stream Area")
tv3 = gtk.TextView()
nb.append_page(tv3)
nb.set_tab_label_text(tv3, "Raw Data Area")
tv4 = gtk.TextView()
nb.append_page(tv4)
nb.set_tab_label_text(tv4, "Console Area")
nb.set_size_request(1120, 215)
# Fixed positions
fixed = gtk.Fixed()
fixed.put(title, 12, 5)
fixed.put(vbox1, 0, 18)
fixed.put(pnLabel, 12, 80)
fixed.put(swWorkspace, 12, 100)
fixed.put(dbaLabel, 500, 80)
fixed.put(dba, 220, 100)
fixed.put(paletteLabel, 1112, 80)
fixed.put(swPalette, 940, 100)
fixed.put(nb, 220, 475)
self.add(fixed)
self.connect("destroy", gtk.main_quit)
self.set_default_size(0, 700)
self.show_all()
def __init__(self, *args, **kwargs):
gtk.Window.__init__(self, *args, **kwargs)
self.set_title('Spell check')
self.set_default_size(350, 200)
self._checker = None
self._numContext = 40
self.errors = None
# create accel group
accel_group = gtk.AccelGroup()
self.add_accel_group(accel_group)
# list of widgets to disable if there's no spell error left
self._conditional_widgets = []
conditional = self._conditional_widgets.append
# layout
mainbox = gtk.VBox(spacing=5)
hbox = gtk.HBox(spacing=5)
self.add(mainbox)
mainbox.pack_start(hbox, padding=5)
box1 = gtk.VBox(spacing=5)
hbox.pack_start(box1, padding=5)
conditional(box1)
# unreconized word
text_view_lable = gtk.Label('Unreconized word')
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
box1.pack_start(text_view_lable, False, False)
text_view = gtk.TextView()
text_view.set_wrap_mode(gtk.WRAP_WORD)
text_view.set_editable(False)
text_view.set_cursor_visible(False)
self.error_text = text_view.get_buffer()
text_buffer = text_view.get_buffer()
text_buffer.create_tag("fg_black", foreground="black")
text_buffer.create_tag("fg_red", foreground="red")
box1.pack_start(text_view)
# Change to
change_to_box = gtk.HBox()
box1.pack_start(change_to_box, False, False)
change_to_label = gtk.Label('Change to:')
self.replace_text = gtk.Entry()
text_view_lable.set_justify(gtk.JUSTIFY_LEFT)
change_to_box.pack_start(change_to_label, False, False)
change_to_box.pack_start(self.replace_text)
# scrolled window
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box1.pack_start(sw)
self.suggestion_list_view = create_list_view('Suggestions')
self.suggestion_list_view.connect("button_press_event",
self._onButtonPress)
self.suggestion_list_view.connect("cursor-changed",
self._onSuggestionChanged)
sw.add(self.suggestion_list_view)
# ---Buttons---#000000#FFFFFF----------------------------------------------------
button_box = gtk.VButtonBox()
hbox.pack_start(button_box, False, False)
# Ignore
button = gtk.Button("Ignore")
button.connect("clicked", self._onIgnore)
button.add_accelerator("activate", accel_group, gtk.keysyms.Return, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_start(button)
conditional(button)
# Ignore all
button = gtk.Button("Ignore All")
button.connect("clicked", self._onIgnoreAll)
button_box.pack_start(button)
conditional(button)
# Replace
button = gtk.Button("Replace")
button.connect("clicked", self._onReplace)
button_box.pack_start(button)
conditional(button)
# Replace all
button = gtk.Button("Replace All")
button.connect("clicked", self._onReplaceAll)
button_box.pack_start(button)
conditional(button)
# Recheck button
button = gtk.Button("_Add")
button.connect("clicked", self._onAdd)
button_box.pack_start(button)
conditional(button)
# Close button
button = gtk.Button(stock=gtk.STOCK_CLOSE)
button.connect("clicked", self._onClose)
button.add_accelerator("activate", accel_group, gtk.keysyms.Escape, 0,
gtk.ACCEL_VISIBLE)
button_box.pack_end(button)
# dictionary label
self._dict_lable = gtk.Label('')
mainbox.pack_start(self._dict_lable, False, False, padding=5)
mainbox.show_all()
def build_dialog(self, parent, title, details):
dialog = gtk.Dialog(_('Error'), parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
but_send = gtk.Button(_('Report Bug'))
dialog.add_action_widget(but_send, gtk.RESPONSE_OK)
close_button = dialog.add_button("gtk-close", gtk.RESPONSE_CANCEL)
close_button.set_always_show_image(True)
dialog.set_default_response(gtk.RESPONSE_CANCEL)
vbox = gtk.VBox()
label_title = gtk.Label()
label_title.set_markup('<b>' + _('Application Error.') + '</b>')
label_title.set_padding(-1, 5)
vbox.pack_start(label_title, False, False)
vbox.pack_start(gtk.HSeparator(), False, False)
hbox = gtk.HBox()
image = gtk.Image()
image.set_from_stock('tryton-dialog-error', gtk.ICON_SIZE_DIALOG)
hbox.pack_start(image, False, False)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
box = gtk.VBox()
label_error = gtk.Label()
label_error.set_markup('')
label_error.set_alignment(0, 0.5)
label_error.set_padding(-1, 14)
label_error.modify_font(pango.FontDescription("monospace"))
label_error.set_markup('<b>' + _('Error: ') + '</b>' + to_xml(title))
box.pack_start(label_error, False, False)
textview = gtk.TextView()
buf = gtk.TextBuffer()
buf.set_text(details)
textview.set_buffer(buf)
textview.set_editable(False)
textview.set_sensitive(True)
textview.modify_font(pango.FontDescription("monospace"))
box.pack_start(textview, False, False)
viewport.add(box)
scrolledwindow.add(viewport)
hbox.pack_start(scrolledwindow)
vbox.pack_start(hbox)
button_roundup = gtk.Button()
button_roundup.set_relief(gtk.RELIEF_NONE)
label_roundup = gtk.Label()
label_roundup.set_markup(
_('To report bugs you must have an account'
' on <u>%s</u>') % CONFIG['roundup.url'])
label_roundup.set_alignment(1, 0.5)
label_roundup.set_padding(20, 5)
button_roundup.connect(
'clicked',
lambda widget: webbrowser.open(CONFIG['roundup.url'], new=2))
button_roundup.add(label_roundup)
vbox.pack_start(button_roundup, False, False)
dialog.vbox.pack_start(vbox)
dialog.set_default_size(600, 400)
return dialog
class ExpressionFaciale:
verbose = True
# Code vient d'ici: http://www.pygtk.org/pygtk2tutorial/sec-Images.html#idp5575312
if verbose == True:
rospy.loginfo("Definition de la classe.")
volts = []
times = []
iTime = 0
delais = 5000 # va rafraichir toutes les x millisecondes.
# Plot
temps_max = 1000
figure = Figure(figsize=(600,125))
figure.patch.set_facecolor('black')
ax = figure.add_subplot(111, facecolor='black')
line, = ax.plot(times,volts)
ax.set_ylim(-0.2,1.0) # mv: -0.5 a 1
ax.set_xlim(0,temps_max)
ax.set_axis_bgcolor('black')
etatHumeur = "Neutre"
etatStatut = "En attente..."
#envoieSpikePret = True
# Communication avec Behavior_chatbot
#topic_attention_conversation = rospy.Publisher('topic_attention_conversation', String, queue_size=10)
# Images et textes
imageHumeur = gtk.Image()
imageFiller = gtk.Image()
statut = gtk.TextView()
statut.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse('#000000'))
statut.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF'))
texte = statut.get_buffer()
texte.set_text(etatStatut)
#def update_line(data):
#line.set_ydata(volts)
#line.set_xdata(times)
# return line,
plotCanevas = FigureCanvas(figure)
#ani = animation.FuncAnimation(figure, update_line, interval=delais)
plt.style.use('dark_background')
pix_filler = gtk.gdk.PixbufAnimation("/home/ubuntu/catkin_ws/src/spike/src/spike/images/pensees/imageFiller.jpeg")
imageFiller.set_from_animation(pix_filler)
pix_humeur_neutre = gtk.gdk.PixbufAnimation("/home/ubuntu/catkin_ws/src/spike/src/spike/images/humeurs/humeurNeutre.png")
pix_humeur_joyeux = gtk.gdk.PixbufAnimation("/home/ubuntu/catkin_ws/src/spike/src/spike/images/humeurs/humeurJoyeux.png")
pix_humeur_fatigue = gtk.gdk.PixbufAnimation("/home/ubuntu/catkin_ws/src/spike/src/spike/images/humeurs/humeurFatigue.gif")
pix_humeur_triste = gtk.gdk.PixbufAnimation("/home/ubuntu/catkin_ws/src/spike/src/spike/images/humeurs/humeurTriste.gif")
def expression(self, widget, data=None):
print "Expression faciale"
def delete_event(self, widget, event, data=None):
print "La fenetre ExpressionFaciale a ete detruite..."
return False
def destroy(self, widget, data=None):
print "La fenetre ExpressionFaciale a ete detruite..."
self.main_quit()
def my_timer(self):
#if mode == modeTest:
# if verbose:
# rospy.loginfo("Timer modeTest: Change les etats...")
#if mode == modeRecoitSignal:
# if verbose:
# rospy.loginfo("Timer modeRecoitSignal")
self.rafraichir()
def rafraichir(self):
if self.verbose == True:
rospy.loginfo(" Humeur: " + self.etatHumeur )
# Execute ce code UNE fois, au debut. ChatBot - Spike est pret!
#if self.envoieSpikePret == True:
# self.envoieSpikePret = False
# if verbose:
# rospy.loginfo("Envoie le message que Spike est pret au chatbot.")
# self.topic_attention_conversation.publish("SPIKE PRET")
# On ajuste l'humeur selon l'etat
#if self.etatHumeur == "Neutre":
# self.imageHumeur.set_from_animation(self.pix_humeur_neutre)
#if self.etatHumeur == "Joyeux":
# self.imageHumeur.set_from_animation(self.pix_humeur_joyeux)
#if self.etatHumeur == "Triste":
# self.imageHumeur.set_from_animation(self.pix_humeur_triste)
#if self.etatHumeur == "Fatigue":
# self.imageHumeur.set_from_animation(self.pix_humeur_fatigue)
#self.imageHumeur.show()
# mise a jour du message a ecran
#self.texte.set_text(self.etatStatut)
#self.statut.set_buffer(self.texte)
#self.statut.show()
# On reinitialise pour le prochain rafraichissement
#self.etatStatut = ""
# Declaration du timer
gtk.timeout_add(self.delais, self.my_timer)
#self.plotCanevas.show()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.set_border_width(1)
self.window.set_title("SPIKE")
self.window.resize(600, 480)
#fixed = gtk.Fixed()
#fixed.set_size_request(1280, 1024)
self.imageHumeur.set_from_animation(self.pix_humeur_neutre)
#self.canevas.put(self.imageReflexion, 0, 0)
#fixed.put(self.plotCanevas,0,0)
#fixed.put(self.imageHumeur, 0, 256)
#fixed.put(self.statut, 100, 50)
#self.plotCanevas.show()
#fixed.show()
#self.window.add(self.imageHumeur)
#self.window.add(self.statut)
#JSD: REACTIVER LES LIGNES COMMENTES POUR AVOIR LES AUTRES ELEMENTS. MAIS REDUIRE LA TAILLE DU FILLER.
vbox = gtk.VBox(False, 0)
vbox.pack_start(self.plotCanevas)
vbox.pack_start(self.imageHumeur, False, False)
#vbox.pack_start(self.imageFiller, False, False)
vbox.pack_start(self.statut)
self.window.add(vbox)
self.window.show_all()
self.rafraichir()
def main(self):
if self.verbose == True:
rospy.loginfo("Behavior_humeur: Main")
if self.verbose == True:
rospy.loginfo("Definition des callbacks.")
def callbackHumeur(data):
expression.etatHumeur = data.data
if self.verbose == True:
rospy.loginfo("Humeur: %s", expression.etatHumeur)
def callbackStatut(data):
expression.etatStatut = data.data
if self.verbose == True:
rospy.loginfo("Statut: %s", expression.etatStatut)
def callbackNeurones(data):
print "Callback neurones"
if self.iTime >= 1000:
del self.times[:]
del self.volts[:]
self.iTime = 0
plt.clf()
self.volts.append(data.data)
self.times.append(self.iTime)
self.iTime += 1
if self.verbose == True:
rospy.loginfo("Enregistrement des Subscribers.")
# On s'inscrit aux topics
rospy.Subscriber("topic_humeur", String, callbackHumeur)
rospy.Subscriber("behavior_ecoute/output", String, callbackStatut)
rospy.Subscriber('/topic_motor_volt_1', Float32, callbackNeurones)
if self.verbose == True:
rospy.loginfo("Appel de la definition de l'expression faciale.")
gtk.main()
def __init__(self):
#PCAP Window
super(PCAPWindow, self).__init__()
self.set_title("PCAP")
self.set_default_size(250, 300)
self.set_position(gtk.WIN_POS_CENTER)
# Labels
descLabel = gtk.Label("Open a PCAP file")
pcapLabel = gtk.Label("PCAP Name")
#Browse Buttons Box
hbox1 = gtk.HBox()
textViewBox = gtk.VButtonBox()
browseButtonBox = gtk.VButtonBox()
labelBox = gtk.VButtonBox()
#Action Buttons Box
vbox1 = gtk.VBox()
actionButtonBox = gtk.HButtonBox()
# Browse Button 1
browsebtn1 = gtk.Button(label="Browse")
# Open Button
openbtn = gtk.Button(label="Open")
# Cancel Button
cancelbtn = gtk.Button(label="Cancel")
# Text Buffers
pcapTextView = gtk.TextView()
# Packing Browse Buttons
labelBox.pack_start(pcapLabel, True, True, 5)
browseButtonBox.pack_start(browsebtn1, True, True, 5)
textViewBox.pack_start(pcapTextView, True, True, 5)
browseButtonBox.set_border_width(5)
# Adding Buttons Box to Buttons VBox
hbox1.add(labelBox)
hbox1.add(textViewBox)
hbox1.add(browseButtonBox)
# Packing Action Buttons
actionButtonBox.pack_start(openbtn, True, True, 0)
actionButtonBox.pack_start(cancelbtn, True, True, 0)
# Adding Actions Box to Actions VBox
vbox1.add(actionButtonBox)
# File Chooser
def chooseDialog(self, textview):
dialog = gtk.FileChooserDialog(
"Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_OPEN, gtk.RESPONSE_OK, gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL))
dialog.set_default_response(gtk.RESPONSE_OK)
response = dialog.run()
if response == gtk.RESPONSE_OK:
#print dialog.get_filename(), 'selected'
textBuffer = gtk.TextBuffer()
textBuffer.set_text(dialog.get_filename())
textview.set_buffer(textBuffer)
dialog.destroy()
# To close and exit the application
def exit(widget, callback_data=None):
self.destroy()
browsebtn1.connect("clicked", chooseDialog, pcapTextView)
cancelbtn.connect("clicked", exit)
#Fixed positions
fixed = gtk.Fixed()
fixed.put(descLabel, 84, 5)
fixed.put(hbox1, 0, 25)
fixed.put(vbox1, 84, 65)
self.add(fixed)
self.set_default_size(0, 0)
self.set_resizable(False)
self.show_all()
def __init__(self, namespace={}, quit_handler=None):
""" Initialize console
"""
# Setup scrolled window
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.set_border_width(0)
# Setup text view
self.text = gtk.TextView()
self.text.set_property('can-focus', True)
self.text.modify_font(pango.FontDescription("mono 9"))
self.text.set_editable(True)
self.text.set_wrap_mode(True)
self.text.set_left_margin(1)
self.text.set_right_margin(1)
self.text.set_size_request(0, 0)
# Setup text buffer
self.buffer = self.text.get_buffer()
self.buffer.create_tag ('prompt', \
weight=pango.WEIGHT_BOLD, editable=False)
self.buffer.create_tag ('script', \
foreground='darkgrey', style=pango.STYLE_OBLIQUE, \
editable=False)
self.buffer.create_tag ('normal', \
foreground='blue', editable=False)
self.buffer.create_tag ('error', \
foreground='red', style=pango.STYLE_OBLIQUE, \
editable=False)
self.buffer.create_tag ('extern', \
foreground='brown', weight=pango.WEIGHT_BOLD, \
editable=False)
self.buffer.create_tag ('center', \
justification=gtk.JUSTIFY_CENTER, editable=False)
# Setup event handlers
self.text.add_events(gtk.gdk.KEY_PRESS_MASK)
self.text.connect('key-press-event', self.on_key_pressed)
self.text.connect('button-release-event', self.on_button_released)
self.text.connect('drag-data-received', self.on_drag_data_received)
self.add(self.text)
# Internal setup
self.tab_pressed = 0
self.nonword_re = re.compile("[^\w\._]")
self.completer = rlcompleter.Completer()
self.namespace = {}
self.cmd = ''
self.input = ''
self.input_mode = False
self.linestart = 0
self.quit_handler = self.quit
if quit_handler:
self.quit_handler = quit_handler
# Setup hooks for standard output.
self.stdout = gtkoutfile(self, self.__get_stream(sys.stdout), 'normal')
self.stderr = gtkoutfile(self, self.__get_stream(sys.stderr), 'error')
self.stdin = gtkinfile(self, self.__get_stream(sys.stdin))
# Setup command history
self.history = History()
self.namespace['__history__'] = self.history
self.show_all()
self.dispatcher = Dispatcher(self)
self.dispatcher.start()
def _info(exctyp, value, tb):
global exception_dialog_active
if exctyp is KeyboardInterrupt:
return original_excepthook(exctyp, value, tb)
sys.stderr.write(analyse_simple(exctyp, value, tb).getvalue())
if exception_dialog_active:
return
gtk.gdk.pointer_ungrab()
gtk.gdk.keyboard_ungrab()
exception_dialog_active = True
trace = None
dialog = gtk.MessageDialog(parent=None,
flags=0,
type=gtk.MESSAGE_WARNING,
buttons=gtk.BUTTONS_NONE)
dialog.set_title(_("Bug Detected"))
if gtk.check_version(2, 4, 0) is not None:
dialog.set_has_separator(False)
primary = _("<big><b>A programming error has been detected.</b></big>")
primary += '\n\n<span color="red">' + str(value) + '</span>'
secondary = _(
"It probably isn't fatal, but the details should be reported to the developers nonetheless."
)
try:
setsec = dialog.format_secondary_text
except AttributeError:
raise
dialog.vbox.get_children()[0].get_children()[1].set_markup(
'%s\n\n%s' % (primary, secondary))
#lbl.set_property ("use-markup", True)
else:
del setsec
dialog.set_markup(primary)
dialog.format_secondary_text(secondary)
try:
email = feedback
dialog.add_button(_("Report..."), 3)
except NameError:
# could ask for an email address instead...
pass
dialog.add_button(_("Details..."), 2)
dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
dialog.add_button(gtk.STOCK_QUIT, 1)
while True:
resp = dialog.run()
if resp == 3:
if trace == None:
trace = analyse(exctyp, value, tb)
# TODO: prettyprint, deal with problems in sending feedback, &tc
try:
server = smtphost
except NameError:
server = 'localhost'
message = 'From: buggy_application"\nTo: bad_programmer\nSubject: Exception feedback\n\n%s' % trace.getvalue(
)
s = SMTP()
s.connect(server)
s.sendmail(email, (email, ), message)
s.quit()
break
elif resp == 2:
if trace == None:
trace = analyse(exctyp, value, tb)
# Show details...
details = gtk.Dialog(
_("Bug Details"), dialog,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (
gtk.STOCK_CLOSE,
gtk.RESPONSE_CLOSE,
))
details.set_property("has-separator", False)
textview = gtk.TextView()
textview.show()
textview.set_editable(False)
textview.modify_font(pango.FontDescription("Monospace"))
sw = gtk.ScrolledWindow()
sw.show()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(textview)
details.vbox.add(sw)
textbuffer = textview.get_buffer()
textbuffer.set_text(trace.getvalue())
monitor = gtk.gdk.screen_get_default().get_monitor_at_window(
dialog.window)
area = gtk.gdk.screen_get_default().get_monitor_geometry(monitor)
try:
w = area.width // 1.6
h = area.height // 1.6
except SyntaxError:
# python < 2.2
w = area.width / 1.6
h = area.height / 1.6
details.set_default_size(int(w), int(h))
details.run()
details.destroy()
elif resp == 1 and gtk.main_level() > 0:
#gtk.main_quit() - why...? Exit code 0 is bad for IDEs.
sys.exit(1)
break
else:
break
dialog.destroy()
exception_dialog_active = False
def run(self):
default_text = """What steps will reproduce the problem?
1.
2.
3.
What is the expected output? What do you see instead?
What operating system are you using?
Please provide any additional information below:
"""
msg = 'Please provide the following information about the bug\n'
self.set_markup(msg)
#create the text input field
summary_entry = gtk.Entry()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
description_text_view = gtk.TextView()
description_text_view.set_size_request(240, 300)
description_text_view.set_wrap_mode(gtk.WRAP_WORD)
buffer = description_text_view.get_buffer()
buffer.set_text(default_text)
sw.add(description_text_view)
#create a horizontal box to pack the entry and a label
summary_hbox = gtk.HBox()
summary_hbox.pack_start(gtk.Label("Summary "), False, 5, 5)
summary_hbox.pack_end(summary_entry)
description_hbox = gtk.HBox()
description_hbox.pack_start(gtk.Label("Description"), False, 5, 5)
description_hbox.pack_start(sw, True, True, 0)
#add it and show it
self.vbox.pack_start(summary_hbox, True, True, 0)
self.vbox.pack_start(description_hbox, True, True, 0)
self.show_all()
# Go go go
gtk_response = super(dlg_ask_bug_info, self).run()
# The user closed the dialog with the X
if gtk_response == gtk.RESPONSE_DELETE_EVENT:
return True, None, None
summary = summary_entry.get_text()
description = buffer.get_text(buffer.get_start_iter(),
buffer.get_end_iter())
self.destroy()
return False, summary, description
def __init__(self):
gtk.Window.__init__(self)
bus = dbus.SessionBus()
tracker = bus.get_object(TRACKER, TRACKER_OBJ)
self.iface = dbus.Interface(tracker,
"org.freedesktop.Tracker1.Resources")
vbox = gtk.VBox()
# Post frame
post_frame = gtk.Frame("Post")
post_frame_vbox = gtk.VBox()
post_frame.add(post_frame_vbox)
# Title
title_label = gtk.Label("Title")
self.title_entry = gtk.Entry()
title_hbox = gtk.HBox()
title_hbox.add(title_label)
title_hbox.add(self.title_entry)
post_frame_vbox.add(title_hbox)
uri_label = gtk.Label("Uri")
self.uri_entry = gtk.Entry()
hbox_uri = gtk.HBox()
hbox_uri.add(uri_label)
hbox_uri.add(self.uri_entry)
self.uri_entry.set_property("sensitive", False)
post_frame_vbox.add(hbox_uri)
date_label = gtk.Label("Date")
self.date_entry = gtk.Entry()
self.date_entry.set_property("editable", False)
date_hbox = gtk.HBox()
date_hbox.add(date_label)
date_hbox.add(self.date_entry)
post_frame_vbox.add(date_hbox)
self.post_text = gtk.TextView()
post_frame_vbox.add(self.post_text)
button_gen = gtk.Button(stock=gtk.STOCK_NEW)
button_gen.connect("clicked", self.gen_new_post_cb)
post_frame_vbox.add(button_gen)
vbox.add(post_frame)
button_new = gtk.Button(stock=gtk.STOCK_ADD)
button_new.connect("clicked", self.clicked_add_cb)
vbox.pack_start(button_new, expand=False)
button_remove = gtk.Button(stock=gtk.STOCK_REMOVE)
button_remove.connect("clicked", self.clicked_remove_cb)
vbox.pack_start(button_remove, expand=False)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
self.last_inserted = None
gtk.main()
def build_widget(self):
"""Build the evaluator widget.
"""
vbox = gtk.VBox()
tb = gtk.Toolbar()
tb.set_style(gtk.TOOLBAR_ICONS)
# Use small toolbar button everywhere
gtk.settings_get_default().set_property('gtk_toolbar_icon_size',
gtk.ICON_SIZE_SMALL_TOOLBAR)
for (icon, tip, action) in (
(gtk.STOCK_SAVE, "Save output window (C-s)", self.save_output_cb),
(gtk.STOCK_CLEAR, "Clear output window", self.clear_output),
(gtk.STOCK_DELETE, "Clear expression (C-l)",
self.clear_expression),
(gtk.STOCK_EXECUTE, "Evaluate expression (C-Return)",
self.evaluate_expression),
(gtk.STOCK_ADD, "Add a bookmark (C-b)", self.add_bookmark),
(gtk.STOCK_REMOVE, "Remove a bookmark", self.remove_bookmark),
(gtk.STOCK_INDEX, "Display bookmarks (C-Space)",
self.display_bookmarks),
):
b = gtk.ToolButton(icon)
b.connect('clicked', action)
b.set_tooltip_text(tip)
tb.insert(b, -1)
# So that applications can define their own buttons
self.toolbar = tb
vbox.pack_start(tb, expand=False)
self.source = gtk.TextView()
self.source.set_editable(True)
self.source.set_wrap_mode(gtk.WRAP_CHAR)
f = gtk.Frame("Expression")
s = gtk.ScrolledWindow()
s.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
s.add(self.source)
f.add(s)
vbox.pack_start(f, expand=False)
self.output = gtk.TextView()
self.output.set_editable(False)
self.output.set_wrap_mode(gtk.WRAP_CHAR)
f = gtk.Frame("Result")
self.resultscroll = gtk.ScrolledWindow()
self.resultscroll.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.resultscroll.add(self.output)
self.resultscroll.set_size_request(-1, 200)
f.add(self.resultscroll)
if self.display_info_widget:
self.logwidget = gtk.TextView()
self.logbuffer = self.logwidget.get_buffer()
sw = gtk.ScrolledWindow()
sw.add(self.logwidget)
pane = gtk.VPaned()
vbox.add(pane)
pane.add1(f)
pane.pack2(sw)
else:
vbox.add(f)
self.source.connect('key-press-event', self.key_pressed_cb)
self.output.connect('key-press-event', self.key_pressed_cb)
self.statusbar = gtk.Statusbar()
self.statusbar.set_has_resize_grip(False)
vbox.pack_start(self.statusbar, expand=False)
vbox.show_all()
return vbox
def create_window(self):
"""Create the main application window"""
self.window = gtk.Window()
self.window.connect('destroy', lambda w: gtk.main_quit())
self.window.resize(800, 600)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title(APP_NAME)
if appicon_path and os.path.exists(appicon_path):
self.window.set_icon_from_file(appicon_path)
vbox = gtk.VBox()
self.window.add(vbox)
# add menubar
vbox.pack_start(self.create_menubar(), False)
# add toolbar
self.toolbar = self.create_toolbar()
vbox.pack_start(self.toolbar, False)
# split main window
hbox = gtk.HBox(homogeneous=False, spacing=10)
vbox.pack_start(hbox, True)
# add operations to left
operations = self.create_operations_box()
hbox.pack_start(operations, False)
# create the right side of the window
right_box = gtk.VBox()
self.progressbar = gtk.ProgressBar()
right_box.pack_start(self.progressbar, False)
# add output display on right
self.textbuffer = gtk.TextBuffer()
swindow = gtk.ScrolledWindow()
swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView(self.textbuffer)
self.textview.set_editable(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
swindow.add(self.textview)
right_box.add(swindow)
hbox.add(right_box)
# add markup tags
tt = self.textbuffer.get_tag_table()
style_operation = gtk.TextTag('operation')
style_operation.set_property('size-points', 14)
style_operation.set_property('weight', 700)
tt.add(style_operation)
style_option_label = gtk.TextTag('option_label')
style_option_label.set_property('weight', 700)
tt.add(style_option_label)
style_operation = gtk.TextTag('error')
style_operation.set_property('foreground', '#b00000')
tt.add(style_operation)
# add status bar
self.status_bar = gtk.Statusbar()
vbox.pack_start(self.status_bar, False)
# setup drag&drop
self.setup_drag_n_drop()
# done
self.window.show_all()
self.progressbar.hide()
return
def __init__(self, tutor):
debug.mainthreadTest()
for menuitem in mainmenu.OOF.Help.Tutorials.items:
menuitem.disable()
subWindow.SubWindow.__init__(self, title=tutor.subject, menu="")
self.subwindow_menu.File.addItem(
oofmenu.OOFMenuItem(
'Save_Text',
callback=self.savePrintable,
params=[
filenameparam.WriteFileNameParameter('filename',
ident="FileMenu"),
filenameparam.WriteModeParameter('mode')
],
help="Save the text of this tutorial in a file.",
no_log=1,
ordering=-1))
labelhbox = gtk.HBox()
self.subject = gtk.Label()
self.slideIndex = gtk.Label()
labelhbox.pack_start(self.subject, expand=1, fill=1, padding=2)
labelhbox.pack_end(self.slideIndex, expand=0, fill=0, padding=2)
self.mainbox.pack_start(labelhbox, expand=0, fill=0, padding=2)
self.msgscroll = gtk.ScrolledWindow()
self.scrollsignals = gtklogger.logScrollBars(self.msgscroll,
"TutorialScroll")
self.msgscroll.set_shadow_type(gtk.SHADOW_IN)
self.msgscroll.set_border_width(2)
self.msgscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.mainbox.pack_start(self.msgscroll, expand=1, fill=1)
self.textview = gtk.TextView()
self.textview.set_cursor_visible(False)
self.textview.set_editable(False)
textattrs = self.textview.get_default_attributes()
self.centerImageTag = self.textview.get_buffer().create_tag(
'center-image', justification=gtk.JUSTIFY_CENTER)
self.boldTag = self.textview.get_buffer().create_tag(
"bold",
weight=pango.WEIGHT_BOLD, # why doesn't this work?
foreground="blue")
## self.boldTag = self.textview.get_buffer().create_tag(
## "bold",
## weight=pango.WEIGHT_HEAVY, # why doesn't this work?
## underline=pango.UNDERLINE_SINGLE)
self.textview.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.msgscroll.add(self.textview)
buttonbox = gtk.HBox(homogeneous=1, spacing=2)
self.mainbox.pack_end(buttonbox, expand=0, fill=0, padding=2)
self.backbutton = gtkutils.StockButton(gtk.STOCK_GO_BACK, "Back")
gtklogger.setWidgetName(self.backbutton, "Back")
gtklogger.connect(self.backbutton, "clicked", self.backCB)
tooltips.set_tooltip_text(self.backbutton,
"Move to the previous slide.")
self.nextbutton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD, "Next")
gtklogger.setWidgetName(self.nextbutton, "Next")
gtklogger.connect(self.nextbutton, "clicked", self.nextCB)
tooltips.set_tooltip_text(self.nextbutton, "Move to the next slide.")
self.jumpbutton = gtkutils.StockButton(gtk.STOCK_GOTO_LAST, "Jump")
gtklogger.setWidgetName(self.jumpbutton, "Jump")
gtklogger.connect(self.jumpbutton, "clicked", self.jumpCB)
tooltips.set_tooltip_text(self.jumpbutton,
"Jump to the leading slide.")
self.savebutton = gtkutils.StockButton(gtk.STOCK_SAVE, "Save...")
gtklogger.setWidgetName(self.savebutton, "Save")
gtklogger.connect(self.savebutton, "clicked", self.saveCB)
tooltips.set_tooltip_text(self.savebutton,
"Save your tutorial session.")
self.closebutton = gtkutils.StockButton(gtk.STOCK_CLOSE, "Close")
gtklogger.setWidgetName(self.closebutton, "Close")
gtklogger.connect(self.closebutton, "clicked", self.closeCB)
tooltips.set_tooltip_text(self.closebutton, "Quit the tutorial.")
buttonbox.pack_start(self.backbutton, expand=1, fill=1, padding=2)
buttonbox.pack_start(self.nextbutton, expand=1, fill=1, padding=2)
buttonbox.pack_start(self.jumpbutton, expand=1, fill=1, padding=2)
buttonbox.pack_start(self.savebutton, expand=1, fill=1, padding=2)
buttonbox.pack_end(self.closebutton, expand=1, fill=1, padding=2)
self.gtk.connect('destroy', self.closeCB)
self.gtk.set_default_size(500, 300)
self.progress = 0 # How far has the tutorial gone?
# It's not affected by "Back" command.
self.index = 0 # which slide?
self.signalReceived = 0 # Received a signal, if any.
self.tutor = tutor
self.newLesson()
self.tutor.lessons[0].activate()
self.saved = None # if saved or not
switchboard.requestCallbackMain("task finished", self.signalCB)
def show(self):
# setup environment
self.env = {
"app": self.app,
"window": self.main_window,
"info": self.print_info
}
# create dialog
self.dialog = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.dialog.connect("delete-event", lambda d, r: self.dialog.destroy())
self.dialog.ptr = self
self.dialog.set_default_size(400, 400)
self.vpaned = gtk.VPaned()
self.dialog.add(self.vpaned)
self.vpaned.set_position(200)
# editor buffer
self.editor = gtk.TextView()
self.editor.connect("key-press-event", self.on_key_press_event)
f = pango.FontDescription("Courier New")
self.editor.modify_font(f)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(self.editor)
self.vpaned.add1(sw)
# output buffer
self.output = gtk.TextView()
self.output.set_wrap_mode(gtk.WRAP_WORD)
f = pango.FontDescription("Courier New")
self.output.modify_font(f)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(self.output)
self.vpaned.add2(sw)
self.output.get_buffer().tag_table.add(self.error_tag)
self.output.get_buffer().tag_table.add(self.info_tag)
self.dialog.show_all()
if self._TAG == 0:
self.output_text("Press Ctrl+Enter to execute. Ready...\n", "info")
elif self._TAG == 1:
self.output_text(
"Press Ctrl+Enter to save the Caption. Ready...\n", "info")
elif self._TAG == 2:
self.output_text("Press Ctrl+Enter to save the Label. Ready...\n",
"info")
elif self._TAG == 3:
self.output_text(
"Press Ctrl+Enter to inser the Equation. Ready...\n", "info")
elif self._TAG == 4:
self.output_text(
"Press Ctrl+Enter to save the Equation. Ready...\n", "info")
def __init__(self, parent=None):
#region Window init
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_default_size(600, 600)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=200, min_height=100)
#endregion
#region TextView
textview = gtk.TextView()
textbuffer = textview.get_buffer()
textbuffer.set_text(text)
textview.set_wrap_mode(gtk.WRAP_WORD)
sw1 = gtk.ScrolledWindow()
sw1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.add(sw1)
sw1.add(textview)
#endregion
#region Search Backtick and set invisible, markup
visibility_tag = textbuffer.create_tag(None, invisible=True)
tag = textbuffer.create_tag(None,
background="lightgrey",
background_full_height=True,
style=pango.STYLE_OBLIQUE,
font="Inconsolta")
tag_string = "`"
start, end = textbuffer.get_bounds()
tag_start = None
tag_end = None
searching = True
count = 0
while searching:
try:
match_start, match_end = start.forward_search(
tag_string, gtk.TEXT_SEARCH_TEXT_ONLY, limit=None)
if not count % 2:
# first
tag_start = match_start.copy()
tag_start.forward_char()
else:
# second
tag_end = match_end.copy()
tag_end.backward_char()
textbuffer.apply_tag(tag, tag_start, tag_end)
textbuffer.apply_tag(visibility_tag, match_start, match_end)
start = match_end
count = count + 1
except:
searching = False
print "Found the Tag-Marker: " + tag_string, count, "times"
#endregion
self.show_all()
def __init__(self, filename):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_title("ascii flow")
# the gaphas canvas object
canvas = gaphas.Canvas()
hbox = gtk.HBox()
self.window.add(hbox)
# side bar
vbox = gtk.VBox()
# open button
button = gtk.Button("Open File")
def click_open(widget):
chooser = gtk.FileChooserDialog(
title=None,
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN,
gtk.RESPONSE_OK))
filter = gtk.FileFilter()
filter.set_name("All Files")
filter.add_pattern("*.txt")
chooser.add_filter(filter)
response = chooser.run()
filename = chooser.get_filename()
chooser.destroy()
if response == gtk.RESPONSE_OK:
if self._notebook.get_current_page() != 0:
self._notebook.set_current_page(0)
while gtk.events_pending():
gtk.main_iteration()
data = open(filename, 'r').read()
load_canvas(canvas, data)
button.connect("clicked", click_open)
vbox.pack_start(button, expand=False)
# add box button
button = gtk.Button("Add Box")
def click_add_box(widget):
view.tool.grab(
gaphas.tool.PlacementTool(view, item_factory(view, gaphs.Box),
gaphas.tool.HandleTool(), 1))
button.connect("clicked", click_add_box)
vbox.pack_start(button, expand=False)
# add line button
button = gtk.Button("Add Line")
def click_add_line(widget):
view.tool.grab(
gaphas.tool.PlacementTool(view, item_factory(view, gaphs.Line),
gaphas.tool.HandleTool(), 1))
button.connect("clicked", click_add_line)
vbox.pack_start(button, expand=False)
# add delete button
button = gtk.Button("Delete Selected")
def click_delete_selected(widget):
while view.selected_items:
for item in view.selected_items:
canvas.remove(item)
break
button.connect("clicked", click_delete_selected)
vbox.pack_start(button, expand=False)
# dashed checkbox
cb_dashed = gtk.CheckButton("Dashed")
cb_dashed.hide()
vbox.pack_start(cb_dashed, expand=False)
def cb_dashed_toggled(cb):
items = view.selected_items
if items:
for b in items:
b.dashed = cb.get_active()
view.queue_draw_refresh()
cb_dashed.connect("toggled", cb_dashed_toggled)
hbox.pack_start(vbox, expand=False)
# gaphas view
view = gaphas.GtkView()
view.canvas = canvas
view.painter = create_painter_chain()
view.tool = create_tool_chain()
view.set_size_request(600, 400)
def selection_changed(view, items):
if items:
print '---'
for b in items:
print b.positions
for b in items:
cb_dashed.set_active(b.dashed)
break
cb_dashed.show()
else:
cb_dashed.hide()
view.connect("selection-changed", selection_changed)
# ascii view
asciiview = gtk.TextView()
buffer = gtk.TextBuffer()
asciiview.set_buffer(buffer)
pangoFont = pango.FontDescription("Courier 11")
asciiview.modify_font(pangoFont)
# renderview
renderview = gtk.Image()
# notebook
notebook = gtk.Notebook()
notebook.append_page(view, gtk.Label("Vectors"))
notebook.append_page(asciiview, gtk.Label("Ascii"))
notebook.append_page(renderview, gtk.Label("Render"))
def switch_page(notebook, page, page_num):
if notebook.loaded:
# set text
if notebook.last_page_num == 0:
ascii = serializer.serialize(canvas.get_all_items())
text = ""
for line in ascii:
text += line + "\n"
else:
text = buffer.get_text(buffer.get_start_iter(),
buffer.get_end_iter())
# init current page
if page_num == 0:
# set vector view
load_canvas(canvas, text)
if page_num == 1:
# set ascii view
buffer.set_text(text)
if page_num == 2:
# set ascii view
buffer.set_text(text)
# set render view
txt_filename = ".tempfile.txt"
img_filename = ".tempfile.png"
java = r'"C:\Program Files (x86)\Java\jre6\bin\javaw.exe"'
open(txt_filename, "w").write(text)
subprocess.Popen("%s -jar ditaa0_9.jar %s -o" %
(java, txt_filename)).wait()
renderview.set_from_file(img_filename)
notebook.loaded = True
notebook.last_page_num = page_num
notebook.connect("switch-page", switch_page)
notebook.loaded = False
notebook.last_page_num = -1
self._notebook = notebook
hbox.add(notebook)
# load file
if filename:
data = open(filename, 'r').read()
load_canvas(canvas, data)
self.window.show_all()
CURRENT_PROBLEM = None
REPOSITORY = "http://128.199.122.193/macrojudge/repository/"
COMPILER = "gcc"
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("delete-event", gtk.main_quit)
window.resize(500, 500)
main_vbox = gtk.VBox()
text_hbox = gtk.HBox()
text_hbox.set_homogeneous(True)
description_text = gtk.TextView()
description_text.set_wrap_mode(True)
description_text.modify_font(pango.FontDescription("monospaced 10"))
description_scroll = gtk.ScrolledWindow()
description_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
description_scroll.add(description_text)
code_text = gtk.TextView()
code_text.modify_font(pango.FontDescription("monospaced 10"))
code_scroll = gtk.ScrolledWindow()
code_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
code_scroll.add(code_text)
right_vbox = gtk.VBox()
def __init__(self):
super(LogsGUI, self).__init__()
self.log_mask = ['DEBUG', 'INFO', 'WARNING', 'ERROR']
#self.set_size_request(400, 300)
self.set_border_width(8)
table = gtk.Table(8, 5, False)
table.set_col_spacings(3)
title = gtk.Label("""\
<span size='12000'>Open Monitor Desktop Agent Logs: \n</span>""")
title.set_use_markup(True)
halign = gtk.Alignment(0, 0, 0, 0)
halign.add(title)
table.attach(halign, 0, 1, 0, 1, gtk.FILL, gtk.FILL, 0, 0);
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView()
self.textview.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 5)
self.textbuffer = self.textview.get_buffer()
self.textview.set_editable(True)
self.textview.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(5140, 5140, 5140))
self.textview.set_cursor_visible(True)
self.textview.show()
self.sw.add(self.textview)
self.sw.show()
table.attach(self.sw, 0, 1, 1, 3)
vbox = gtk.VBox()
btnbox = gtk.VButtonBox()
btnbox.set_border_width(5)
btnbox.set_layout(gtk.BUTTONBOX_START)
btnbox.set_spacing(5)
self.checkbtn_error = gtk.CheckButton("ERROR")
self.checkbtn_warning = gtk.CheckButton("WARNING")
self.checkbtn_info = gtk.CheckButton("INFO")
self.checkbtn_debug = gtk.CheckButton("DEBUG")
self.checkbtn_error.set_active(True)
self.checkbtn_warning.set_active(True)
self.checkbtn_info.set_active(True)
self.checkbtn_debug.set_active(True)
self.checkbtn_error.connect('toggled', lambda x: self.change_mask())
self.checkbtn_warning.connect('toggled', lambda x: self.change_mask())
self.checkbtn_info.connect('toggled', lambda x: self.change_mask())
self.checkbtn_debug.connect('toggled', lambda x: self.change_mask())
vbox.add(self.checkbtn_error)
vbox.add(self.checkbtn_warning)
vbox.add(self.checkbtn_info)
vbox.add(self.checkbtn_debug)
table.attach(vbox, 3, 4, 1, 2, gtk.FILL, gtk.SHRINK, 1, 1)
halign2 = gtk.Alignment(0, 1, 0, 0)
table.attach(halign2, 4, 5, 0, 1, gtk.FILL, gtk.FILL, 0, 0)
self.add(table)
self.refresh()
gobject.timeout_add(5000, self.refresh)
def __init__(self, bdaddr, channel, outfile=None):
self.cust_file_path = None
self.cust_file_data = None
self.cust_file_binary = 0
self.bdaddr = bdaddr
self.channel = channel
self.outfile = outfile
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.mainbox = gtk.HBox()
self.win.add(self.mainbox)
self.apphbox = gtk.VBox()
self.apphbox2 = gtk.VBox()
self.mainbox.add(self.apphbox)
self.mainbox.add(self.apphbox2)
self.uriframe = gtk.Frame("URI")
self.apphbox.add(self.uriframe)
self.urivbox = gtk.VBox()
self.uriframe.add(self.urivbox)
self.spframe = gtk.Frame("SmartPoster")
self.apphbox.add(self.spframe)
self.spvbox = gtk.VBox()
self.spframe.add(self.spvbox)
self.custvbox = gtk.VBox()
self.custframe = gtk.Frame("Mime-Type")
self.apphbox2.add(self.custframe)
self.custframe.add(self.custvbox)
self.uriapp_uri = gtk.TextView()
self.uriapp_uri.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.urivbox.add(self.uriapp_uri)
self.uriapp_genbut = gtk.Button("Write")
self.uriapp_genbut.connect("clicked", self.uri_button)
self.urivbox.add(self.uriapp_genbut)
self.spvbox.add(gtk.Label("URI"))
self.spapp_uri = gtk.TextView()
self.spapp_uri.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.spvbox.add(self.spapp_uri)
self.spapp_title = gtk.TextView()
self.spapp_title.set_wrap_mode(gtk.WRAP_WORD_CHAR)
#self.spapp_title.set_border_window_size(gtk.TEXT_WINDOW_TOP, 5)
self.spvbox.add(gtk.Label("Title"))
self.spvbox.add(self.spapp_title)
self.spapp_genbut = gtk.Button("Write")
self.spapp_genbut.connect("clicked", self.sp_button)
self.spvbox.add(self.spapp_genbut)
self.custvbox.add(gtk.Label("Mime-Type"))
self.custapp_mime_type = gtk.TextView()
self.custapp_mime_type.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.custvbox.add(self.custapp_mime_type)
self.custapp_data = gtk.TextView()
self.custapp_data.set_wrap_mode(gtk.WRAP_WORD_CHAR)
#self.custapp_data.set_border_window_size(gtk.TEXT_WINDOW_TOP, 5)
self.custvbox.add(gtk.Label("Data"))
self.custvbox.add(self.custapp_data)
self.custapp_loadbut = gtk.FileChooserButton("Load File")
self.custapp_loadbut.connect("selection-changed", self.file_selected)
self.custapp_genbut = gtk.Button("Write")
self.custapp_genbut.connect("clicked", self.mime_button)
self.custapp_clearbut = gtk.Button("Clear/Reset")
self.custapp_clearbut.connect("clicked", self.clear_button)
self.custvbox.add(self.custapp_loadbut)
self.custvbox.add(self.custapp_clearbut)
self.custvbox.add(self.custapp_genbut)
self.win.connect("delete-event", self.exit_event)
self.win.resize(800, 480)
self.win.show_all()
def __init__(self, handle):
'''Constructor'''
activity.Activity.__init__(self, handle)
self.main_container = gtk.HBox()
toolbox = widgets.ActivityToolbox(self)
self.set_toolbar_box(toolbox)
toolbox.show()
self.path = self.get_activity_root()
###left side###
self.left_container = gtk.VBox()
d = datetime.today()
self.label_date = gtk.Label(d.strftime("%d %B %Y"))
self.calendar = gtk.Calendar()
self.calendar.connect('day-selected', self._day_selected_cb)
self.calendar.connect('month-changed', self._mark_day_cb)
self.calendar.connect('next-year', self._mark_day_cb)
self.calendar.connect('prev-year', self._mark_day_cb)
self.mark_day()
self.tool_frame = gtk.Frame(_("Tools"))
self.reminder_expander = gtk.Expander(_("Tasks reminder"))
self.query_expander = gtk.Expander(_("View by"))
self.tool_box = gtk.VBox()
#reminder
self.scroll_reminder = gtk.ScrolledWindow()
self.scroll_reminder.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scroll_reminder.set_size_request(-1, 170)
self.reminder_list = gtk.TreeView()
self.scroll_reminder.add(self.reminder_list)
self.reminder_expander.add(self.scroll_reminder)
#query
self.query_box = gtk.VBox()
self.label_q_priority = gtk.Label(_("Priority"))
self.label_q_category = gtk.Label(_("Category"))
comboBoxModel = ComboBoxModel()
cat_model = comboBoxModel.get_category_model()
pri_model = comboBoxModel.get_priority_model()
cell = gtk.CellRendererText()
self.combobox_q_priority = gtk.ComboBox()
self.combobox_q_priority.pack_start(cell, True)
self.combobox_q_priority.add_attribute(cell, 'text', 0)
self.combobox_q_category = gtk.ComboBox()
self.combobox_q_category.pack_start(cell, True)
self.combobox_q_category.add_attribute(cell, 'text', 0)
self.combobox_q_category.set_model(cat_model)
self.combobox_q_priority.set_model(pri_model)
self.filter_button = gtk.Button(_('Filter'))
self.filter_button.connect('clicked', self._filter_query_cb)
self.query_box.pack_start(self.label_q_priority, False)
self.query_box.pack_start(self.combobox_q_priority, False)
self.query_box.pack_start(self.label_q_category, False)
self.query_box.pack_start(self.combobox_q_category, False)
self.query_box.pack_start(self.filter_button, True, True, 5)
self.query_expander.add(self.query_box)
self.tool_box.pack_start(self.reminder_expander, False)
self.tool_box.pack_start(self.query_expander, False)
self.tool_frame.add(self.tool_box)
self.left_container.pack_start(self.label_date, False, False, 5)
self.left_container.pack_start(self.calendar, False)
self.left_container.pack_start(self.tool_frame, True, True, 5)
###right side###
self.right_container = gtk.VBox()
self.tasks_frame = gtk.Frame(_("Tasks list"))
self.scroll_tasks = gtk.ScrolledWindow()
self.scroll_tasks.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.tasks_list = gtk.TreeView()
self.get_tasks()
self.add_columns()
self.scroll_tasks.add(self.tasks_list)
self.tasks_frame.add(self.scroll_tasks)
#options
self.options_expander = gtk.Expander(_("Options"))
self.options_box = gtk.HBox()
self.label_b_priority = gtk.Label(_("Priority"))
self.combobox_priority = gtk.ComboBox()
self.combobox_priority.pack_start(cell, True)
self.combobox_priority.add_attribute(cell, 'text', 0)
self.label_b_category = gtk.Label(_("Category"))
self.combobox_category = gtk.ComboBox()
self.combobox_category.pack_start(cell, True)
self.combobox_category.add_attribute(cell, 'text', 0)
self.combobox_category.set_model(cat_model)
self.combobox_priority.set_model(pri_model)
self.priority_box = gtk.VBox()
self.priority_box.pack_start(self.label_b_priority)
self.priority_box.pack_start(self.combobox_priority)
self.category_box = gtk.VBox()
self.category_box.pack_start(self.label_b_category)
self.category_box.pack_start(self.combobox_category)
self.options_box.pack_start(self.category_box, True, True, 5)
self.options_box.pack_start(self.priority_box, True, True, 5)
self.options_expander.add(self.options_box)
#input
self.scroll_text = gtk.ScrolledWindow()
self.scroll_text.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.text_input = gtk.TextView()
self.text_input.set_size_request(0, 80)
self.scroll_text.add(self.text_input)
self.save_button = gtk.Button(_("Add new"))
self.save_button.connect('clicked', self._save_cb)
self.remove_button = gtk.Button(_("Remove"))
self.remove_button.connect('clicked', self._delete_row_cb)
self.buttons_box = gtk.VBox()
self.buttons_box.pack_start(self.save_button, False)
self.buttons_box.pack_start(self.remove_button, False)
self.input_box = gtk.HBox()
self.input_box.pack_start(self.scroll_text, True, True, 5)
self.input_box.pack_start(self.buttons_box, False)
self.right_container.pack_start(self.tasks_frame, True, True, 5)
self.right_container.pack_start(self.options_expander, False, False)
self.right_container.pack_start(self.input_box, False, False, 5)
self.main_container.pack_start(self.left_container, False, False, 5)
self.main_container.pack_start(self.right_container, True, True, 5)
self.main_container.show_all()
self.set_canvas(self.main_container)
def __init__(self):
gtk.Alignment.__init__(self)
self.__gobject_init__()
self._pkg = None
self._changeset = None
font = self.style.font_desc.copy()
font.set_size(font.get_size() - pango.SCALE)
boldfont = font.copy()
boldfont.set_weight(pango.WEIGHT_BOLD)
self._notebook = gtk.Notebook()
self._notebook.show()
self.add(self._notebook)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
#sw.set_border_width(5)
sw.show()
table = gtk.Table()
table.set_row_spacings(2)
table.set_col_spacings(5)
table.set_border_width(5)
table.show()
sw.add_with_viewport(table)
self._info = type("Info", (), {})()
attrsleft = pango.AttrList()
attrsleft.insert(pango.AttrFontDesc(font, 0, -1))
attrsright = pango.AttrList()
attrsright.insert(pango.AttrFontDesc(boldfont, 0, -1))
row = 0
for attr, text in [("status", _("Status:")),
("priority", _("Priority:")),
("group", _("Group:")),
("installedsize", _("Installed Size:")),
("channels", _("Channels:"))]:
label = gtk.Label(text)
label.set_attributes(attrsleft)
if attr == "channels":
label.set_alignment(1.0, 0.0)
else:
label.set_alignment(1.0, 0.5)
label.show()
table.attach(label, 0, 1, row, row + 1, gtk.FILL, gtk.FILL)
setattr(self._info, attr + "_label", label)
label = gtk.Label()
label.set_attributes(attrsright)
label.set_alignment(0.0, 0.5)
label.show()
table.attach(label, 1, 2, row, row + 1, gtk.FILL, gtk.FILL)
setattr(self._info, attr, label)
row += 1
label = gtk.Label(_("General"))
self._notebook.append_page(sw, label)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_border_width(5)
sw.show()
self._descrtv = gtk.TextView()
self._descrtv.set_editable(False)
self._descrtv.set_cursor_visible(False)
self._descrtv.set_left_margin(5)
self._descrtv.set_right_margin(5)
self._descrtv.show()
buffer = self._descrtv.get_buffer()
buffer.create_tag("description", font_desc=font)
buffer.create_tag("summary", font_desc=boldfont)
sw.add(self._descrtv)
label = gtk.Label(_("Description"))
self._notebook.append_page(sw, label)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_border_width(5)
sw.show()
self._conttv = gtk.TextView()
self._conttv.set_editable(False)
self._conttv.set_cursor_visible(False)
self._conttv.set_left_margin(5)
self._conttv.set_right_margin(5)
self._conttv.show()
buffer = self._conttv.get_buffer()
buffer.create_tag("content", font_desc=font)
sw.add(self._conttv)
label = gtk.Label(_("Content"))
self._notebook.append_page(sw, label)
self._relations = GtkPackageView()
self._relations.set_border_width(5)
self._relations.getTreeView().set_headers_visible(False)
self._relations.show()
label = gtk.Label(_("Relations"))
self._notebook.append_page(self._relations, label)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_border_width(5)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.show()
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
self._urls = gtk.TreeView(model)
self._urls.set_headers_visible(False)
self._urls.show()
renderer = gtk.CellRendererText()
renderer.set_property("font-desc", font)
self._urls.insert_column_with_attributes(-1,
_("Channel"),
renderer,
text=0)
self._urls.insert_column_with_attributes(-1,
_("Size"),
renderer,
text=1)
self._urls.insert_column_with_attributes(-1,
_("URL"),
renderer,
text=2)
sw.add(self._urls)
label = gtk.Label(_("URLs"))
self._notebook.append_page(sw, label)
self._notebook.connect("switch_page", self._switchPage)
def __init__(self):
win = gtk.Window()
win.set_position(gtk.WIN_POS_CENTER)
win.set_title("CodeChat")
win.set_icon_name("gtk-dialog-info")
win.connect("destroy", win_quit)
leftEvent = gtk.EventBox()
rightEvent = gtk.EventBox()
#// main horizontal container, equal 1px spacing
mainBox = gtk.HBox(True, 1)
leftFrame = gtk.Frame("editor")
rightFrame = gtk.Frame("chat")
#// left and right containers, spacing not equal
leftVBox = gtk.VBox(False, 1)
rightVBox = gtk.VBox(False, 1)
#// build up the left side
editWindow = gtk.ScrolledWindow(None, None)
editWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
editWindow.set_shadow_type(gtk.SHADOW_IN)
self.EditBuffer = gtksourceview2.Buffer()
self.EditLangMgr = gtksourceview2.LanguageManager()
self.EditBuffer.set_highlight_syntax(True)
self.EditBuffer.set_highlight_matching_brackets(True)
lang = self.EditLangMgr.get_language("python")
self.EditBuffer.set_language(lang)
self.EditView = gtksourceview2.View(self.EditBuffer)
self.EditView.set_highlight_current_line(True)
self.EditView.set_show_line_numbers(True)
self.EditView.modify_font(pango.FontDescription("Monospace 8"))
self.EditStatusBar = gtk.Statusbar()
editWindow.add(self.EditView)
leftVBox.pack_start(editWindow, True, True, 1)
leftVBox.pack_end(self.EditStatusBar, False, False, 2)
leftFrame.add(leftVBox)
#// build up the right side
chatWindow = gtk.ScrolledWindow(None, None)
chatWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
chatWindow.set_shadow_type(gtk.SHADOW_IN)
chatTagTable = gtk.TextTagTable()
self.ChatBuffer = gtk.TextBuffer(chatTagTable)
self.ChatView = gtk.TextView(self.ChatBuffer)
self.ChatView.set_editable(False)
self.ChatView.set_cursor_visible(False)
chatWindow.add(self.ChatView)
chatHBox = gtk.HBox(False, 0)
self.MessageBuffer = gtk.EntryBuffer("", -1)
self.ChatEntry = gtk.Entry()
self.ChatEntry.set_buffer(self.MessageBuffer)
self.SendBtn = gtk.Button("send")
chatHBox.pack_start(self.ChatEntry, True, True, 0)
chatHBox.pack_end(self.SendBtn, False, False, 0)
rightVBox.pack_start(chatWindow, True, True, 1)
rightVBox.pack_start(chatHBox, False, False, 0)
rightFrame.add(rightVBox)
leftEvent.add(leftFrame)
rightEvent.add(rightFrame)
#// set up interface + layout
mainBox.pack_start(leftEvent, True, True, 0)
mainBox.pack_start(rightEvent, True, True, 0)
#// Show the window
win.add(mainBox)
win.set_size_request(800, 400)
win.show_all()
self.conclient = client.ConnectionClient()
#we need to query the user for username and connection info
self.dialog = gtk.Dialog("Connection Dialog", win, gtk.DIALOG_MODAL)
ulabel = gtk.Label("username")
ilabel = gtk.Label("IP Address:Port")
self.uentry = gtk.Entry()
self.ientry = gtk.Entry()
self.dialog.vbox.add(ulabel)
self.dialog.vbox.add(self.uentry)
self.dialog.vbox.add(ilabel)
self.dialog.vbox.add(self.ientry)
self.button = self.dialog.add_button("connect", gtk.RESPONSE_OK)
self.button.connect("clicked", self.connect)
self.ientry.connect("activate", self.connect)
#self.dialog.response(self.connect)
self.dialog.show_all()
response = self.dialog.run()
print("here- after dialog")
#instantiate read thread
self.read_thread = threading.Thread(None, self.doRead, 'read_thread')
self.read_thread.start()
def init(self):
import gtk
self.__sw = gtk.ScrolledWindow()
self.__sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.__view = gtk.TextView()
self.__sw.add(self.__view)
def __init__(self, w3af):
super(KBBrowser, self).__init__(w3af, "pane-kbbrowser", 250)
# Internal variables:
#
# Here I save the request and response ids to be used in the page control
self.req_res_ids = []
# This is to search the DB and print the different request and responses as they are
# requested from the page control, "_pageChange" method.
self._historyItem = HistoryItem()
# the filter to the tree
filterbox = gtk.HBox()
self.filters = {}
def make_but(label, signal, initial):
but = gtk.CheckButton(label)
but.set_active(initial)
but.connect("clicked", self.type_filter, signal)
self.filters[signal] = initial
but.show()
filterbox.pack_start(but, expand=False, fill=False, padding=2)
make_but("Vulnerabilities", "vuln", True)
make_but("Informations", "info", True)
filterbox.show()
# the kb tree
self.kbtree = FullKBTree(w3af, self, self.filters)
# all in the first pane
scrollwin21 = gtk.ScrolledWindow()
scrollwin21.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollwin21.add(self.kbtree)
scrollwin21.show()
# the filter and tree box
treebox = gtk.VBox()
treebox.pack_start(filterbox, expand=False, fill=False)
treebox.pack_start(scrollwin21)
treebox.show()
# the explanation
explan_tv = gtk.TextView()
explan_tv.set_editable(False)
explan_tv.set_cursor_visible(False)
explan_tv.set_wrap_mode(gtk.WRAP_WORD)
self.explanation = explan_tv.get_buffer()
explan_tv.show()
scrollwin22 = gtk.ScrolledWindow()
scrollwin22.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollwin22.add_with_viewport(explan_tv)
scrollwin22.show()
# The request/response viewer
self.rrV = reqResViewer.reqResViewer(w3af, withAudit=False)
self.rrV.set_sensitive(False)
# Create the title label to show the request id
self.title0 = gtk.Label()
self.title0.show()
# Create page changer to handle info/vuln objects that have MORE THAN ONE
# related request/response
self.pagesControl = entries.PagesControl(w3af, self._pageChange, 0)
self.pagesControl.deactivate()
self._pageChange(0)
centerbox = gtk.HBox()
centerbox.pack_start(self.pagesControl, True, False)
# Add everything to a vbox
vbox_rrv_centerbox = gtk.VBox()
vbox_rrv_centerbox.pack_start(self.title0, False, True)
vbox_rrv_centerbox.pack_start(self.rrV, True, True)
vbox_rrv_centerbox.pack_start(centerbox, False, False)
# and show
vbox_rrv_centerbox.show()
self.pagesControl.show()
centerbox.show()
# And now put everything inside the vpaned
vpanedExplainAndView = entries.RememberingVPaned(
w3af, "pane-kbbexplainview", 100)
vpanedExplainAndView.pack1(scrollwin22)
vpanedExplainAndView.pack2(vbox_rrv_centerbox)
vpanedExplainAndView.show()
# pack & show
self.pack1(treebox)
self.pack2(vpanedExplainAndView)
self.show()
def __init__(self):
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title(NAME + " " + VER)
window.set_size_request(300, 222)
window.set_position(gtk.WIN_POS_CENTER)
window.connect("delete_event", lambda w, e: gtk.main_quit())
global dst_entry
global buffer
global statusbar
global conf_file
global sms_counter
global isms_label
sms_counter = 10
if sys.platform == 'win32':
directory = os.path.expanduser("~") + '/pycosmos'
if not os.path.exists(directory):
os.makedirs(directory)
else:
directory = os.path.expanduser("~") + '/.pycosmos'
if not os.path.exists(directory):
os.makedirs(directory)
conf_file = directory + '/pycosmos.conf'
sms_counter_file = directory + '/smsCounter'
try:
with open(sms_counter_file, 'r+') as f:
first_line = f.readline()
words = first_line.split()
today = datetime.datetime.now()
day_of_year = today.timetuple().tm_yday
if int(day_of_year) is int(words[0]):
sms_counter = int(words[1])
else:
to_write = str(day_of_year) + ' ' + str(10)
f.seek(0)
f.truncate()
f.write(to_write)
except IOError as e:
print 'IOError'
vbox = gtk.VBox(False, 2)
window.add(vbox)
window.set_resizable(False)
vbox.show()
hbox = gtk.HBox(False, 2)
dst_label = gtk.Label("Send to : ")
hbox.pack_start(dst_label, False, False, 2)
dst_entry = gtk.Entry(
max=109) # 10 numbers * 10 free sms + 9 seperators
dst_entry.set_text("69")
hbox.pack_start(dst_entry, False, False, 2)
button = gtk.Button(" Send ")
hbox.pack_start(button, False, False, 2)
vbox.pack_start(hbox, False, False, 2)
hbox1 = gtk.HBox(False, 2)
vbox1 = gtk.VBox(False, 2)
msg_label = gtk.Label("Char : ")
vbox1.pack_start(msg_label, False, False, 2)
char_label = gtk.Label("140 left")
vbox1.pack_start(char_label, False, False, 2)
sms_label = gtk.Label("SMS : ")
vbox1.pack_start(sms_label, False, False, 2)
isms_label = gtk.Label(str(sms_counter) + " left")
vbox1.pack_start(isms_label, False, False, 2)
button.connect("clicked", self.on_button_clicked, sms_counter,
isms_label, sms_counter_file)
opt_button = gtk.Button("Options")
opt_button.connect("clicked", self.options, window)
vbox1.pack_start(opt_button, False, False, 2)
about_button = gtk.Button("About")
about_button.connect("clicked", self.about_on_clicked)
vbox1.pack_start(about_button, False, False, 2)
hbox1.pack_start(vbox1, False, False, 2)
textview = gtk.TextView()
textview.set_size_request(220, 90)
textview.set_wrap_mode(gtk.WRAP_WORD)
buffer = textview.get_buffer()
buffer.connect("changed", self.on_change, char_label)
textview.set_accepts_tab(False)
hbox1.pack_start(textview, False, False, 0)
vbox.pack_start(hbox1, False, False, 2)
statusbar = gtk.Statusbar()
vbox.pack_start(statusbar, False, False, 0)
window.show_all()
def __init__(self):
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.text = gtk.TextView()
self.text.set_wrap_mode(True)
self.interpreter = code.InteractiveInterpreter()
self.completer = Completer(self.interpreter.locals)
self.buffer = []
self.history = []
self.banner = banner
self.ps1 = ">>> "
self.ps2 = "... "
self.text.add_events(gtk.gdk.KEY_PRESS_MASK)
self.text.connect("key_press_event", self.key_pressed)
self.current_history = -1
self.mark = self.text.get_buffer().create_mark(
"End",
self.text.get_buffer().get_end_iter(), False)
#setup colors
self.style_banner = gtk.TextTag("banner")
self.style_banner.set_property("foreground", "saddle brown")
self.style_ps1 = gtk.TextTag("ps1")
self.style_ps1.set_property("foreground", "DarkOrchid4")
self.style_ps1.set_property("editable", False)
self.style_ps1.set_property("font", "courier")
self.style_ps2 = gtk.TextTag("ps2")
self.style_ps2.set_property("foreground", "DarkOliveGreen")
self.style_ps2.set_property("editable", False)
self.style_ps2.set_property("font", "courier")
self.style_out = gtk.TextTag("stdout")
self.style_out.set_property("foreground", "midnight blue")
self.style_err = gtk.TextTag("stderr")
self.style_err.set_property("style", pango.STYLE_ITALIC)
self.style_err.set_property("foreground", "red")
self.text.get_buffer().get_tag_table().add(self.style_banner)
self.text.get_buffer().get_tag_table().add(self.style_ps1)
self.text.get_buffer().get_tag_table().add(self.style_ps2)
self.text.get_buffer().get_tag_table().add(self.style_out)
self.text.get_buffer().get_tag_table().add(self.style_err)
self.stdout = OutputStream(self.text, sys.stdout, self.style_out)
self.stderr = OutputStream(self.text, sys.stderr, self.style_err)
sys.stderr = self.stderr
sys.stdout = self.stdout
self.current_prompt = None
self.write_line(self.banner, self.style_banner)
self.prompt_ps1()
self.add(self.text)
self.text.show()
def setup(self):
self.window.set_title("Caminho mais curto entre dois motifs")
self.window.resize(300, 150)
self.type1 = 0
self.type2 = 0
self.motif1 = {
'a': [None, None],
'b': [None, None],
'c': [None, None],
'd': [None, None]
}
self.motif2 = {
'e': [None, None],
'f': [None, None],
'g': [None, None],
'h': [None, None]
}
self.motif1 = {
'a': ['RPL6', 0],
'b': ['RPL37A', 0],
'c': ['M6PR', 0],
'd': ['RPS28', 0]
}
self.motif2 = {
'e': ['ARF5', 0],
'f': ['PNMAL2', 0],
'g': ['RPS15', 0],
'h': ['RAD23A', 0]
}
hobox = gtk.HBox()
for i in range(1, 3):
vbox = gtk.VBox()
if i == 1:
names = self.motif1
else:
names = self.motif2
vbox.add(self.combo(None, self.types, self.on_motif_changed, i))
for k in sorted(names):
hbox = self.entry(" %s " % k.upper(), self.on_entry_changed, i,
k)
hbox.add(
self.combo(None, self.tscp, self.on_combo_changed, i, k))
vbox.add(hbox)
hobox.add(vbox)
vbox.show()
self.container.add(hobox)
hobox.show()
self.container.add(
self.entry('Amostra: ', self.on_entry_changed, 1, 'a'))
self.container.add(
self.entry('Pontuacao Maxima: ', self.on_entry_changed, 1, 'a'))
self.container.add(
self.entry('Pontuacao Minima: ', self.on_entry_changed, 1, 'a'))
self.container.add(
self.entry('Comprimento: ', self.on_entry_changed, 1, 'a'))
button = gtk.Button()
button.set_label('Procurar')
button.connect("clicked", self.run)
button.show()
self.container.add(button)
self.text = gtk.TextView()
self.text.set_size_request(-1, 300)
self.text.show()
self.container.add(self.text)
