def main(): gobject.threads_init() gtk.threads_init() DBusGMainLoop(set_as_default=True) session_bus = dbus.SessionBus() system_bus = dbus.SystemBus() name = dbus.service.BusName('org.freedesktop.Cozy', session_bus) mainloop = gobject.MainLoop() config = Configuration() backup_provider = BackupProvider() location_manager = LocationManager(config, system_bus) backup_location = location_manager.get_backup_location() with RestoreBackend(config, backup_provider, backup_location) as restore_backend: standard_fallback_restore_client_loader = StandardFallbackRestoreClientLoader(config.data_path) restore_control_center = RestoreControlCenter(restore_backend) wait_until_event_loop_is_running_thread = WaitUntilEventLoopIsRunningThread(mainloop, restore_control_center, standard_fallback_restore_client_loader) wait_until_event_loop_is_running_thread.start() restore_frontend = RestoreFrontend(restore_control_center, mainloop.quit) mainloop.run() restore_control_center.go_to_present()
def get_instance(): if not VirtualHal.instance: vhi = VirtualHal() VirtualHal.instance = vhi gtk.threads_init() thread.start_new_thread(gtk.main, ()) return VirtualHal.instance
def main(): import logging import gtk settings = gtk.settings_get_default() # Use a button ordering more consistent with Windows print 'Use a button ordering more consistent with Windows' settings.set_property('gtk-alternative-button-order', True) logging.basicConfig(format='%(asctime)s [%(levelname)s:%(name)s]: ' '%(message)s', datefmt=r'%Y-%m-%d %H:%M:%S', level=logging.INFO) initialize_core_plugins() from app import App from app_context import get_app gtk.threads_init() gtk.gdk.threads_init() gtk.gdk.threads_enter() my_app = get_app() sys.excepthook = except_handler my_app.run() gtk.gdk.threads_leave()
def __init__ (self): self.letter = {} self.guibuilder = gtk.Builder() self.guibuilder.add_from_file("/usr/share/pyshared/sbw/ui/braille.glade") self.window = self.guibuilder.get_object("window") self.textview = self.guibuilder.get_object("textview") self.label = self.guibuilder.get_object("label") self.textbuffer = self.textview.get_buffer() self.language_and_code = {} self.punctuation_and_name = {".":"Dot","!":"Exclamation",":":"Colon",",":"Coma","-":"Hyphen",";":"Semi-Colon", "?":"Question-mark","'":"quote/apostrophe","(":"Opening bracket",")":"Closing bracket","<":"Lessthan",">":"Greaterthan","[":"Left square bracket", "]":"Right square bracket","{":"Left Brace","}":"Right Brace",'"':"Double Quote"} self.delete_list = {'minus','backslash','equal','bracketright','bracketleft','apostrophe',\ 'slash','period','comma','grave','exclam','at','numbersign','dollar','percent','asciicircum','ampersand'\ ,'asterisk','parenleft','parenright','underscore','plus','bar','braceright','braceleft','quotedbl','colon',\ 'question','greater','less'} self.language_code_one = {"english":0,"spanish":1,"hindi":2,"malayalam":3,"tamil":4,"kannada":5} self.language_code_two = {0:"english",1:"spanish",2:"hindi",3:"malayalam",4:"tamil",5:"kannada"} self.get_configuration() self.activate_configuration() self.capitol_switch = False self.run = 0 self.c_count = 0 self.stick = False #Language and contractions self.dot_one_three_five_six_language_list = {"malayalam"} self.dot_one_five_six_language_list = {"malayalam"} self.dot_three_language_list = {"malayalam"} self.dot_three_six_language_list = {"malayalam","hindi"} self.dot_four_language_list = {"english"} self.dot_four_five_language_list = {"english"} self.dot_four_five_six_language_list = {"english"} self.dot_four_six_language_list = {"english"} self.dot_five_language_list = {"english","malayalam"} self.dot_five_six_language_list = {"english"} self.dot_six_language_list = {"english","malayalam"} #self.dot__language_list = {"english","malayalam"} # Intiating thred in PyGtk gtk.threads_init() self.guibuilder.connect_signals(self) self.textview.grab_focus() self.window.maximize() self.window.show() gtk.main()
def run (self): gtk.timeout_add (self.TIMEOUT, self.code_exec) try: if gtk.gtk_version[0] == 2: gtk.threads_init() except: pass gtk.main ()
def main(self): self.connect_with_server() self.update_liststore() self.listWindow.show() gtk.threads_init() gtk.threads_enter() gtk.main() gtk.threads_leave()
def __init__(self): trayicon.TrayIcon.__init__(self, "Ilenia-notifier") self.ilenia = None w_event = gtk.EventBox() self.w_icon = gtk.Image() self.w_icon.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU) w_event.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.CONFIGURE) w_event.add(self.w_icon) self.w_menu = gtk.Menu() self.w_update = gtk.ImageMenuItem(gtk.STOCK_REFRESH, _("Update")) self.w_update.connect("button_press_event", self.on_update) self.w_menu.add(self.w_update) w_update_repos = gtk.ImageMenuItem(gtk.STOCK_CONNECT, _("Update Repos")) w_update_repos.connect("button_press_event", self.on_update_repos) self.w_menu.add(w_update_repos) self.w_menu.add(gtk.SeparatorMenuItem()) w_show_details = gtk.ImageMenuItem(gtk.STOCK_INFO, _("Show Details Window")) w_show_details.connect("button_press_event", self.on_show_details) self.w_menu.add(w_show_details) self.w_menu.add(gtk.SeparatorMenuItem()) self.w_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, _("Quit")) self.w_quit.connect("button_press_event", self.on_quit) self.w_menu.add(self.w_quit) self.w_menu.show_all() w_event.connect("button_press_event", self.on_event); self.w_tooltips = gtk.Tooltips() self.w_tooltips.set_tip(self, "Ilenia-notifier") self.w_tooltips.enable() self.add(w_event) self.show_all() self.updating_repos = False self.updating_ilenia = False self.working = False self.w_details = Details() gtk.threads_init() thread.start_new_thread(self.init_ilenia, ()) thread.start_new_thread(self.ipc_start, ()) gtk.main()
def downloading(url,final): p = ProgressBar(url) Test(url, open(final, 'wb'), p.progress).start() # Enter the GTK mainloop gtk.threads_init() try: p.mainloop() except KeyboardInterrupt: pass
def main(self): self.FrameOfMspApi.set_visible(True) self.window.show_all() self.not_from_parent_gtk = 1 gtk.threads_init() gtk.threads_enter() gtk.main() gtk.threads_leave()
def init(self): gtk.threads_init() if self.load_last_crawled() and datetime.date.today().day <= self.last_crawled.day and agromaret.load_prices() and bulog.load_prices(): self.update_bulog_table() self.update_agromaret_table(1) self.show_prices() else: thread.start_new_thread(self.crawl, (True,)) thread.start_new_thread(self.crawl_periodically, ()) gtk.main()
def mainloop(self): self.start() gobject.timeout_add(self.TIMEOUT, self.shell.runcode) try: if gtk.gtk_version[0] >= 2: gtk.threads_init() except AttributeError: pass gtk.main() self.join()
def main(args=None): gtk.threads_init() args = parse_args(args) schema = json.loads(args.schema) device_name = re.split(r",\s+", args.device_name) if args.device_name else None try: results = schema_dialog(schema, device_name=device_name, max_width=args.max_width, max_fps=args.max_fps) except ValueError, exception: print >> sys.stderr, "Error: {}".format(exception) raise SystemExit(-1)
def testDialog (self): self.ibd = ImageBrowserDialog() self.ibd.add_images_from_uris_w_progress( ['http://ideasinfood.typepad.com/ideas_in_food/images/katzs_pastrami_reuben.jpg'] \ # + ['file:///home/tom/pictures/'+image for image in ['Caneel beach.JPG','Cinnamon beach.JPG','dsc00258.jpg']] ) #for image in []: # self.ibd.add_image_from_uri() import os if os.name!='nt': gtk.threads_init() self.ibd.run()
def __init__(self, argv): self.init_default(); self.handle_argv(argv); self.trayIcon = gtk.StatusIcon(); self.trayIcon.connect('popup-menu', self.make_menu); self.set_updates(0); self.trayIcon.set_visible(True); self.p = Thread(target=self.loop_process); self.p.daemon = True; self.p.start(); gtk.threads_init(); gtk.main();
def main(): inputThread = InputThread() graph = rtgraph.HScrollLineGraph(range=(-1.0, 1.0)) win = rtgraph.GraphUIWindow(inputThread.channels, graph, valueUpdateInterval=500) win.connect("destroy", gtk.mainquit) inputThread.start() try: gtk.threads_init() gtk.main() finally: inputThread.running = False
def main(configFunc): """Run the provided configuration function then the gtk main loop, terminating all threads cleanly on exit """ try: gtk.threads_init() configFunc() gtk.main() finally: for thread in threading.enumerate(): if isinstance(thread, MeterThread): thread.stop() thread.join()
def __init__(self, dao, timeout=0.0, start_simulation_method = None): gtk.threads_init() self.visulaiser_main = None self.visulaiser_listener = None threading.Thread.__init__(self) self.bufsize = 65536 self.done = False self.dao = dao self.port = None self.start_simulation_method = start_simulation_method self.finish_event = threading.Event() if timeout > 0: thread.start_new_thread(_timeout, (self, timeout))
def __init__(self, settings): gtk.threads_init() self.settings = settings self.builder = gtk.Builder() self.builder.add_from_file("gui.glade") self.window = self.builder.get_object ("windowMain") if self.window: self.window.connect("destroy", gtk.main_quit) self.resetPixelCache() self.drawingArea = self.builder.get_object ("drawingArea") self.listStore = self.builder.get_object ("liststore1") self.treeView = self.builder.get_object ("treeviewPaths") handlers = { "onDeleteWindow": gtk.main_quit, "on_treeviewPaths_cursor_changed" : self.on_treeviewPaths_cursor_changed, "on_drawingArea_expose_event" : self.on_drawingArea_expose_event, "on_drawingArea_configure_event" : self.on_drawingArea_configure_event, "on_toolbuttonOpen_clicked" : self.on_toolbuttonOpen_clicked, "on_toolbuttonCalcAll_clicked" : self.on_toolbuttonCalcAll_clicked, "on_toolbuttonSaveGcode_clicked" : self.on_toolbuttonSaveGcode_clicked, "on_toolbuttonShowSettings_clicked" : self.on_toolbuttonShowSettings_clicked, "on_windowSettings_delete_event" : self.on_windowSettings_delete_event, "on_buttonSaveSettings_clicked" : self.on_buttonSaveSettings_clicked, "on_pathSettings_changed" : self.on_pathSettings_changed, "on_buttonCalcSinglePath_clicked" : self.on_buttonCalcSinglePath_clicked, "on_drawingArea_scroll_event" : self.on_drawingArea_scroll_event, "on_drawingArea_motion_notify_event" : self.on_drawingArea_motion_notify_event, "on_drawingArea_button_press_event" : self.on_drawingArea_button_press_event, "on_drawingArea_button_release_event" : self.on_drawingArea_button_release_event, "on_menuitemAbout_button_press_event" : self.on_menuitemAbout_button_press_event, "on_treeviewPaths_key_press_event" : self.on_treeviewPaths_key_press_event, "on_buttonSimplifyPaths_clicked" : self.on_buttonSimplifyPaths_clicked, "on_imagemenuitemNew_button_press_event" : self.on_imagemenuitemNew_button_press_event } self.builder.connect_signals(handlers) self.drawingArea.set_events(gtk.gdk.EXPOSURE_MASK | gtk.gdk.LEAVE_NOTIFY_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK ) self.treeView.add_events(gtk.gdk.KEY_PRESS_MASK)
def main(): channels = [AdcChannel(name="Analog channel %d" % i) for i in xrange(8)] graph = rtgraph.HScrollLineGraph(range=(0.0, 255.0)) win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500) win.connect("destroy", gtk.mainquit) analogThread = AnalogUpdaterThread(channels) try: # Windows just hangs in gtk.threads_init() if os.name != 'nt': gtk.threads_init() gtk.main() finally: analogThread.running = False
def __init__(self): gtk.threads_init() gtk.threads_enter() self._callback = None if HAS_APPINDICATOR: self._icon = None else: self._menu = None self._icon = gtk.StatusIcon() self._icon.connect('activate', self._on_activate) self._icon.connect('popup_menu', self._on_popup_menu) icons = gtk.icon_theme_get_default() icons.connect('changed', self._on_theme_change)
def run(file_manager): ''' Odpala GUI programu. Do działania potrzebuje klasy zarządzającej tekstami oraz klasy dekodującej zawartość plików ''' seeker = SeekerGUI(file_manager) #@UnusedVariable try: gtk.threads_init() except: print "W trakcie kompilacji nie była włączona obsługa wątków pyGTK!" import sys #@Reimport sys.exit(1) gtk.threads_enter() gtk.main() gtk.threads_leave()
def __init__(self): # initialize the feedbackloop gtk.threads_init() gtk.threads_enter() self.feedbackloop = feedbackLoop() self.feedbackloop.active = False self.feedbackloop.start() gtk.threads_leave() # create a window self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) self.win.set_size_request(600,500) self.win.connect('destroy', gtk.main_quit) #vbox to put everything in self.vbox = gtk.VBox() self.win.add(self.vbox) # add a graph self.figure = Figure(figsize=(10,4)) self.figureCanvas = FigureCanvas(self.figure) self.vbox.pack_start(self.figureCanvas, expand=True, fill=True) # graph self.axes = self.figure.add_subplot(111) self.axes.grid() self.line, = self.axes.plot([1,2,3,4,5],[5,3,5,2,5],'-^', label='output signal PID') # topline self.topline, = self.axes.plot([-1e99, 1e99], 2*[self.feedbackloop.max_signal], label='upper lim') self.botline, = self.axes.plot([-1e99, 1e99], 2*[self.feedbackloop.min_signal], label='lower lim') self.figureCanvas.draw() self.axes.legend(loc=2) # button start/stop self.buttonBox = gtk.HButtonBox() self.vbox.pack_end(self.buttonBox, expand=False, fill=True) self.startStopButton = gtk.ToggleButton('Start/Stop') self.startStopButton.connect('toggled', self.activateFeedbackLoop) self.buttonBox.pack_start(self.startStopButton) self.win.show_all() gobject.idle_add(self.update_graph)
def main(): channels = [ rtgraph.Channel(name="Vector"), rtgraph.Channel(name="Magnitude"), ] graph = rtgraph.IsometricVectorGraph() win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500) win.connect("destroy", gtk.main_quit) device = sys.argv[1] thread = rfaccel.ReceiverThread(PacketGrapher(channels, device)) try: gtk.threads_init() gtk.main() finally: thread.running = False
def setup_gtk(self): gtk.threads_init() # Create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # Quit when window is closed self.window.connect("destroy", self.destroy) # Creates a new button self.button = gtk.Button("Push me!") self.button.connect("clicked", self.clicked, None) # Show widgets and window self.window.add(self.button) self.button.show() self.window.show()
def __init__(self): """ This start the gui in a asynchronous thread. We are in the "main" thread of the application, wich will later be used by the gui as well. We spawn a new thread for the worker. """ gtk.threads_init() self.qIn=Queue.Queue() self.qOut=Queue.Queue() self.gui=GuiPart(self.qIn,self.qOut) self.running=True self.incomingThread=threading.Thread(target=self.processIncoming) #print "plop=",self.incomingThread self.incomingThread.setDaemon(True) self.incomingThread.start() #print "pika=",pika #gtk.threads_enter() gtk.main() self.running=False
def main(): channels = [ rtgraph.Channel(name="X"), rtgraph.Channel(name="Y"), rtgraph.Channel(name="Z"), rtgraph.Channel(name="-X"), ] graph = rtgraph.HScrollLineGraph(range=(0.0, 65535.0)) win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500) win.connect("destroy", gtk.main_quit) device = sys.argv[1] thread = rfaccel.ReceiverThread(PacketGrapher(channels, device)) try: gtk.threads_init() gtk.main() finally: thread.running = False
def run(animation, texture, getFrameRect, size=(200, 200), offset=(0, 0)): gtk.threads_init() gtk.threads_enter() window = gtk.Window() widget = Screen(animation, texture, getFrameRect, offset) widget.show() def on_size_allocate(wind, rect): #print("walloc") shapemap = widget.shapemap() if shapemap: window.input_shape_combine_mask(shapemap, 0, 0) #window.reset_shapes() #print("walloc with bitmap") window.connect("delete-event", gtk.main_quit) window.connect("size-allocate", on_size_allocate) window.add(widget) window.set_decorated(False) window.set_skip_taskbar_hint(True) window.set_skip_pager_hint(True) window.set_keep_above(True) window.stick() window.set_default_size(*size) #the other function doesn't work on windows #which sadly means that transparency doesn't work on windows if os.name=="nt": colormap = gtk.gdk.colormap_get_system() else: colormap = window.get_screen().get_rgba_colormap() gtk.widget_set_default_colormap(colormap) window.present() refresher = Refresher(window) refresher.start() try: gtk.main() finally: gtk.threads_leave()
def __init__(self, config): self.dirs = config['dirs'] self.ahead_icon = config['ahead_icon'] self.synced_icon = config['synced_icon'] self.ind = appindicator.Indicator("GitCheck", "", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status (appindicator.STATUS_ACTIVE) self.ind.set_attention_icon ("indicator-messages-new") # create a menu menu = gtk.Menu() Check = gtk.MenuItem("Check if any directories are ahead") Check.connect("activate", lambda s: self.SetIcon()) Check.show() menu.append(Check) dirs_items = [] for dir in self.dirs: item = gtk.CheckMenuItem(dir) item.set_active(True) item.show() menu.append(item) dirs_items.append(item) self.dirs_items = dirs_items quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit.connect("activate", self.quit) quit.show() menu.append(quit) self.ind.set_menu(menu) self.SetIcon() # Initialise the icon gobject.timeout_add_seconds(10, self.SetIcon) gtk.threads_init()
def main(): channels = [] analogThread = AnalogUpdaterThread(channels) # Wait for our channel list to be populated while not channels: time.sleep(0.1) graph = rtgraph.HScrollLineGraph(range=(0.0, 30.0), scrollRate=10) win = rtgraph.GraphUIWindow(channels, graph, valueUpdateInterval=500) win.connect("destroy", gtk.mainquit) try: # Windows just hangs in gtk.threads_init() if os.name != 'nt': gtk.threads_init() gtk.main() finally: analogThread.running = False
def main(): pyCast=gtk.glade.XML (conf.GLADEFILE,"pycast") dic = { "on_pycast_destroy" : (Exit), "on_addcast" : (castdlgs.AddCast,pyCast), "on_aboutdialog" : miscdlgs.About, "on_castlist_click" : casttree.CastlistClick, "on_removecast" : (castdlgs.RemoveCast,pyCast)} pyCast.signal_autoconnect (dic) casttree.ListCasts(pyCast) gtk.threads_init() conf.Load() thread.start_new_thread(casts.DownloadRSS,(pyCast,'')) gtk.threads_enter() gtk.main() gtk.threads_leave()
def __init__(self): gtk.threads_init() # Create window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", self.destroy) self.window.set_border_width(10) # Create menus menu = gtk.Menu() buf = "Open File" menu_items = gtk.MenuItem("Start Patch") menu.append(menu_items) menu_items.connect("activate", self.menuitem_response, buf) menu_items.show() root_menu = gtk.MenuItem("File") root_menu.show() root_menu.set_submenu(menu) vbox = gtk.VBox(gtk.FALSE, 0) self.window.add(vbox) vbox.show() menu_bar = gtk.MenuBar() vbox.pack_start(menu_bar, gtk.FALSE, gtk.FALSE, 0) menu_bar.append(root_menu) menu_bar.show() connection = FtsSocketConnection() rootPatcher = FtsObject(connection, None, 0) connection.putObject(0, rootPatcher) self.console_stream = FtsConsoleStream(self.window, vbox, connection, rootPatcher, "console_stream") self.console_stream.send("set_default") self.clientPatcher = FtsObject(connection, rootPatcher, 1) JMaxApplication.connection = connection JMaxApplication.rootPatcher = rootPatcher
def startapp(): if platform.system() == 'Windows': set_locale() else: gtk.threads_init() install_gettext("sanaviron") if '--debug' in sys.argv: import gc gc.enable() gc.set_debug(gc.DEBUG_LEAK) print(get_summary()) sys.path.append(os.path.dirname(os.path.abspath(__file__))) os.chdir(os.path.dirname(os.path.abspath(__file__))) from ui.application import Application application = Application() if '--sample' in sys.argv: application.editor.canvas.load_from_xml( os.path.join("..", "examples", "invoice.xml")) application.run()
def run(self): gtk.threads_init() gtk.main()
def __init__(self, maxthreads=3): VBox.__init__(self) self.threads = [] self.queue = DownloadQueue() self.show() for i in range(maxthreads): thread = _DownloadStatus(self.queue) thread.start() self.threads.append(thread) self.pack_end(thread, FALSE, FALSE, 0) def put(self, url, path): self.queue.put(url, path) if __name__ == '__main__': threads_init() win = MenuWindow() win.connect('destroy', mainquit) win.set_usize(200, 100) #url = 'http://paella/debian/dists/sid/Release' mirror = 'paella' #mirror = 'ftp.us.debian.org' url = 'http://%s/debian/dists/sid/main/binary-i386/Packages.gz' % mirror dl = DownloadStatus(url, 'hellothere') win.vbox.add(dl) #threads_enter() #dl.start() mainloop() #threads_leave()
def show(self): self.window.show_all() gtk.threads_init() gtk.main()
def run(): gtk.threads_init() gui = GUI() thread.start_new_thread(gui.do_strobes, ()) gtk.main()
def main(): gtk.threads_init() gtk.main()
def main(argv): a = Application() gtk.threads_init() gtk.main()
def main(): gtk.threads_init() warnings.filterwarnings("ignore", category=DeprecationWarning) app = application() app.start()
def init_gtk(self): try: gtk.threads_init() except: print "No threading was enabled when you compiled pyGTK!" sys.exit(1)
def __init__(self, dirs, args, update_period=300, update_period_remote=3600): self.args = args self.dirs = dirs self.update_period = update_period self.update_period_remote = update_period_remote self.remote = False # Flag to update the remote self.ind = appindicator.Indicator( "checkgit", "", appindicator.CATEGORY_APPLICATION_STATUS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.ind.set_attention_icon("indicator-messages-new") self.IconMenuDictionary = { 'ahead': gtk.STOCK_GO_UP, 'diverged': gtk.STOCK_REFRESH, 'behind': gtk.STOCK_GO_DOWN, 'up-to-date': gtk.STOCK_YES, 'no-state': gtk.STOCK_HELP } # create a menu menu = gtk.Menu() ManualCheck = gtk.ImageMenuItem(gtk.STOCK_REFRESH) ManualCheck.set_always_show_image(True) ManualCheck.show() ManualCheck.connect("activate", self.SetIconAndMenuRemote2) menu.append(ManualCheck) ManualUpdate = gtk.ImageMenuItem(gtk.STOCK_HOME) ManualUpdate.set_always_show_image(True) ManualUpdate.show() ManualUpdate.connect("activate", self.PullPushAll) ManualUpdate.connect("activate", self.SetIconAndMenuRemote2) menu.append(ManualUpdate) dirs_items = [] for dir in self.dirs: label_name = self.ClearDirName(dir) item = gtk.ImageMenuItem(gtk.STOCK_YES, label_name) item.show() item.set_always_show_image(True) menu.append(item) dirs_items.append(item) self.dirs_items = dirs_items quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit.connect("activate", self.quit) quit.set_always_show_image(True) quit.show() menu.append(quit) self.ind.set_menu(menu) # Update the custom labels: must be done after `set_menu`. ManualCheck.set_label("Check status") ManualUpdate.set_label("Pull/Push") self.SetIconAndMenu(remote=True) # Initialise the icon gobject.timeout_add_seconds(int(self.update_period), self.SetIconAndMenu) gobject.timeout_add_seconds(int(self.update_period_remote), self.SetIconAndMenuRemote) gtk.threads_init()
def __init__(self, url): # Fenster + Inhalt zusammenbasteln self.windowMain = gtk.Window(gtk.WINDOW_TOPLEVEL) vboxMain = gtk.VBox() vboxInOut = gtk.VBox(False, 6) hboxAddress = gtk.HBox(False, 6) labelAddress = gtk.Label("_Adress:") labelAddress.set_use_underline(True) self.inputAddress = gtk.Entry() buttonCheck = gtk.Button("_Check") buttonCheck.connect("clicked", self.button_check_clicked) buttonClear = gtk.Button("C_lear all") buttonClear.connect("clicked", self.button_clear_clicked) self.inputAddress.connect("changed", self.input_address_changed, buttonCheck) self.inputAddress.connect("key_press_event", self.input_address_keypress) labelAddress.set_mnemonic_widget(self.inputAddress) hboxAddress.pack_start(labelAddress, False, True) hboxAddress.add(self.inputAddress) hboxAddress.pack_end(buttonClear, False, True) hboxAddress.pack_end(buttonCheck, False, True) # Tastenkürzelgruppe mit Fenster verbinden accel = gtk.AccelGroup() self.windowMain.add_accel_group(accel) # Menu zusammenbasteln menuBar = gtk.MenuBar() rootMenu = gtk.MenuItem("_GPharmcheck") mainMenu = gtk.Menu() menuItemAbout = gtk.ImageMenuItem(gtk.STOCK_ABOUT) menuItemQuit = gtk.ImageMenuItem(gtk.STOCK_QUIT) menuItemQuit.add_accelerator("activate", accel, ord("Q"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) mainMenu.append(menuItemAbout) mainMenu.append(gtk.SeparatorMenuItem()) mainMenu.append(menuItemQuit) menuItemAbout.connect("activate", self.menu_item_about_activate) menuItemQuit.connect("activate", self.menu_item_quit_activate) rootMenu.set_submenu(mainMenu) menuBar.append(rootMenu) vboxMain.pack_start(menuBar, False, True, 0) self.output = gtk.TextView() outputScroll = gtk.ScrolledWindow() outputScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS) outputScroll.add(self.output) outputScroll.set_shadow_type(gtk.SHADOW_IN) vboxInOut.pack_start(hboxAddress, False, True) vboxInOut.pack_end(outputScroll, True, True) vboxInOut.set_border_width(6) vboxMain.add(vboxInOut) buttonCheck.set_sensitive(False) # Mit Signalen verbinden self.windowMain.connect("delete_event", self.delete_event) self.windowMain.add(vboxMain) self.windowMain.move(200, 100) self.windowMain.resize(400, 300) self.windowMain.set_title("GPharmcheck " + __version__) self.windowMain.show_all() gtk.threads_init() gtk.threads_enter() gtk.main() gtk.threads_leave()
def __init__(self, basedir, embed=False, poster=""): """ Main window class """ self.basedir = basedir self.embed = embed self.poster = poster self.window = gtk.Window() self.window.set_title("Pyimagedownloader %s" % __version__) self.window.set_size_request(500, 200) self.window.connect("delete-event", self.close) self.window.connect("destroy", self.close) # let's have a scrobllbar self.scrolledwindow = gtk.ScrolledWindow() self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scrolledwindow.set_size_request(400, 150) # ListStore and its TreeView self.liststore = gtk.ListStore(str) self.treeview = gtk.TreeView(self.liststore) self.treeview.set_fixed_height_mode( True) # all columns have same height # CellRender to render the data self.cell = gtk.CellRendererText() # TreeViewColumn to display text in a single column self.tvcolumn = gtk.TreeViewColumn('URL', self.cell, text=0) # this must be set for set_fixed_height_mode of TreeView to work self.tvcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) self.tvcolumn.set_clickable(False) # column header won't be clickable # add column to the treeview self.treeview.append_column(self.tvcolumn) # make treeview searchable and allow sorting self.treeview.set_search_column(0) self.tvcolumn.set_sort_column_id(0) # add grid lines self.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_HORIZONTAL) # make the column header not clickable self.tvcolumn.set_clickable(False) # Clipboard self.clipboard = gtk.Clipboard(gtk.gdk.display_get_default(), "PRIMARY") # Buttons self.basedir_button = gtk.Button("Set save directory") self.filelist_button = gtk.Button("Load file") self.cut_button = gtk.Button("Cut") self.copy_button = gtk.Button("Copy") self.paste_button = gtk.Button("Paste") self.start_button = gtk.Button("Start") self.close_button = gtk.Button("Close") self.basedir_button.set_size_request(30, 30) self.filelist_button.set_size_request(30, 30) self.cut_button.set_size_request(50, 50) self.copy_button.set_size_request(50, 50) self.paste_button.set_size_request(50, 50) self.start_button.set_size_request(50, 50) self.close_button.set_size_request(50, 50) self.hbox1 = gtk.HBox(False, 5) self.hbox2 = gtk.HBox(False, 5) self.vbox = gtk.VBox(False, 5) self.hbox1.pack_start(self.basedir_button) self.hbox1.pack_start(self.filelist_button) self.vbox.pack_start(self.hbox1) self.vbox.pack_start(self.scrolledwindow) self.hbox2.pack_start(self.start_button) self.hbox2.pack_start(self.cut_button) self.hbox2.pack_start(self.copy_button) self.hbox2.pack_start(self.paste_button) self.hbox2.pack_start(self.close_button) self.vbox.pack_start(self.hbox2) self.scrolledwindow.add(self.treeview) self.window.add(self.vbox) self.basedir_button.connect("clicked", self.basedir_dialog) self.filelist_button.connect("clicked", self.filelist_dialog) self.cut_button.connect("clicked", self.copy, "cut") self.copy_button.connect("clicked", self.copy, "copy") self.paste_button.connect("clicked", self.paste) self.start_button.connect("clicked", self.sequential_downloader, self.liststore, self.basedir, self.embed, self.poster) self.close_button.connect("clicked", self.close) # Tooltips self.cut_button.set_tooltip_text("Cut url(s)") self.copy_button.set_tooltip_text("Copy url(s) into the clipboard") self.paste_button.set_tooltip_text("Paste url(s) from the clipboard") self.window.show_all() gtk.threads_init() gtk.main()
Metoda pomocnicza dla kodu obsługi zdarzenia kliknięcia: umieszcza komunikat w obszarze tekstowym i przesuwa obszar na sam dół. """ message=message+enter buffer = self.logwindow iter = buffer.get_end_iter() #obsługa różnych wersji GTK if color != "black": tag = buffer.create_tag() tag.set_property("foreground", color) self.logwindow.insert_with_tags(buffer.get_end_iter(), message, tag) else: self.logwindow.insert(iter, message) #gtk.FALSE i gtk.TRUE w starszych pyGTK mark = buffer.create_mark("end", buffer.get_end_iter(), False) self.logwindowview.scroll_to_mark(mark,0.05,True,0.0,1.0) #print "Koniec funkcji log" if __name__ == '__main__': PyRAPGUI() try: gtk.threads_init() except: print "W trakcie kompilacji pyGTK nie były włączone wątki!" import sys sys.exit(1) gtk.threads_enter() gtk.main() gtk.threads_leave()
def main(): gtk.threads_init() gtk.threads_enter() gtk.main() gtk.threads_leave() return 0
def main(): # Configure options parser = OptionParser(usage='usage: %prog [options]') parser.set_defaults(debug=False) parser.set_defaults(capture_log=False) parser.add_option('-d', '--debug', action='store_true', dest='debug', help='start in debug mode') parser.add_option('-c', '--capture-log', action='store_true', dest='capture_log', help='Capture device logs.') (options, args) = parser.parse_args() del args # Option debug for logging if options.debug: level = logging.DEBUG else: level = logging.INFO logfilename = '/var/tmp/hermes-hardware-' + \ os.environ['USER'] + str(os.getuid()) + \ '.log' logging.basicConfig(level=level, format='%(asctime)s %(levelname)s %(message)s', filename=logfilename, filemode='a') # Set capture log if options.capture_log: filepath = '/var/tmp/filenotification-' + \ os.environ['USER'] + str(os.getuid()) + \ '.log' iface = FileNotification(filepath) capture_log_gui = CaptureLogGui() else: iface = NotificationDaemon() global DeviceActor from actors.deviceactor import DeviceActor ################################################################## # Init application. # ####################### logging.getLogger().info("----------------------------- Hermes init.") DeviceListener(iface) gtk.threads_init() try: gtk.main() except: if 'capture_log_gui' in locals(): # Close file for write in hd. capture_log_gui.logfile.close() logging.getLogger().info( "----------------------------- Hermes finish.")
def main(argv): Application().startup() gtk.threads_init() gtk.main()
def __init__(self): self.name = self.plugin_name self.ignore_warnings = {} gtk.threads_init()