def main(): window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_size_request(width, height) window.connect("delete_event", gtk.mainquit) vbox = gtk.VBox() hbox = gtk.HBox() w_e = gtk.Entry(max=64) hbox.add(w_e) hbox.add(gtk.Label("x")) h_e = gtk.Entry(max=64) hbox.add(h_e) set_size_btn = gtk.Button("set size") def set_size(*args): w = int(w_e.get_text()) h = int(h_e.get_text()) print("resizing to %s x %s" % (w, h)) window.resize(w, h) set_size_btn.connect('clicked', set_size) hbox.add(set_size_btn) vbox.add(hbox) btn = gtk.Button("auto resize me") def resize(*args): global width, height width = max(200, (width+20) % 600) height = max(200, (height+20) % 400) print("resizing to %s x %s" % (width, height)) window.resize(width, height) btn.connect('clicked', resize) vbox.add(btn) window.add(vbox) window.show_all() gtk.main() return 0
def main(self): parser = SafeConfigParser() try: parser.read(self.base_folder + '/' + self.CONFIG_FILENAME) self.server = parser.get(self.CONFIG_SECTION, 'server') self.port = parser.getint(self.CONFIG_SECTION, 'port') self.user = parser.get(self.CONFIG_SECTION, 'user') self.password = parser.get(self.CONFIG_SECTION, 'password') self.timeout = parser.getint(self.CONFIG_SECTION, 'timeout') rpc_interval = parser.getint(self.CONFIG_SECTION, 'rpc_interval') except Exception as e : print( e ); self.displayErrorAndExit( "Could not read configuration '"+self.CONFIG_FILENAME+"'\nError is: "+e.message) if parser.has_option(self.CONFIG_SECTION, "rpc_logger_level"): transmissionrpc.utils.add_stdout_logger(parser.get(self.CONFIG_SECTION, 'rpc_logger_level')); self.check_alt_speed_enabled() # The callback function is called repeatedly until it returns False, # at which point the timeout is automatically destroyed and the function will not be called again # http://www.pygtk.org/pygtk2reference/gobject-functions.html#function-gobject--timeout-add gtk.timeout_add( rpc_interval * 1000, self.check_alt_speed_enabled) gtk.main()
def test_select_clientmessage_and_xselectinput(self): self.evs = [] self.w = self.window() gtk.gdk.flush() l.add_event_receiver(self.w, self) l.add_event_receiver(self.root(), self) data = (0x01020304, 0x05060708, 0x090a0b0c, 0x0d0e0f10, 0x11121314) l.sendClientMessage(self.root(), False, 0, "NOMASK", *data) l.sendClientMessage(self.w, False, 0, "NOMASK", *data) gtk.main() # Should have gotten message to w, not to root assert len(self.evs) == 1 ev = self.evs[0] assert ev.window is self.w assert ev.message_type == "NOMASK" assert ev.format == 32 assert ev.data == data self.evs = [] l.sendClientMessage(self.root(), False, l.const["Button1MotionMask"], "BAD", *data) l.addXSelectInput(self.root(), l.const["Button1MotionMask"]) l.sendClientMessage(self.root(), False, l.const["Button1MotionMask"], "GOOD", *data) gtk.main() assert len(self.evs) == 1 ev = self.evs[0] assert ev.window is self.root() assert ev.message_type == "GOOD" assert ev.format == 32 assert ev.data == data
def start(name): global logfilename, logfile, gui logfilename = name logfile = file(logfilename, "w") gobject.io_add_watch(sys.stdin, gobject.IO_IN, inputhandler) gui = GUI() gtk.main()
def main(): parser = ConfigParser.SafeConfigParser() config_path = os.path.join(os.getenv('HOME'), '.luksmounter') if not parser.read(config_path): raise Exception('Could not read configuration file: %s' % config_path) MounterWindow(parser) gtk.main()
def main(args): if len(args) < 1: print("usage: pyftinspect font...", file=sys.stderr) sys.exit(1) for arg in args: Inspect(arg) gtk.main()
def test_event_routing(self): w1 = self.window() w2 = self.window() w2.reparent(w1, 0, 0) results = set() r1 = _EventRoutingReceiver(1, results) r2 = _EventRoutingReceiver(2, results) r3 = _EventRoutingReceiver(3, results) r4 = _EventRoutingReceiver(4, results) l.add_event_receiver(w1, r1) l.add_event_receiver(w1, r2) l.add_event_receiver(w2, r3) l.add_event_receiver(w2, r4) w1.set_events(gtk.gdk.SUBSTRUCTURE_MASK) w2.set_events(gtk.gdk.STRUCTURE_MASK) w2.show() while len(results) != 4: gtk.main() w2.hide() assert results == set([("child-map", 1), ("child-map", 2), ("map", 3), ("map", 4)]) l.remove_event_receiver(w1, r2) l.remove_event_receiver(w2, r4) results.clear() w2.show() while len(results) != 2: gtk.main() assert results == set([("child-map", 1), ("map", 3)])
def __init__(self, objeto = None, usuario = None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ global fin Ventana.__init__(self, 'consulta_albaranesFacturados.glade', objeto) connections = {'b_salir/clicked': self.salir, 'b_buscar/clicked': self.buscar, 'b_imprimir/clicked': self.imprimir, 'b_fecha_inicio/clicked': self.set_inicio, 'b_fecha_fin/clicked': self.set_fin, "b_exportar/clicked": self.exportar} self.add_connections(connections) cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None), ('Nº Albarán','gobject.TYPE_STRING', False, True, True, None), ('Cliente','gobject.TYPE_STRING', False, True, False, None), ('Num. Factura','gobject.TYPE_STRING', False, True, False,None), ('Idalbaran','gobject.TYPE_INT64', False, False, False, None)) utils.preparar_listview(self.wids['tv_datos'], cols) self.wids['tv_datos'].connect("row-activated", self.abrir_albaran) temp = time.localtime() self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2]) self.wids['e_fechafin'].set_text(utils.str_fecha(temp)) self.wids['rb_salida'].set_active(True) gtk.main()
def __init__(self, objeto = None, usuario = None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ self.usuario = usuario Ventana.__init__(self, 'albaranes_de_entrada_repuestos.glade', objeto, usuario = self.usuario) connections = {'b_nuevo/clicked': self.crear_nuevo_albaran, 'b_actualizar/clicked': self.actualizar_ventana, 'b_guardar/clicked': self.guardar, 'b_buscar/clicked': self.buscar_albaran, 'b_fecha/clicked': self.buscar_fecha, 'b_add_ldv/clicked': self.add_repuesto, 'b_drop_ldv/clicked': self.drop_producto, 'b_add_pedido/clicked': self.add_pedido, 'b_borrar/clicked': self.borrar_albaran, 'b_imprimir/clicked': self.imprimir, 'b_salir/clicked': self.salir, 'cbe_almacen/changed': self.guardar } self.add_connections(connections) self.inicializar_ventana() if self.objeto == None: self.ir_a_primero() else: self.ir_a(objeto) gtk.main()
def __init__(self, objeto = None, usuario = None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ self.usuario = usuario self.clase = self.CLASE Ventana.__init__(self, self.VENTANA, objeto) self.dic_campos = self.__build_dic_campos() self.adaptador = adapter.adaptar_clase(self.clase, self.dic_campos) connections = {'b_salir/clicked': self.salir, 'b_nuevo/clicked': self.nuevo, 'b_borrar/clicked': self.borrar, 'b_actualizar/clicked': self.actualizar_ventana, 'b_guardar/clicked': self.guardar, 'b_buscar/clicked': self.buscar, # XXX: Más widgets y señales si se necesitan. } self.add_connections(connections) self.inicializar_ventana() if self.objeto == None: self.ir_a_primero() else: self.ir_a(objeto) gtk.main()
def __init__(self, app): self._app = app self._app.dew = self icons = gtk.IconTheme() app_icon = "tray" try: assert icons.has_icon(app_icon) except AssertionError: app_icon = "/tmp/tray.png" icon = pkg_resources.resource_string(__name__, 'resources/tray/tray.png') f = open(app_icon, "w") f.write(icon) f.close() if not hasattr(self._app, 'statusIcon'): self._app.statusIcon = appindicator.Indicator('Dewdrop', app_icon, appindicator.CATEGORY_APPLICATION_STATUS) self._app.statusIcon.set_status(appindicator.STATUS_ACTIVE) self.init_menu() self.dapi = DAPI() self.dapi.auth(self._app._cfg.get('email'), self._app._cfg.get('passhash')) self.show_hide_drop() gtk.main()
def main(options, args): logger = log.get_logger("example2", options=options) # Check whether user wants to use OpenCv if options.opencv: from ginga import trcalc try: trcalc.use('opencv') except Exception as e: logger.warning("failed to set OpenCv preference: %s" % (str(e))) # Check whether user wants to use OpenCL elif options.opencl: from ginga import trcalc try: trcalc.use('opencl') except Exception as e: logger.warning("failed to set OpenCL preference: %s" % (str(e))) fv = FitsViewer(logger) root = fv.get_widget() root.show_all() if len(args) > 0: fv.load_file(args[0]) gtk.main()
def __init__(self, callback, realm='', username=''): """The constructor.""" self.callback = callback # Set the Glade file self.gladefile = os.path.join(PREFIX, 'share', APP, 'glade/credentialsdialog.glade') self.wTree = gtk.glade.XML(self.gladefile, domain=APP) # Store some important widgets self.window = self.wTree.get_widget('CredentialsDialog') # Set the correct label containing the realm label = self.wTree.get_widget('Label') label.set_text(label.get_text() % realm) # Set provided username self.wTree.get_widget('UsernameInput').set_text(username) # Connect all events events = {'on_CredentialsDialog_destroy' : self.__cancel, 'on_ButtonCancel_clicked' : self.__cancel, 'on_ButtonOk_clicked' : self.__providePassword, } self.wTree.signal_autoconnect(events) # Show main window self.window.show() # Don't know why, but threading won't work without those two line # I would habe expected that the main thread of nautilus has # already called gobject.threads_init() before gtk.main() #gobject.threads_init() gtk.main()
def run(self): window = gtk.Window() self.main.__window = window window.add(self.main.widget) window.connect('delete-event', self.quit) window.show_all() gtk.main()
def main(self): """Launched the main gtk loop""" try: gtk.main() except KeyboardInterrupt: app.mainWindow.destroy() print "Exited by user"
def __init__(self, objeto = None, usuario = None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ global fin Ventana.__init__(self, 'consulta_entradas_almacen.glade', objeto) connections = {'b_salir/clicked': self.salir, 'b_buscar/clicked': self.buscar, 'b_imprimir/clicked': self.imprimir, 'b_fecha_inicio/clicked': self.set_inicio, 'b_producto/clicked': self.buscar_producto, 'b_fecha_fin/clicked': self.set_fin} self.add_connections(connections) utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) for c in pclases.Proveedor.select(orderBy='nombre')]) cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, False, None), ('Albarán', 'gobject.TYPE_STRING', False, True, True, None), ('Fecha', 'gobject.TYPE_STRING', False, True, False, None), ('Producto', 'gobject.TYPE_STRING', False, True, True, None), ('Cantidad', 'gobject.TYPE_FLOAT', False, True, False, None), ('Precio', 'gobject.TYPE_FLOAT', False, True, False, None), ('Subtotal', 'gobject.TYPE_FLOAT', False, True, False, None), ('idldc','gobject.TYPE_STRING',False,False,False,None)) utils.preparar_listview(self.wids['tv_datos'], cols) for ncol in (4, 5, 6): col = self.wids['tv_datos'].get_column(ncol) for cell in col.get_cell_renderers(): cell.set_property("xalign", 1) temp = time.localtime() self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0]) self.wids['e_fechafin'].set_text(utils.str_fecha(temp)) self.producto = None gtk.main()
def main(): logger.info('loading configuration') import conf debug_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR'] parser = argparse.ArgumentParser( description="Simple panel written in Python for holding widgets") parser.add_argument('--verbosity', '-v', dest='verbosity', choices=debug_levels, default=None) args = parser.parse_args() level = args.verbosity or getattr(conf, 'VERBOSITY', 'INFO') if level not in debug_levels: logger.critical('Log level %s not supported!', level) return 1 logging.basicConfig(level=level) logger.info('creating panel') app = PanelWindow(position=getattr(conf, 'POSITION', None), widgets=getattr(conf, 'WIDGETS', [])) logger.info('starting main loop') gtk.gdk.threads_init() with GdkLock(): gtk.main()
def start(args): global emma_instance debug_output = False log_file = None log_flush = False skip = False for i, arg in enumerate(args): if skip: skip = False continue if arg == "-h" or arg == "--help": usage() elif arg == "-d" or arg == "--debug": debug_output = True elif arg == "-f" or arg == "--flush": log_flush = True elif arg == "-l" or arg == "--log": if i + 1 == len(args): usage() log_file = args[i + 1] skip = True else: usage() # this singleton will be accessible as sys.stdout! OutputHandler(debug_output, log_file, log_flush) emma_instance = Emma() emma_instance.start() gtk.main() return 0
def main(): """Run the program.""" # Check for --loglevel, --debug, we deal with them by ourselves because # option parser also use logging. loglevel = None for idx, arg in enumerate(sys.argv): if '--loglevel' in arg: if '=' in arg: loglevel = arg.split('=')[1] else: loglevel = sys.argv[idx + 1] level = getattr(logging, loglevel.upper(), None) if level is None: raise ValueError('Invalid log level: %s' % loglevel) loglevel = level else: if '--debug' in sys.argv or '-d' in sys.argv: loglevel = logging.DEBUG logging.basicConfig( level=loglevel, format='%(filename)s [%(lineno)d]: %(levelname)s %(message)s') if loglevel is None: # Disabling warning, info, debug messages logging.disable(logging.WARNING) opts = create_options() desc = 'Usage: %prog [Options...]' opts.parse_args(desc, sys.argv) keymon = KeyMon(opts) try: gtk.main() except KeyboardInterrupt: keymon.quit_program()
def main(): gtk.gdk.threads_init() gui = GUI() gui.window.connect('destroy', gtk.main_quit) gui.window.show() gtk.main()
def __init__(self, objeto = None, usuario = None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ self.usuario = usuario Ventana.__init__(self, 'resultados_fibra.glade', objeto, usuario = usuario) connections = {'b_salir/clicked': self._salir, 'b_lote/clicked': self.set_loteCem, 'b_fecha/clicked': self.fecha, 'b_add/clicked': self.add, 'b_drop/clicked': self.drop, 'sp_tolerancia/value-changed': self.cambiar_tolerancia, 'b_guardar_obs/clicked': self.guardar_obs, 'b_imprimir/clicked': self.imprimir, 'ventana/delete_event': self._salir } self.add_connections(connections) self.activar_widgets(False) self.inicializar_ventana() if objeto == None: self.loteCem = None else: self.loteCem = objeto self.actualizar_ventana() gtk.main()
def __init__(self, file_paths, platform): """ ActionHandler constructor. Create the main window, setup the message handler, import the preferences, and connect all of the action handlers. Finally, enter the gtk main loop and block. @param file_paths a list of flow graph file passed from command line @param platform platform module """ self.clipboard = None for action in Actions.get_all_actions(): action.connect('activate', self._handle_action) #setup the main window self.main_window = MainWindow(platform) self.main_window.connect('delete-event', self._quit) self.main_window.connect('key-press-event', self._handle_key_press) self.get_page = self.main_window.get_page self.get_flow_graph = self.main_window.get_flow_graph self.get_focus_flag = self.main_window.get_focus_flag #setup the messages Messages.register_messenger(self.main_window.add_report_line) Messages.send_init(platform) #initialize self.init_file_paths = file_paths Actions.APPLICATION_INITIALIZE() #enter the mainloop gtk.main()
def main(): import logging logging.basicConfig(format="%(message)s") logging.root.setLevel(logging.DEBUG) gl_backing_test(gl_client_window_class=GLSimpleClientWindow, w=640, h=480) gtk.main()
def __init__(self, clase, objeto = None, usuario = None): """ Recibe la clase base para construir la ventana. Opcionalmente recibe un objeto para mostrar en la misma y el usuario registrado en el sistema. Construye la ventana e inicia el bucle Gtk. """ self.usuario = usuario self.clase = clase self.objeto = objeto ventana_marco = os.path.join('..', 'formularios', 'ventana_generica.glade') Ventana.__init__(self, ventana_marco, objeto, usuario) # Botones genéricos: connections = {'b_salir/clicked': self.salir, 'b_actualizar/clicked': self.actualizar_ventana, 'b_nuevo/clicked': self.nuevo, 'b_borrar/clicked': self.borrar, 'b_buscar/clicked': self.buscar, 'b_guardar/clicked': self.guardar } self.add_connections(connections) self.inicializar_ventana() if self.objeto == None: self.ir_a_primero() else: self.ir_a(self.objeto) gtk.main()
def run(self): """Start Nex""" splash = Splash(self.appath) splash.show_all() gobject.timeout_add(1000, splash.hide) # 5*1000 miliseconds gobject.idle_add(self.setup_app) gtk.main()
def __init__(self, objeto=None, usuario=None): """ Constructor. objeto puede ser un objeto de pclases con el que comenzar la ventana (en lugar del primero de la tabla, que es el que se muestra por defecto). """ self.usuario = usuario Ventana.__init__(self, os.path.join("ui", 'cobro_facturas_venta.glade'), objeto) connections = {'b_salir/clicked': self.salir, 'b_add_cobro/clicked': self.add_cobro, 'b_remove_cobro/clicked': self.remove_cobro} self.add_connections(connections) cols = (('ID', 'gobject.TYPE_INT', False, True, True, None), ('Número', 'gobject.TYPE_STRING', False, True, True, None), ('Cliente', 'gobject.TYPE_STRING', False, True, False, None), ('Fecha', 'gobject.TYPE_STRING', False, True, False, None), ('Importe', 'gobject.TYPE_STRING', False, True, False, None), ('Estado', 'gobject.TYPE_STRING', False, True, False, None), ('Fecha vto', 'gobject.TYPE_STRING', False, True, False, None), ('Pagado en', 'gobject.TYPE_STRING', False, True, False, None), ('id', 'gobject.TYPE_STRING', False, False, False, None)) utils.preparar_listview(self.wids['tv_datos'], cols) #self.wids['tv_datos'].connect("row-activated", self.abrir_factura, # self.usuario, self) col = self.wids['tv_datos'].get_column(3) for cell in col.get_cell_renderers(): cell.set_property("xalign", 1.0) col = self.wids['tv_datos'].get_column(4) for cell in col.get_cell_renderers(): cell.set_property("xalign", 0.5) self.rellenar_widgets() self.wids['ventana'].resize(800, 600) gtk.main()
def draw_gtk(p): win = gtk.Window() win.set_title('Family tree') win.connect('destroy', lambda widget: gtk.main_quit()) sw = gtk.ScrolledWindow() win.add(sw) da = gtk.DrawingArea() def draw(widget, event): global ctx ctx = da.window.cairo_create() draw_tree(p) w = int(p.get('w') + 1) h = int(p.get('h') + 1) da.set_size_request(w, h) w = min(w, 1200) sw.set_size_request(w, h + 60) da.connect('expose_event', draw) sw.add_with_viewport(da) win.show_all() gtk.main()
def main(): window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_name("Test Input") vbox = gtk.VBox(False, 0) window.add(vbox) vbox.show() window.connect("destroy", lambda w: gtk.main_quit()) # Create the drawing area drawing_area = gtk.DrawingArea() drawing_area.set_size_request(200, 200) vbox.pack_start(drawing_area, True, True, 0) # now let's draw a point style = drawing_area.get_style() gc = style.fg_gc[gtk.STATE_NORMAL] drawing_area.show() window.show() drawing_area.window.draw_point(gc, 20, 30) gtk.main() return 0
def input_box(title="Input Box", message="", default_text='', modal= True): win = EntryDialog(message, default_text, modal=modal) win.set_title(title) win.show() gtk.main() return win.ret
def run(self): try: gtk.gdk.threads_init() self.window.show() gtk.main() finally: self.shutdown()
def main(self): self.thread.start() gtk.gdk.threads_init() ## run threads gtk.main()
def main(): gtk.main()
gtkmvc3.adapters.containers.watch_items_in_tree(self.list) def on_button1__clicked(self, widget): self.undo.undo() def on_button2__clicked(self, widget): self.undo.redo() def on_button3__clicked(self, widget): self.undo.begin_grouping() for row in self.list: row[0].hours = int(random.random() * 10) self.undo.set_action_name("random hours") self.undo.end_grouping() def on_window1__delete_event(self, widget, event): gtk.main_quit() def register_adapters(self): self.setup_columns() adapt_availability(self.undo, 'undoable', self.view['button1']) adapt_availability(self.undo, 'redoable', self.view['button2']) adapt_label(self.undo, 'undo_label', self.view['button1']) adapt_label(self.undo, 'redo_label', self.view['button2']) Controller(gtkmvc3.Model(), gtkmvc3.View(builder='undo.ui'), handlers='class') gtk.main()
def run(self): gtk.main()
def main(): ApplicationMainWindow() gtk.main()
def main(self): gtk.gdk.threads_enter() self.create() gtk.main() gtk.gdk.threads_leave()
def mainLoop(): gtk.main()
def startGUI(self): print "GUI Started" ## Main Window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_border_width(10) self.version = self.settings.get_version() self.window.set_title("Shredder " + self.version) self.window.set_default_size(650, 400) self.window.connect("destroy", self.destroy) self.window.set_icon_from_file( util().get_resource("img/shredder256.png")) ## Toolbar self.toolbar = gtk.Toolbar() self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) self.toolbar.set_style(gtk.TOOLBAR_BOTH) self.toolbar.set_border_width(5) ## Labels self.statuslbl = gtk.Label("Idle") self.statuslbl.set_line_wrap(True) self.iterationlbl = gtk.Label("Shred Iterations: ") self.zerolbl = gtk.Label("Zero-ing: ") self.removelbl = gtk.Label("Remove: ") ## Spin Buttons self.adjustments = gtk.Adjustment( int(self.settings.get_shred_iterations()), 1, sys.float_info.max, 1, 10, 0) self.check_iterations = gtk.SpinButton() self.check_iterations.set_adjustment(self.adjustments) ## Image Icons # Shred image self.shredimg = gtk.Image() self.shredimg.set_from_file( util().get_resource("img/shredder24.png")) # Filechooser image self.fileimg = gtk.Image() self.fileimg.set_from_file(util().get_resource("img/file.png")) # Folderchooser image self.folderimg = gtk.Image() self.folderimg.set_from_file(util().get_resource("img/folder.png")) # Trash image self.trashimg = gtk.Image() self.trashimg.set_from_file(util().get_resource("img/trash.png")) # Remove image self.rmimg = gtk.Image() self.rmimg.set_from_file(util().get_resource("img/remove.png")) # Clear image self.clrimg = gtk.Image() self.clrimg.set_from_file(util().get_resource("img/clear.png")) # Preferences image self.prefimg = gtk.Image() self.prefimg.set_from_file( util().get_resource("img/preferences.png")) # About image self.abtimg = gtk.Image() self.abtimg.set_from_file(util().get_resource("img/about.png")) ## Check Boxes self.zero = gtk.CheckButton(label=None) self.zero.set_active(self.settings.is_zero()) self.remove = gtk.CheckButton(label=None) self.remove.set_active(self.settings.is_remove_shredded()) ## Tree with scrolling self.scrolltree = gtk.ScrolledWindow() self.liststore = gtk.ListStore(str) self.tree = gtk.TreeView(self.liststore) self.cell = gtk.CellRendererText() self.tvcolumn = gtk.TreeViewColumn( "Files and folders for shredding... (You can drag and drop files and folders below)", self.cell, text=0) self.tree.append_column(self.tvcolumn) self.tree.enable_model_drag_source( gtk.gdk.BUTTON1_MASK, self.TARGETS, gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE) self.tree.enable_model_drag_dest(self.TARGETS, gtk.gdk.ACTION_DEFAULT) self.tree.connect("drag_data_get", self.drag_data_get_data) self.tree.connect("drag_data_received", self.drag_data_received_data) self.scrolltree.add(self.tree) ## Adding items to toolbar self.toolbar.append_item("Shred", "Begin shredding files", "Private", self.shredimg, self.do_shred) self.toolbar.append_item("Add File", "Choose a file", "Private", self.fileimg, self.get_filechooser_callback) self.toolbar.append_item("Add Folder", "Choose a folder", "Private", self.folderimg, self.get_folderchooser_callback) self.toolbar.append_item("Add Trash", "Shred Trash bin", "Private", self.trashimg, self.shred_trash) self.toolbar.append_item("Remove Item", "Remove file/folder from shredding list", "Private", self.rmimg, self.clear_selected) self.toolbar.append_item("Clear List", "Clear shredding list", "Private", self.clrimg, self.clear_treeview) self.toolbar.append_item("Preferences", "Shredder settings and preferences", "Private", self.prefimg, self.on_open_pref) self.toolbar.append_item("About", "About Shredder", "Private", self.abtimg, self.about) ## An About Dialog, where the developers get to show off. # If you're a contributor, please add yourself here. self.about_dialog = gtk.AboutDialog() self.about_dialog.set_program_name("Shredder") self.about_dialog.set_website("http://code.google.com/p/shredder") self.about_dialog.set_license(self.license) self.about_dialog.set_authors([ "Tay Thotheolh <*****@*****.**>", "Michael Rawson <*****@*****.**>" ]) self.about_dialog.set_version(self.version) ## Progress bar self.progress = gtk.ProgressBar() ## Packing widgets into window # Vertical box to contain all boxes self.vbox = gtk.VBox(homogeneous=False, spacing=0) # toolbox to contain toolbar self.toolbox = gtk.HBox(homogeneous=False, spacing=0) self.vbox.pack_start(self.toolbar, expand=False, fill=False, padding=0) # treebox to contain treeview self.treebox = gtk.HBox(homogeneous=False, spacing=0) self.vbox.pack_start(self.scrolltree, expand=True, fill=True, padding=0) # Overall VBox self.mainbox = gtk.VBox(homogeneous=False, spacing=0) self.mainbox.pack_start(self.vbox, expand=True, fill=True, padding=0) self.statusbox = gtk.HBox(homogeneous=False, spacing=0) self.statusbox.pack_start(self.statuslbl, expand=False, fill=False, padding=0) self.separator = gtk.HSeparator() self.mainbox.pack_start(self.separator, expand=False, fill=False, padding=0) self.mainbox.pack_start(self.progress, expand=False, fill=False, padding=5) self.mainbox.pack_end(self.statusbox, expand=False, fill=False, padding=0) ## Presenting window self.progress.show() self.toolbar.show() self.window.add(self.mainbox) self.window.show_all() gtk.main() return None
def main(self): gtk.main()
def main(): searchWindow = SearchWindow('/home/sevka') searchWindow.show_all() gtk.main() return 0
def main(): # And of course, our main loop. gtk.main() # Control returns here when main_quit() is called return 0
def main(): game = Game2Controller() gtk.main()
def show(self): self.fill() self._window.show() gtk.main() self._window.hide()
def main(): UIManagerDemo() gtk.main()
def main(self): """Start GTK mainloop.""" gtk.main()
def mainloop(self): if gtk.main_level() == 0: gtk.main()
def main(self): self.window.show() gtk.main()
def main(): TooltipDemo() gtk.main()
def run(self): """ run is called to set off the GTK mainloop """ gtk.main() return
def main(): SpinnerDemo() gtk.main()
def run(self): gtk.main() return 0
def _run(): """ Fills the hook for L{Application.run} """ gtk.main()
def main(window): """ Test code """ import traceback successors = {'a':['c','e'], 'b':['d'], 'c':[], 'd':[], 'e':['d'], } successors2 = {'a':['c','e','d'], 'b':['d'], 'c':['f'], 'd':['f','g'], 'e':['g'], 'f':['h'], 'g':['h'], 'h':['i','j','k'], 'i':['l'], 'j':['l'], 'k':[], 'l':[], } ## print graph.reversed_prelation_table(pert2[0]) ## for n in range(1,6): ## print inActivitiesR(pert2, graph.reversed_prelation_table(pert2[0]), n) ## print "OUT" ## for n in range(1,6): ## print outActivitiesR(pert2, n) ## window.images.append( graph.pert2image(pert4) ) ## print equivalentRemovingDummy(pert4, (3,4) ) ## removeDummy(pert4, (3,4) ) ## pertP = pert5 ## window.images.append( graph.pert2image(pertP) ) ## makePrelation( pertP, (1,5), (3,4) ) ## addActivity( pertP, 'nueva' ) ## makePrelation( pertP, (1,2), (7,8) ) ## makePrelation( pertP, (9,8), (6,4) ) # window.images.append( graph.pert2image(pert.Pert(pert4)) ) # window.images.append( graph2image(successors2) ) # window.images.append( graph2image(successors3) ) try: pertP = Pert() pertP.construct(successors2) window.images.append( graph.pert2image(pertP) ) except Exception: traceback.print_exception(*sys.exc_info()) ## s = pertSuccessors(pertP) ## window.images.append( graph2image( roy(s) ) ) gtk.main()
def run(self): self.show_all() gtk.main()
def __init__(self, konf, svbe): """ :type konf: str """ self.konf = konf gtk.Builder.__init__(self) self.container = None """ :type: Container """ self.amplitude = None """ :type: numpy.multiarray.ndarray """ self.phase = None """ :type: numpy.multiarray.ndarray """ self.add_from_file(os.path.join(svbe, 'laden.glade')) self.ui = self.window('fenster_laden') self.ff = self.window('fenster_fortschritt') self.connect_signals({ 'ende': gtk.main_quit, 'fit_starten': self.fit_starten, 'abbrechen': lambda _: Fit.stopp(), 'vorschau': self.vorschau }) self.fortschritt = self.get_object('fortschritt') """ :type: gtk.ProgressBar """ self.parser = DefaultParser() self.parser.read(konf) self.parser.getint = lambda sektion, option: int(self.parser.get(sektion, option).rsplit(',', 1)[0]) self.version = self.parser.getint(opt, 'Version') if self.version >= 3: self.sv = os.path.dirname(svbe) if Dialog(self.sv).frage("Kanal", "Den gewünschten Kanal wählen:", "elstat.", "elmech."): self.kanal = 'elstat' else: self.kanal = 'elmech' else: self.kanal = 'Untitled' self.pixel = self.spinbutton('pixel') self.pixel.set_value(self.parser.getint(rst, 'Pixel')) self.dim = self.spinbutton('dim') self.dim.set_value(self.parser.getfloat(rst, 'Dimension')) self.df = self.spinbutton('df') self.df.set_value(self.parser.getfloat(sgl, 'Rate') / self.parser.getfloat(sgl, 'Sample')) self.mittelungen = self.spinbutton('mittelungen') self.mittelungen.set_value(1) self.fmin = self.spinbutton('fmin') self.bereich_min = self.spinbutton('bereich_min') fmin = self.parser.getint(sgn, 'f_start') self.fmin.set_value(fmin) self.bereich_min.set_value(fmin) self.fmax = self.spinbutton('fmax') self.bereich_max = self.spinbutton('bereich_max') fmax = self.parser.getint(sgn, 'f_ende') self.fmax.set_value(fmax) self.bereich_max.set_value(fmax) self.plotter = Plotter("Frequenz (Hz)", "Amplitude (V)") self.get_object('vorschau').add(self.plotter) self.ui.show_all() gtk.main()
def main(): gtk.main() return 0
def main(): KeyboardStateInfoWindow() gtk.main()
def start(self): gtk.main()
def main(): StockItemAndIconBrowserDemo() gtk.main()
def main(): """Run the program.""" # Check for --loglevel, --debug, we deal with them by ourselves because # option parser also use logging. loglevel = None for idx, arg in enumerate(sys.argv): if '--loglevel' in arg: if '=' in arg: loglevel = arg.split('=')[1] else: loglevel = sys.argv[idx + 1] level = getattr(logging, loglevel.upper(), None) if level is None: raise ValueError('Invalid log level: %s' % loglevel) loglevel = level else: if '--debug' in sys.argv or '-d' in sys.argv: loglevel = logging.DEBUG logging.basicConfig( level=loglevel, format='%(filename)s [%(lineno)d]: %(levelname)s %(message)s') if loglevel is None: # Disabling warning, info, debug messages logging.disable(logging.WARNING) opts = create_options() opts.read_ini_file(os.path.join(settings.get_config_dir(), 'config')) desc = _('Usage: %prog [Options...]') opts.parse_args(desc, sys.argv) if opts.version: show_version() sys.exit(0) if opts.smaller: opts.scale = 0.75 elif opts.larger: opts.scale = 1.25 opts.themes = settings.get_themes() if opts.list_themes: print _('Available themes:') print theme_names = sorted(opts.themes) name_len = max(len(name) for name in theme_names) for theme in theme_names: print(' - %%-%ds: %%s' % name_len) % (theme, opts.themes[theme][0]) raise SystemExit() elif opts.theme and opts.theme not in opts.themes: print _('Theme %r does not exist') % opts.theme print print _('Please make sure %r can be found in ' 'one of the following directories:') % opts.theme print for theme_dir in settings.get_config_dirs('themes'): print ' - %s' % theme_dir sys.exit(-1) if opts.reset: print _('Resetting to defaults.') opts.reset_to_defaults() opts.save() keymon = KeyMon(opts) try: gtk.main() except KeyboardInterrupt: keymon.quit_program()