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)