def main(args): bindtextdomain('gimmie', gimmie_globals.localedir) textdomain('gimmie') ### Uncomment to spew leak debug info #gc.set_debug(gc.DEBUG_LEAK) # Tell gobject/gtk we are threaded gtk.gdk.threads_init() gnome.program_init("gimmie", gimmie_globals.version) _setup_session_manager() signal.signal( signal.SIGTERM, lambda x: _cancel_session_manager()) # Don't restart after kill try: topics = [ ApplicationsTopic(), DocumentsTopic(), PeopleTopic(), ComputerTopic() ] load_it = lambda: _load_gimmie_bar(topics) gconf_bridge.connect("changed::swapbar", lambda gb: load_it()) gconf_bridge.connect("changed::autohide", lambda gb: load_it()) gconf_bridge.connect("changed::vertical", lambda gb: load_it()) load_it() gtk.main() except (KeyboardInterrupt, SystemExit): # Don't restart if user pressed Ctrl-C, or sys.exit called _cancel_session_manager()
def _show_help(): try: import gnome except: print "You need python gnome module to use this help." return p = { gnome.PARAM_APP_DATADIR : '/usr/share' } gnome.program_init("ibus-xkbc", '1.0', properties=p) gnome.help_display("ibus-xkbc")
def _show_help(): try: import gnome except: print "You need python gnome module to use this help." return p = {gnome.PARAM_APP_DATADIR: '/usr/share'} gnome.program_init("ibus-xkbc", '1.0', properties=p) gnome.help_display("ibus-xkbc")
def __init__(self, app_name, app_version, filename, top_window, widget_list, handlers, pull_down_dict=None): ''' __init__(self, app_name, app_version, filename, top_window, widget_list, pull_down_dict=None): app_name, app_version : application name and version filename: filename of the .glade file top_window: the glade name of the top level widget (this will then be accessible as self.top_window) widget_list: a list of glade names; the dictionary self.widgets will be created that maps these name to the actual widget object pull_down_dict: a dictionary that maps combo names to a tuple of strings to put in the combo ''' self.widget_list = widget_list try: search_path = GladeGnomeApp.search_path except: search_path = './' gnome.program_init(app_name, app_version) fname = search_file(filename, search_path) self.xml = gtk.glade.XML(fname, domain='sbackup') # prepare callbacks self.cb_dict = {} for f in handlers: self.cb_dict[f] = getattr(self, f) self.widgets = {} for w in self.widget_list: self.widgets[w] = self.xml.get_widget(w) if pull_down_dict is not None: for w, l in pull_down_dict.items(): self.widgets[w].set_popdown_strings(l) # set attribute for top_window so it can be accessed as self.top_window self.top_window = self.xml.get_widget(top_window) # window to show when this one is hidden self.prev_window = None # initialize callback func self.cb_func = None
def main(): import gnome gnome.program_init("Prime", "0.01") pix = gtk.gdk.pixbuf_new_from_file(sibpath(__file__, "icon-active.png")) gtk.window_set_default_icon_list(pix) # global ne ne = NotificationEntry() from twisted.python import log import sys sys.stdin.close() log.startLogging(sys.stdout) reactor.run()
def main(): gnome.program_init('tray', SamplerConfig.version) unique = Service.unique() if unique: unique.dialog.run() else: import dbus bus = dbus.SessionBus() remote = bus.get_object('edu.wisc.cs.cbi.FirstTime', '/edu/wisc/cs/cbi/FirstTime') iface = dbus.Interface(remote, 'edu.wisc.cs.cbi.FirstTime') iface.present()
def main(): __pychecker__ = 'unusednames=tray' gnome.program_init('tray', SamplerConfig.version) unique = Service.unique() if not unique: return client = gconf.client_get_default() gconf_dir = GConfDir(client, Keys.root, gconf.CLIENT_PRELOAD_ONELEVEL) tray = TrayIcon(client) gtk.main() del gconf_dir
def handleGnomeSession(self): """ Define alguns handlers para eventos da sessão Gnome """ try: import gnome import gnome.ui except: pass else: gnome.program_init(self.name, version) self.gclient = gnome.ui.master_client() #self.gclient = gnome.ui.Client() #self.gclient.connect_to_session_manager() self.gclient.connect("save-yourself", self.saveyourself) self.gclient.connect("die", self.die)
def main(): gnome.program_init('preferences', SamplerConfig.version) unique = Service.unique() if unique: unique.dialog.run() else: import dbus import gtk.gdk bus = dbus.SessionBus() remote = bus.get_object('edu.wisc.cs.cbi.Preferences', '/edu/wisc/cs/cbi/Preferences') iface = dbus.Interface(remote, 'edu.wisc.cs.cbi.Preferences') iface.present() gtk.gdk.notify_startup_complete()
def __init__(self): self.program = gnome.program_init("notemeister", notemeister.const.version) self.Conf = notemeister.Configurator.Configurator() self.textview = notemeister.NoteView.NoteView(self.Conf) self.treeview = notemeister.NoteTree.NoteTree(self.textview) self.init_interface() self.treescroller.add(self.treeview) self.viewscroller.add(self.textview) self.treeview.connect("button_press_event", self.on_button_press_event) self.treeview.connect("doubleclick", self.on_doubleclick) self.treeview.loadNotes() tree_state = self.Conf.get_string("/apps/notemeister/tree_state") if len(self.treeview.noteList) > 0: path = self.treeview.restore_tree_state(tree_state) if len(path): self.treeview.set_cursor(path, None, gtk.FALSE) else: self.show_welcome() if self.Conf.enable_autosave: self.auto_save_notes() notemeister.utils.make_path(notemeister.const.dataPath) self.topWindow.show_all() gtk.main()
def runit(splash=None): from netconfpkg import NC_functions from netconfpkg.NCException import NCException splash_window = None try: if splash: splash_window = splash_screen(True) import gnome import netconfpkg.gui.GUI_functions import netconfpkg netconfpkg.PRG_NAME = PRG_NAME from netconfpkg.gui.NewInterfaceDialog import NewInterfaceDialog from netconfpkg.gui.maindialog import mainDialog netconfpkg.gui.GUI_functions.PROGNAME = PROGNAME # make ctrl-C work signal.signal(signal.SIGINT, signal.SIG_DFL) progname = os.path.basename(sys.argv[0]) gnome.program_init(PROGNAME, "scn") gtk.glade.bindtextdomain(PROGNAME, "/usr/share/locale") if progname == 'system-config-network-druid' or \ progname == 'internet-druid': interface = NewInterfaceDialog() gtk.main() if interface.canceled: sys.exit(1) window = mainDialog() # pylint: disable-msg=W0612 if splash_window: splash_window.destroy() del splash_window gtk.main() except NCException, e: NC_functions.generic_error_dialog(str(e)) return
def __init__(self, base, content_type, body): import cgi import gnome import gtk.glade import gtkhtml2 import sys import BlipIcons import SamplerConfig import Paths import Signals argv = sys.argv sys.argv = [sys.argv[0]] gnome.program_init('wrapper', SamplerConfig.version) sys.argv = argv xml = gtk.glade.XML(Paths.glade) Signals.autoconnect(self, xml) self.__dialog = xml.get_widget('server-message') pixmap = self.__dialog.render_icon(BlipIcons.stock[True], BlipIcons.ICON_SIZE_EMBLEM, '') self.__dialog.set_icon(pixmap) document = gtkhtml2.Document() document.connect('request_url', self.on_request_url) document.connect('set_base', self.on_set_base) document.connect('link_clicked', self.on_link_clicked) document.connect('title_changed', self.on_title_changed) document.dialog = self.__dialog document.base = '' self.on_set_base(document, base) [mime_type, options] = cgi.parse_header(content_type) document.open_stream(mime_type) document.write_stream(body) document.close_stream() self.__document = document view = gtkhtml2.View() view.set_document(document) port = xml.get_widget('html-scroll') port.add(view) view.show()
def help_docs(window): """Shell out to display help documents.""" import platform if platform.system() == 'Windows': # shell out to explorer... pass else: import gnome props = {gnome.PARAM_APP_DATADIR:DB_PATH} prog = gnome.program_init('SCBdo', VERSION, properties=props) gnome.help_display('SCBdo')
def help_docs(window): """Shell out to display help documents.""" import platform if platform.system() == 'Windows': # shell out to explorer... pass else: import gnome props = {gnome.PARAM_APP_DATADIR: DB_PATH} prog = gnome.program_init('SCBdo', VERSION, properties=props) gnome.help_display('SCBdo')
def _read_glade(self, interface, glade_dir): glade_path = os.path.join(glade_dir, GLADE_FILE) if interface == INTERFACE_GNOME: try: xml_doc = dom_parse(glade_path) xml_glade_interface = xml_doc.getElementsByTagName("glade-interface")[0] xml_gnome_main = get_elements_by_attribute(xml_glade_interface, "widget", {"class":"GnomeApp"})[0] set_glade_icon(glade_path, xml_gnome_main) xml_main = get_elements_by_attribute(xml_glade_interface, "widget", {"class":"GtkWindow", "id":"main"})[0] xml_vbox = get_elements_by_attribute(xml_main.getElementsByTagName("child")[0], "widget", {"class":"GtkVBox", "id":"vbox"})[0] xml_placeholder = xml_gnome_main.getElementsByTagName("placeholder")[0] xml_gnome_child = xml_placeholder.parentNode xml_gnome_child.replaceChild(xml_vbox, xml_placeholder) xml_glade_interface.removeChild(xml_main) xml_gnome_main.attributes["id"].nodeValue = "main" xml_buf = xml_doc.toxml() import gnome gnome.program_init("PyCheckSum", "0.1") xml = gtk.glade.xml_new_from_buffer(xml_buf, len(xml_buf), 'main') except: print "Can't start as gnome app. Retrying as simple Gtk app..." return self._read_glade(INTERFACE_GTK) else: xml_doc = dom_parse(glade_path) xml_glade_interface = xml_doc.getElementsByTagName("glade-interface")[0] xml_glade_interface.removeChild(get_elements_by_attribute(xml_glade_interface, "widget", {"class":"GnomeApp"})[0]) xml_glade_interface.removeChild(get_elements_by_attribute(xml_glade_interface, "requires", {"lib":"gnome"})[0]) xml_glade_interface.removeChild(get_elements_by_attribute(xml_glade_interface, "requires", {"lib":"bonobo"})[0]) set_glade_icon(glade_path, get_elements_by_attribute(xml_glade_interface, "widget", {"class":"GtkWindow", "id":"main"})[0]) xml_buf = xml_doc.toxml() xml = gtk.glade.xml_new_from_buffer(xml_buf, len(xml_buf), 'main') return xml
def __init__(self): gnome.program_init(APP_NAME,APP_VERSION) # Create widget tree for the GUI and signal handlers self.__window = gtk.glade.XML('glade/window.glade','window') self.__window.signal_autoconnect( { 'on_window_destroy' : self.on_window_destroy, 'on_new_activate' : self.on_new_activate, 'on_open_activate' : self.on_open_activate, 'on_pause_activate' : self.on_pause_activate, 'on_clear_activate' : self.on_clear_activate, 'on_prefs_activate' : self.on_prefs_activate, 'on_about_activate' : self.on_about_activate, 'on_button_press_event' : self.on_button_press_event, }) # Save some pointers to specifig gui widgets self.__board = self.__window.get_widget('board') #for b in self.__board.get_children(): # b.modify_fg(gtk.STATE_INSENSITIVE,gdk.Color(60255,255,6660)) self.__rowHints = self.__window.get_widget('rowHints') self.__colHints = self.__window.get_widget('columnHints') self.__level = self.__window.get_widget('level') self.__timeLeft = self.__window.get_widget('timeLeft') self.__desiredSkill = SKILL_MEDIUM self.__desiredPlayTime = 1800 self.__gameOver = False self.__prefs_change = False # This will store the picross game self.__game = None self.__board.set_sensitive(False) self.__timer = GameTimer(delay=1,callback=self.__timerCallback) self.__timer.setDaemon(True) # Start the gtk main event loop and allow multiple threads to # serialize access to the Python interpreter gdk.threads_init() #self.__timer.start() gtk.main()
def browse_url(url): global gnome_initted if sys.platform == 'win32': try: import webbrowser webbrowser.open_new(url) except: raise error.Error('Opening a browser failed.') elif settings.gtk_loaded(): try: import gnome except: gnome = None if gnome and not gnome_initted: gnome.program_init('circle',__init__.__version__) gnome_initted = 1 if gnome: gnome.url_show(url) else: if not os.fork(): try: os.execlp('gnome-moz-remote','gnome-moz-remote','--newwin',url) except: try: os.execlp('mozilla','mozilla',url) except: raise error.Error('Opening a browser failed.') else: try: #if not os.fork(): #os.execlp('lynx','lynx',url) os.system("lynx "+quote_for_shell(url)) except: raise error.Error('Opening a browser failed.')
def __init__(self, name, version, humanName, gladeFile, root): """Initialise program 'name' and version from 'file' containing root node 'root'. """ props = { gnome.PARAM_HUMAN_READABLE_NAME: humanName, gnome.PARAM_APP_DATADIR: paths.datadir, gnome.PARAM_APP_LIBDIR: paths.datadir, gnome.PARAM_APP_PREFIX: paths.prefix, gnome.PARAM_APP_SYSCONFDIR: paths.sysconfdir, } self.program = gnome.program_init(name, version, properties=props) gladeXML = uninstalled_file(gladeFile) if gladeXML == None: filename = os.path.join(name, gladeFile) gladeXML = self.program.locate_file(gnome.FILE_DOMAIN_APP_DATADIR, filename, True) if gladeXML == []: ### FIXME: Need to use something less generic than this raise Exception("Unable to locate %s" % (filename)) else: gladeXML = gladeXML[0] GtkApp.__init__(self, gladeXML, root) if 0: self.client = gnome.ui.Client() self.client.disconnect() def connected(*args): print "CONNECTED", args def cb(name): def cb2(*args): print name, args, "\n" return cb2 self.client.connect("connect", cb("CON")) self.client.connect("die", cb("DIE")) self.client.connect("disconnect", cb("DIS")) self.client.connect("save-yourself", cb("SAVE")) self.client.connect("shutdown-cancelled", cb("CAN")) self.client.connect_to_session_manager()
try: import pygtk #tell pyGTK, if possible, that we want GTKv2 pygtk.require("2.0") except: #Some distributions come with GTK2, but not pyGTK pass try: import gtk import gtk.glade import gnome import pynotify except: print _("You need to install pyGTK or GTKv2,\n" "or set your PYTHONPATH correctly.\n" "try: export PYTHONPATH= ") sys.exit(1) gnome.program_init("mount-systray", "0.1") device_manager = MSDeviceManager() conf = MSConfig() MSSystray(device_manager, conf) pynotify.init("mount-systray") gtk.main()
# no options were passed print "WARNING: Unknown arguments passed, using defaults." opts = [] args = sys.argv[1:] for o, a in opts: if o in ("-h", "--help"): usage() elif o in ("-w", "--window"): standalone = True print 'Running with options:', { 'standalone': standalone, } gnome.program_init('glipper', '1.0', properties= { gnome.PARAM_APP_DATADIR : glipper.DATA_DIR }) set_process_name() if standalone: import gnome gnome.init(glipper.defs.PACKAGE, glipper.defs.VERSION) set_process_name() build_window() gtk.main() else: gnomeapplet.bonobo_factory( "OAFIID:Glipper_Factory", gnomeapplet.Applet.__gtype__, glipper.defs.PACKAGE,
folder = header.get_folder() msg = folder.get_msg(header) msgview.set_msg(msg) def on_folderstree_selected(treeselection, headerstree): model, iter = treeselection.get_selected() folder = model.get_value( iter, tinymail.uigtk.GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN) if folder: progressbar.show() folder.refresh_async(on_refresh_folder, on_status, headerstree) props = {gnome.PARAM_APP_DATADIR: "/usr/share"} pr = gnome.program_init("E-Mail", "1.0", properties=props) xml = gtk.glade.XML("tinymail-python-test.glade", domain="email") widget = xml.get_widget("window") progressbar = xml.get_widget("progressbar") progressbar.hide() folderstree = xml.get_widget("folderstree") headerstree = xml.get_widget("headerstree") vpaned = xml.get_widget("vpaned") renderer = gtk.CellRendererText() column = gtk.TreeViewColumn("Folder", renderer, text=0) column.set_fixed_width(100) column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED) folderstree.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn("From", renderer, text=0) column.set_fixed_width(100)
kwargs = {} if sys.version_info < (3,): kwargs['unicode'] = True gettext.install(PROGNAME, localedir="/usr/share/locale", codeset='utf-8', **kwargs) except: try: import builtins builtins.__dict__['_'] = str except ImportError: import __builtin__ __builtin__.__dict__['_'] = unicode gnome.program_init("SELinux Management Tool", "5") version = "1.0" sys.path.append('/usr/share/system-config-selinux') ## ## Pull in the Glade file ## if os.access("system-config-selinux.glade", os.F_OK): xml = gtk.glade.XML("system-config-selinux.glade", domain=PROGNAME) else: xml = gtk.glade.XML("/usr/share/system-config-selinux/system-config-selinux.glade", domain=PROGNAME)
os.putenv("DESKTOP_AUTOSTART_ID", "") self._enabled = succ if not self.enabled: self.output_info("Warning: Not able to connect to current " "desktop session, please Quit before logout to save " "kupfer's data.") def _connect_gnomeui(self): try: import gnome import gnome.ui except ImportError, exc: self.output_debug(exc) return False gnome.program_init(version.PACKAGE_NAME, version.VERSION) client = gnome.ui.master_client() client.connect("save-yourself", self._session_save) client.connect("die", self._session_die) self.output_debug("Setting up session connection using GnomeClient") return True def _connect_session_manager(self): bus = dbus.SessionBus() proxy_obj = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus') dbus_iface = dbus.Interface(proxy_obj, 'org.freedesktop.DBus') service_name = "org.gnome.SessionManager" obj_name = "/org/gnome/SessionManager" iface_name = service_name
## PROGNAME = "policycoreutils" import gettext gettext.bindtextdomain(PROGNAME, "/usr/share/locale") gettext.textdomain(PROGNAME) try: gettext.install(PROGNAME, localedir="/usr/share/locale", unicode=False, codeset='utf-8') except IOError: import builtins builtins.__dict__['_'] = str gnome.program_init("SELinux Policy Generation Tool", "5") version = "1.0" sys.path.append('/usr/share/system-config-selinux') sys.path.append('.') # From John Hunter http://www.daa.com.au/pipermail/pygtk/2003-February/004454.html def foreach(model, path, iter, selected): selected.append(model.get_value(iter, 0)) ## ## Pull in the Glade file ##
""" self.filechooserdialog_open.show_all() def on_button_fileopen_cancel_clicked(self, widget, data=None): """ 2015.01.23 """ self.filechooserdialog_open.hide() def on_button_fileopen_ok_clicked(self, widget, data=None): """ 2009-3-13 """ input_fname = self.filechooserdialog_open.get_filename() sampling_probability = float(self.entry_sampling_probability.get_text()) self.filechooserdialog_open.hide() self.readInDataToPlot(input_fname, sampling_probability) def on_entry_plot_title_change(self, widget, data=None): """ 2009-3-13 upon any change in the entry_plot_title """ self.plot_title = self.entry_plot_title.get_text() if __name__ == '__main__': prog = gnome.program_init('DataMatrixGUI', '0.1') instance = DataMatrixGUI() gtk.main()
print "WARNING: Unknown arguments passed, using defaults." opts = [] args = sys.argv[1:] for o, a in opts: if o in ("-h", "--help"): usage() elif o in ("-w", "--window"): standalone = True print 'Running with options:', { 'standalone': standalone, } gnome.program_init('glipper', '1.0', properties={gnome.PARAM_APP_DATADIR: glipper.DATA_DIR}) set_process_name() if standalone: import gnome gnome.init(glipper.defs.PACKAGE, glipper.defs.VERSION) set_process_name() build_window() gtk.main() else: gnomeapplet.bonobo_factory("OAFIID:Glipper_Factory", gnomeapplet.Applet.__gtype__, glipper.defs.PACKAGE, glipper.defs.VERSION,
dialog.destroy() if ret == gtk.RESPONSE_OK: autorun(mount, program_to_spawn) if __name__=="__main__": # use nautilus translations # TODO: custom translations with new strings gettext.bindtextdomain("nautilus", "/usr/share/locale") gettext.bind_textdomain_codeset("nautilus", "UTF-8") gettext.textdomain("nautilus") app = gnome.program_init ("secure-nautilus-autorun", __version__, gnome.libgnome_module_info_get(), sys.argv, []); if len(sys.argv)!=2: sys.exit(0) # instantiate monitor so we get the "unmounted" signal properly monitor = gio.volume_monitor_get() if not monitor: sys.exit(-1) file = gio.File(sys.argv[1]) if not file: sys.exit(-2) mount = file.find_enclosing_mount()
import sys pygtk.require('2.0') import gtk import gnome import gnome.ui import gnomeapplet import subprocess import gobject from colorpicker.globals import * from colorpicker.preferences import * MAX_HISTORY = 16 gnome.program_init("colorpicker", "1.0") def color_to_string(clr): return '#%02x%02x%02x' % (clr.red/256, clr.green/256, clr.blue/256) def lighten(clr): newclr = gtk.gdk.Color(clr.red+(16*256), clr.green+(16*256), clr.blue+(16*256)) if newclr.red > 65535: newclr.red = 65535 if newclr.green > 65535: newclr.green = 65535 if newclr.blue > 65535: newclr.blue = 65535 return newclr def darken(clr):
# Make the outline light original_weight = widget.get_data('original_weight') widget.set(weight=original_weight) return True return False def on_button_row_rate_clicked(self, widget, data=None): """ 2008-02-06 """ if self.qc_class_ins: self.qc_class_ins.plot_row_NA_mismatch_rate('%s vs %s strain-wise'%(os.path.basename(self.input_fname1), os.path.basename(self.input_fname2))) else: self.app_input_appbar.push("Error: Instantiate Class First!") def on_button_col_rate_clicked(self, widget, data=None): """ 2008-02-06 """ if self.qc_class_ins: self.qc_class_ins.plot_col_NA_mismatch_rate('%s vs %s snp-wise'%(os.path.basename(self.input_fname1), os.path.basename(self.input_fname2))) else: self.app_input_appbar.push("Error: Instantiate Class First!") prog = gnome.program_init('QCVisualizeII', '0.1') #prog.set_property('app-datadir', '/usr/share') #prog.set_property('default-icon', '/usr/share/pixmaps/apple-green.png') instance = QCVisualizeII() gtk.main()
def create_gnome_app( cfg ): gnome_props = { gnome.PARAM_APP_DATADIR : '/usr/share' } return gnome.program_init( 'backintime', cfg.VERSION, properties = gnome_props )
def init_for_help(application_dir="/"): props = { gnome.PARAM_APP_DATADIR : os.path.join(application_dir, 'usr/share/package-manager/help') } gnome.program_init('package-manager', '0.1', properties=props)
fd = os.open(self.config.named_pipe, os.O_RDONLY | os.O_NONBLOCK) except OSError, e: dialog = ErrorDialog(self.root_widget, "Unable to open file", "The file '%s' cannot be read. Please check " "the permissions and try again." % self.config.named_pipe) dialog.run() dialog.destroy() sys.exit() else: gobject.io_add_watch(fd, gobject.IO_IN, self.read_pipe) def on_app1_delete_event(self, *args): self.toggle_visibility() return True def main(): config = Config(gconf.client_get_default()) if config.is_first_run(): window = WelcomeDruid(config) window.show() else: window = MainWindow(config) gtk.main() if __name__ == "__main__": program = gnome.program_init("bandsaw", __VERSION__) main()
Requires PyGtk 2.6 Released under the terms of the revised BSD license Modified: 2015-12-21 """ from __future__ import division import sys, os, gtk, pango, ConfigParser #import math from math import * app_version = "1.3.3" try: import gnome props = {gnome.PARAM_APP_DATADIR: '/usr/share'} prog = gnome.program_init("lybniz", str(app_version), properties=props) except: print "Gnome not found" import gettext gettext.install('lybniz') # profiling enable_profiling = False if enable_profiling: from time import time app_win = None actions = gtk.ActionGroup("General") graph = None
win.show_all() def on_button_refresh_interval_clicked(self, widget=None, data=None): """ 2009-11-10 set the refresh interval in the node_queue_app (checking status of nodes in the queue """ entry_checking_interval = self.xml.get_widget("entry_checking_interval") self.backend_ins.checkStatusOfNodesInQueue() if self.node_queue_refresh_timeout_source_id is not None: gobject.source_remove(self.node_queue_refresh_timeout_source_id) interval_str = entry_checking_interval.get_text() if not interval_str: interval_str = '10m' #default is 10m interval = self.getTimeIntervalFromStr(interval_str) self.node_queue_refresh_timeout_source_id = gobject.timeout_add(interval, self.backend_ins.checkStatusOfNodesInQueue) self.displayQueueWindow() def on_button_stop_node_status_refresh_clicked(self, widget, data=None): """ 2009-11-10 remove the timeout function """ if self.node_queue_refresh_timeout_source_id is not None: gobject.source_remove(self.node_queue_refresh_timeout_source_id) if __name__ == '__main__': prog = gnome.program_init('ClusterJobManager', '0.1') instance = grid_job_mgr() gtk.main()
def on_message_arrived(self, message): buf = self.glade.get_widget("ReceiveText").get_buffer() info = dict(message[1][0]) info['tags'] = '; '.join(message[0]) buf.insert(buf.get_end_iter(), "%(tags)s\n%(content)s\n\n" % info) class MainWindow(EpicenterWidget): def __init__(self, bus, **kw): self.bus = bus self.storage = dbus.Interface( bus.get_object('org.redhog.epicenter', '/org/redhog/epicenter/storage'), dbus_interface='org.redhog.epicenter.storage') EpicenterWidget.__init__(self, **kw) def on_NewPage_clicked(self, button): searches = self.glade.get_widget("Searches") page_nr = searches.get_n_pages() - 1 content = SearchContent(parent = self) header = SearchHeader(parent = self, content = content) searches.insert_page(content.widget, header.widget, page_nr) def on_MainWindow_delete_event(self, window, event): gtk.main_quit() gnome.program_init("Epicenter", "0.01") dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) MainWindow(dbus.SessionBus()) gtk.main()
def create_gnome_app(cfg): gnome_props = {gnome.PARAM_APP_DATADIR: '/usr/share'} return gnome.program_init('backintime', cfg.VERSION, properties=gnome_props)
Requires PyGtk 2.6 Released under the terms of the revised BSD license Modified: 2015-12-21 """ from __future__ import division import sys, os, gtk, pango, ConfigParser #import math from math import * app_version = "1.3.3" try: import gnome props = {gnome.PARAM_APP_DATADIR : '/usr/share'} prog = gnome.program_init("lybniz", str(app_version), properties=props) except: print "Gnome not found" import gettext gettext.install('lybniz') # profiling enable_profiling = False if enable_profiling: from time import time app_win = None actions = gtk.ActionGroup("General") graph = None
return False def on_button_row_rate_clicked(self, widget, data=None): """ 2008-02-06 """ if self.qc_class_ins: self.qc_class_ins.plot_row_NA_mismatch_rate( '%s vs %s strain-wise' % (os.path.basename( self.input_fname1), os.path.basename(self.input_fname2))) else: self.app_input_appbar.push("Error: Instantiate Class First!") def on_button_col_rate_clicked(self, widget, data=None): """ 2008-02-06 """ if self.qc_class_ins: self.qc_class_ins.plot_col_NA_mismatch_rate( '%s vs %s snp-wise' % (os.path.basename( self.input_fname1), os.path.basename(self.input_fname2))) else: self.app_input_appbar.push("Error: Instantiate Class First!") prog = gnome.program_init('QCVisualizeII', '0.1') #prog.set_property('app-datadir', '/usr/share') #prog.set_property('default-icon', '/usr/share/pixmaps/apple-green.png') instance = QCVisualizeII() gtk.main()
def init_for_help(application_dir="/"): props = { gnome.PARAM_APP_DATADIR: os.path.join(application_dir, 'usr/share/package-manager/help') } gnome.program_init('package-manager', '0.1', properties=props)
def main(): gnome.program_init(NAME, VERSION) config = Configuration() newt = Newton(config, 'window') newt.toggle_window_visible() gtk.main()
""" self.filechooserdialog_open.show_all() def on_button_fileopen_cancel_clicked(self, widget, data=None): """ 2015.01.23 """ self.filechooserdialog_open.hide() def on_button_fileopen_ok_clicked(self, widget, data=None): """ 2009-3-13 """ input_fname = self.filechooserdialog_open.get_filename() sampling_probability = float(self.entry_sampling_probability.get_text()) self.filechooserdialog_open.hide() self.readInDataToPlot(input_fname, sampling_probability) def on_entry_plot_title_change(self, widget, data=None): """ 2009-3-13 upon any change in the entry_plot_title """ self.plot_title = self.entry_plot_title.get_text() if __name__ == '__main__': prog = gnome.program_init('DataMatrixGuiXYProbe', '0.1') instance = DataMatrixGuiXYProbe() gtk.main()
Unable to initialize graphical environment. Most likely cause of failure is that the tool was not run using a graphical environment. Please either start your graphical user interface or set your DISPLAY variable. Caught exception: %s """) % e sys.exit(-1) from lvm_model import lvm_model, lvm_conf_get_locking_type from Volume_Tab_View import Volume_Tab_View from lvmui_constants import * import gnome import gnome.ui gnome.program_init(PROGNAME, VERSION) gnome.app_version = VERSION FORMALNAME = _("system-config-lvm") ABOUT_VERSION = _("%s %s") % ('system-config-lvm', VERSION) from execute import execWithCapture from Cluster import Cluster ############################################### class baselvm: def __init__(self, glade_xml, app): # check locking type locking_type = lvm_conf_get_locking_type() if locking_type != 1:
action="store_true", dest="as_extension", help="usar interface reducida, apropiada para administradores de ficheiros", ) parser.add_option("-s", "--standalone", action="store_false", dest="as_extension", help="usar interface completa") parser.add_option( "-u", "--uri-list", action="store_true", dest="as_uris", help="tratamento de URIs, no lugar de ficheiros locais" ) parser.add_option("--show-initial-warning", action="store_true", dest="initial_warning") options, input_files = parser.parse_args() if not input_files: options.as_extension = False gnome.program_init(constants.name, constants.version) class Info: pass class Callbacks: def __init__(self): self.file_selection_work_pending = False self.non_local_warning_message_visible = False self.selection_info_visible = False if options.initial_warning: self.show_non_local_warning() self.complete_can_close = False self.dirs = {}
def get_app(): program = gnome.program_init("gstratatest", "1.0") app = GStrataTest("GStrataTest", "GStrataTest") xml = gtk.glade.XML("gstratatest.glade") xml.signal_autoconnect(app) return app
## PROGNAME="policycoreutils" import gettext gettext.bindtextdomain(PROGNAME, "/usr/share/locale") gettext.textdomain(PROGNAME) try: gettext.install(PROGNAME, localedir="/usr/share/locale", unicode=False, codeset = 'utf-8') except IOError: import __builtin__ __builtin__.__dict__['_'] = unicode gnome.program_init("SELinux Policy Generation Tool", "5") version = "1.0" sys.path.append('/usr/share/system-config-selinux') sys.path.append('.') # From John Hunter http://www.daa.com.au/pipermail/pygtk/2003-February/004454.html def foreach(model, path, iter, selected): selected.append(model.get_value(iter, 0)) ## ## Pull in the Glade file ## if os.access("polgen.glade", os.F_OK): xml = gtk.glade.XML ("polgen.glade", domain=PROGNAME)
""" 2009-3-13 """ delimiter = figureOutDelimiter(input_fname) self.header, self.strain_acc_list, self.category_list, self.data_matrix = read_data(input_fname, delimiter=delimiter) def on_imagemenuitem_open_activate(self, widget, data=None): """ 2009-3-13 """ self.filechooserdialog_open.show_all() def on_button_fileopen_ok_clicked(self, widget, data=None): """ 2009-3-13 """ input_fname = self.filechooserdialog_open.get_filename() self.filechooserdialog_open.hide() self.readInDataToPlot(input_fname) def on_entry_plot_title_change(self, widget, data=None): """ 2009-3-13 upon any change in the entry_plot_title """ self.plot_title = self.entry_plot_title.get_text() if __name__ == '__main__': prog = gnome.program_init('DataMatrixGuiXYProbe', '0.1') instance = DataMatrixGuiXYProbe() gtk.main()
def __init__(self, start_hidden, tray_icon): super(Browser, self).__init__() self.glade=Gtk.glade.XML(utils.get_data_file_name('labyrinth.glade')) self.view = self.glade.get_widget ('MainView') self.populate_view () self.view.connect ('row-activated', self.open_row_cb) self.view.connect ('cursor-changed', self.cursor_change_cb) self.view_dependants = [] self.open_button = self.glade.get_widget('OpenButton') self.delete_button = self.glade.get_widget('DeleteButton') self.open_menu = self.glade.get_widget('open1') self.delete_menu = self.glade.get_widget('delete1') self.view_dependants.append (self.open_button) self.view_dependants.append (self.delete_button) self.view_dependants.append (self.open_menu) self.view_dependants.append (self.delete_menu) self.open_button.connect ('clicked', self.open_clicked) self.glade.get_widget('NewButton').connect ('clicked', self.new_clicked) self.delete_button.connect ('clicked', self.delete_clicked) self.open_menu.connect ('activate', self.open_clicked) self.glade.get_widget('new1').connect ('activate', self.new_clicked) self.delete_menu.connect ('activate', self.delete_clicked) self.glade.get_widget('import1').connect ('activate', self.import_clicked) self.glade.get_widget('quit1').connect ('activate', self.quit_clicked) self.glade.get_widget('about1').connect ('activate', self.about_clicked) self.glade.get_widget('showhelp').connect ('activate', self.show_help_clicked) map(lambda x : x.set_sensitive(False), self.view_dependants) props = { gnome.PARAM_APP_DATADIR : '/usr/share' } prog = gnome.program_init('labyrinth', '0.5', properties=props) self.main_window = self.glade.get_widget ('MapBrowser') # set remembered size if os.name != 'nt': self.config_client = GConf.Client.get_default() self.config_client.add_dir ("/apps/labyrinth", GConf.ClientPreloadType.PRELOAD_NONE) width = self.config_client.get_int ('/apps/labyrinth/width') height = self.config_client.get_int ('/apps/labyrinth/height') utils.use_bezier_curves = self.config_client.get_bool ('/apps/labyrinth/curves') if width == 0 or height == 0: width = 400 height = 300 else: width = 400 height = 300 view_sortable = self.view.get_model () view_sortable.connect ('sort-column-changed', self.sort_column_changed_cb) if os.name != 'nt': sort_order = self.config_client.get_int('/apps/labyrinth/map_sort_order') column_id = self.config_client.get_int('/apps/labyrinth/map_sort_order_column') view_sortable.set_sort_column_id (column_id, sort_order) self.main_window.resize (width, height) if os.name != 'nt': try: self.main_window.set_icon_name ('labyrinth') except: self.main_window.set_icon_from_file(utils.get_data_file_name('labyrinth.svg')) else: self.main_window.set_icon_from_file('images\\labyrinth-24.png') if tray_icon: self.main_window.connect ('delete_event', self.toggle_main_window, None) traymenu = Gtk.Menu() quit_item = Gtk.MenuItem("Quit") quit_item.connect("activate",self.quit_clicked) traymenu.add(quit_item) traymenu.show_all() self.traymenu = traymenu self.trayicon = TrayIcon.TrayIcon( icon_name="labyrinth", menu=traymenu, activate=self.toggle_main_window) else: self.main_window.connect('delete_event', self.quit_clicked, None) if start_hidden: self.main_window.hide () else: self.main_window.show_all ()
def __init__(self, plot_title='', id_is_strain=1, header=None, strain_acc_list=None, category_list=None, data_matrix=None): """ 2008-01-10 use a paned window to wrap the scrolledwindow and the canvas so that the relative size of canvas to the scrolledwindow could be adjusted by the user. """ prog = gnome.program_init('DataMatrixGuiXYProbe', '0.1') #this must be called before any initialization for gnome app program_path = os.path.dirname(__init__.__file__) #sys.argv[0]) xml = gtk.glade.XML(os.path.join(program_path, 'DataMatrixGuiXYProbe.glade')) xml.signal_autoconnect(self) self.app1 = xml.get_widget("app1") self.app1.connect("delete_event", gtk.main_quit) self.app1.set_default_size(800, 1000) self.app1.set_title(plot_title) self.plot_title = plot_title self.id_is_strain = id_is_strain self.header = header self.strain_acc_list = strain_acc_list self.category_list = category_list self.data_matrix = data_matrix self.column_types = None self.column_header = None self.column_editable_flag_ls = None self.list_2d = None self.column_types = None self.list_2d = None self.column_header = None self.editable_flag_ls = None self.vbox1 = xml.get_widget("vbox1") self.treeview_matrix = xml.get_widget("treeview_matrix") # matplotlib stuff fig = Figure(figsize=(8,8)) self.canvas = FigureCanvas(fig) # a gtk.DrawingArea self._idClick = self.canvas.mpl_connect('button_press_event', self.on_click) self.vpaned1 = xml.get_widget("vpaned1") self.vpaned1.add2(self.canvas) #vbox.pack_start(self.canvas, True, True) self.ax = fig.add_subplot(111) self.treeview_matrix.connect('row-activated', self.plot_row) toolbar = NavigationToolbar(self.canvas, self.app1) self.vbox1.pack_start(toolbar, False, False) self.checkbutton_label_dot = xml.get_widget('checkbutton_label_dot') self.entry_dot_label_column = xml.get_widget('entry_dot_label_column') self.entry_x_column = xml.get_widget('entry_x_column') self.entry_y_column = xml.get_widget('entry_y_column') self.entry_hist_column = xml.get_widget('entry_hist_column') self.entry_no_of_bins = xml.get_widget('entry_no_of_bins') #2009-5-20 self.entry_plot_title = xml.get_widget('entry_plot_title') self.entry_plot_title.set_text(self.plot_title) self.filechooserdialog_save = xml.get_widget("filechooserdialog_save") self.filechooserdialog_save.connect("delete_event", yh_gnome.subwindow_hide) self.filechooserdialog_open = xml.get_widget("filechooserdialog_open") self.filechooserdialog_open.connect("delete_event", yh_gnome.subwindow_hide) self.app1_appbar1 = xml.get_widget('app1_appbar1') self.app1_appbar1.push('Status Message.') #import gnome.ui has to be executed. self.treeview_matrix.connect('cursor-changed', self.update_no_of_selected, self.app1_appbar1) self.app1.show_all()
## PROGNAME = "policycoreutils" import gettext gettext.bindtextdomain(PROGNAME, "/usr/share/locale") gettext.textdomain(PROGNAME) try: gettext.install(PROGNAME, localedir="/usr/share/locale", unicode=False, codeset='utf-8') except IOError: import __builtin__ __builtin__.__dict__['_'] = unicode gnome.program_init("SELinux Management Tool", "5") version = "1.0" sys.path.append('/usr/share/system-config-selinux') ## ## Pull in the Glade file ## if os.access("system-config-selinux.glade", os.F_OK): xml = gtk.glade.XML("system-config-selinux.glade", domain=PROGNAME) else: xml = gtk.glade.XML( "/usr/share/system-config-selinux/system-config-selinux.glade", domain=PROGNAME)
self._enabled = succ if not self.enabled: self.output_info( "Warning: Not able to connect to current " "desktop session, please Quit before logout to save " "kupfer's data.") def _connect_gnomeui(self): try: import gnome import gnome.ui except ImportError, exc: self.output_debug(exc) return False gnome.program_init(version.PACKAGE_NAME, version.VERSION) client = gnome.ui.master_client() client.connect("save-yourself", self._session_save) client.connect("die", self._session_die) self.output_debug("Setting up session connection using GnomeClient") return True def _connect_session_manager(self): bus = dbus.SessionBus() proxy_obj = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus') dbus_iface = dbus.Interface(proxy_obj, 'org.freedesktop.DBus') service_name = "org.gnome.SessionManager" obj_name = "/org/gnome/SessionManager" iface_name = service_name
def __init__(self, plot_title='', id_is_strain=1, header=None, strain_acc_list=None, category_list=None, data_matrix=None): """ 2008-01-10 use a paned window to wrap the scrolledwindow and the canvas so that the relative size of canvas to the scrolledwindow could be adjusted by the user. """ prog = gnome.program_init('DataMatrixGUI', '0.1') #this must be called before any initialization for gnome app program_path = os.path.dirname(__init__.__file__) xml = gtk.glade.XML(os.path.join(program_path, 'DataMatrixGUI.glade')) xml.signal_autoconnect(self) self.app1 = xml.get_widget("app1") self.app1.connect("delete_event", gtk.main_quit) self.app1.set_default_size(800, 1000) self.app1.set_title(plot_title) self.plot_title = plot_title self.id_is_strain = id_is_strain self.header = header self.strain_acc_list = strain_acc_list self.category_list = category_list self.data_matrix = data_matrix self.inputDataHeaders = None self.columnTypes = None self.columnHeaders = None self.columnEditableFlagList = None self.list2D = None self.vbox1 = xml.get_widget("vbox1") self.treeview_matrix = xml.get_widget("treeview_matrix") # matplotlib stuff fig = Figure(figsize=(8,8)) self.canvas = FigureCanvas(fig) # a gtk.DrawingArea self._idClick = self.canvas.mpl_connect('button_press_event', self.onUserClickCanvas) self.vpaned1 = xml.get_widget("vpaned1") self.vpaned1.add2(self.canvas) #self.vbox1.pack_start(self.canvas, True, True) self.ax = fig.add_subplot(111) self.treeview_matrix.connect('row-activated', self.plot_row) toolbar = NavigationToolbar(self.canvas, self.app1) self.vbox1.pack_start(toolbar, False, False) self.checkbutton_label_dot = xml.get_widget('checkbutton_label_dot') self.entry_dot_label_column = xml.get_widget('entry_dot_label_column') self.dataLabelColumnIndexAndSeparatorList = None self.dataLabelNumericItemIndexList = None self.entry_x_na = xml.get_widget('entry_x_na') self.entry_y_na = xml.get_widget('entry_y_na') self.entry_multiply_x = xml.get_widget('entry_multiply_x') self.entry_multiply_y = xml.get_widget('entry_multiply_y') self.entry_add_x = xml.get_widget('entry_add_x') self.entry_add_y = xml.get_widget('entry_add_y') self.entry_x_error = xml.get_widget("entry_x_error") self.entry_y_error = xml.get_widget("entry_y_error") self.checkbutton_logX = xml.get_widget('checkbutton_logX') self.checkbutton_logY = xml.get_widget('checkbutton_logY') self.checkButtonPlotOnlySelected = xml.get_widget('checkButtonPlotOnlySelected') self.entry_x_column = xml.get_widget('entry_x_column') self.entry_y_column = xml.get_widget('entry_y_column') self.entry_filters = xml.get_widget("entry_filters") #self.checkbutton_histLogX = xml.get_widget('checkbutton_histLogX') #self.checkbutton_histLogY = xml.get_widget('checkbutton_histLogY') self.entry_hist_column = xml.get_widget('entry_hist_column') self.entry_no_of_bins = xml.get_widget('entry_no_of_bins') self.entry_plot_title = xml.get_widget('entry_plot_title') self.entry_plot_title.set_text(self.plot_title) self.filechooserdialog_save = xml.get_widget("filechooserdialog_save") self.filechooserdialog_save.connect("delete_event", yh_gnome.subwindow_hide) self.entry_sampling_probability = xml.get_widget("entry_sampling_probability") self.filechooserdialog_open = xml.get_widget("filechooserdialog_open") self.filechooserdialog_open.connect("delete_event", yh_gnome.subwindow_hide) self.app1_appbar1 = xml.get_widget('app1_appbar1') self.app1_appbar1.push('Status Message.') #import gnome.ui has to be executed. self.treeview_matrix.connect('cursor-changed', self.update_no_of_selected, self.app1_appbar1) self.app1.show_all() self.xValuePreProcessor = None self.yValuePreProcessor = None self.x_error_column_index = None self.y_error_column_index = None self.typeName2PythonType = { "str": str, "string": str, "numeric":float, "number":float, "double":float, "float":float, "integer":int, "int":int}
try: import gnome except ImportError, e: exit_with_error('Importing gnome module failed', err) try: import gconf except ImportError, e: exit_with_error('Importing gconf module failed', err) import specimen.config as config gettext.bindtextdomain(config.PACKAGE, config.LOCALEDIR) gettext.textdomain(config.PACKAGE) gtk.glade.bindtextdomain(config.PACKAGE, config.LOCALEDIR) gtk.glade.textdomain(config.PACKAGE) prog = gnome.program_init(config.PACKAGE, config.VERSION) gtk.window_set_default_icon_name('gnome-specimen') from specimenwindow import SpecimenWindow w = SpecimenWindow() try: gtk.main () except (KeyboardInterrupt): pass