def __init__(self, path, solution): import pygtk import gtk pygtk.require('2.0') self.solution = solution self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.show() self.window.connect('destroy', self.destroy) self.box = gtk.HBox() self.image = gtk.Image() self.image.set_from_file(path) self.entry = gtk.Entry() self.entry.connect('activate', self.solve) self.button = gtk.Button('Go') self.button.connect('clicked', self.solve) self.window.add(self.box) self.box.pack_start(self.image) self.box.pack_start(self.entry) self.box.pack_start(self.button) self.box.show() self.image.show() self.button.show() self.entry.show() self.entry.grab_focus()
def gtkui_dependency_check(): ''' This function verifies that the dependencies that are needed by the GTK user interface are met. ''' print '\tGTK UI dependencies...', # Check Gtk try: import pygtk pygtk.require('2.0') import gtk, gobject assert gtk.gtk_version >= (2, 12) assert gtk.pygtk_version >= (2, 12) print OKGREEN + "\tOK" + ENDC except: print FAIL + "\tD'oh!" + ENDC msg = 'You have to install GTK and PyGTK versions >=2.12 to be able to run the GTK user interface.\n' msg += ' - On Debian-based distributions: apt-get install python-gtk2\n' msg += ' - On Mac: sudo port install py25-gtk' print msg sys.exit( 1 ) # Check GtkSourceView2 try: print '\tGtkSourceView2...', import gtksourceview2 print OKGREEN + "\tOK" + ENDC except: print FAIL + "\tD'oh!" + ENDC print "GtkSourceView2 not installed! Install it for your platform:" print " - On Debian-based distributions: apt-get install python-gtksourceview2" sys.exit( 1 )
def run_osra(osra): sdf = " " filedes, filename = tempfile.mkstemp(suffix='.png') if os.name=="posix": import pygtk pygtk.require('2.0') import gtk, gobject clipboard = gtk.clipboard_get() image=clipboard.wait_for_image() if not image: return sdf try: image.save(filename,"png") except: return sdf else: import ImageGrab image = ImageGrab.grabclipboard() if not image: return sdf try: image.save(filename) except: return sdf try: stdout, stdin, stderr = popen2.popen3('"%s" -f sdf %s' % (osra, filename)) except: os.remove(filename) return sdf sdf = stdout.read() #os.remove(filename) return sdf
def main (args): import locale import gettext import pygtk; pygtk.require('2.0'); import gobject from gobject.option import OptionParser, make_option import gtk import maindialog import config locale.setlocale (locale.LC_ALL, "") gettext.install (config.PACKAGE, config.LOCALEDIR) parser = OptionParser ( option_list = [ # FIXME: remove this when we can get all the default # options make_option ("--version", action="store_true", dest="version", help=config.VERSION), ]) parser.parse_args (args) if parser.values.version: # Translators: %s is the version number print _("Simple Menu Editor %s") % (config.VERSION) else: dialog = maindialog.MenuEditorDialog (args) gtk.main ()
def _check_libs(): try: import pygtk pygtk.require('2.0') import gtk import gnome import gnome.ui gnome.ui.authentication_manager_init() import gconf import gobject gobject.threads_init() import gnomevfs except ImportError: print '%s needs pygtk and gnome-python >= 2.12!' % NAME sys.exit(1) try: import pygst pygst.require('0.10') import gst except ImportError: print '%s needs python-gstreamer 0.10!' % NAME sys.exit(1) print ' using Gstreamer version: %s' % ( '.'.join([str(s) for s in gst.gst_version]))
def genNotify(gn_title="",gn_msg="",gn_duration=5): #This will be the generic notification that will be called throughout #it will try to contact xbmc first...if it can't it will pass the message to pynotify. global os gn_return="" msg=urllib.quote(gn_msg) #Hopefully that will have 'escaped' characters and encoded accordingly urltoget="GET \"http://%s:%s@%s/xbmcCmds/xbmcHttp?command=ExecBuiltIn(Notification(%s, %s,7500))\"" % (gm_xbmcusername,gm_xbmcpassword,gm_xbmcaddress,gn_title,msg) logger.debug("Sending xbmc msg via: %s" % urltoget) xbmcsuccess= str(os.system(urltoget)) if "<li>OK" in xbmcsuccess: return gn_return exit try: #will doing this import over and over eat memory, or is it clever enough to not? mmm import gtk, pygtk, os, os.path, pynotify pygtk.require('2.0') except: gn_return = "Error: need python-notify, python-gtk2 and gtk" if not pynotify.init("Timekpr notification"): return "timekpr notification failed to initialize" sys.exit(1) n = pynotify.Notification(gn_title, gn_msg,"file://%s/icon.png" % mypath) #n = pynotify.Notification("Moo title", "test", "file:///path/to/icon.png") n.set_urgency(pynotify.URGENCY_CRITICAL) n.set_timeout(gn_duration*1000) # 5 seconds n.set_category("device") if not n.show(): gn_return= "Failed" return gn_return
def copy_to_clipboard_on_linux(text): """ Copies a text to Clipboard on Linux. http://www.answermysearches.com/ python-how-to-copy-and-paste-to-the-clipboard-in-linux/286/ """ try: import pygtk pygtk.require('2.0') import gtk # get the clipboard clipboard = gtk.clipboard_get() # set the clipboard text data clipboard.set_text(text) # make our data available to other applications clipboard.store() except: # pylint: disable-msg=W0702 # W0702: No exception type(s) specified print "Unexpected error:", sys.exc_info()[0] # copying to clipboard using GTK did not work. # maybe, Tkinter will work, so try it too. copy_to_clipboard_on_windows(text)
def get_gtk_keymap(ignore_keys=[None, "VoidSymbol"], add_if_missing=[]): """ Augment the keymap we get from gtk.gdk.keymap_get_default() by adding the keyval_name. We can also ignore some keys """ import pygtk pygtk.require("2.0") import gtk keymap = gtk.gdk.keymap_get_default() keycodes=[] max_entries = 1 for i in range(0, 2**8): entries = keymap.get_entries_for_keycode(i) if entries: max_entries = max(max_entries, len(entries)) for keyval, keycode, group, level in entries: name = gtk.gdk.keyval_name(keyval) if name not in ignore_keys: keycodes.append((nn(keyval), nn(name), nn(keycode), nn(group), nn(level))) if name in add_if_missing: add_if_missing.remove(name) #TODO: do this server-side to ensure all modifiers can be set if add_if_missing: for name in add_if_missing: keycodes.append((0, name, 0, 0, 0)) return keycodes
def __init__(self): import pygtk pygtk.require('2.0') import gtk import pango self.gtk = gtk self.gtk.gdk.set_program_class('launchbox') self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect('delete_event', self.on_delete_event) self.window.connect('destroy', self.on_destroy) self.window.padding = 10 self.alignment = gtk.Alignment() self.alignment.set_padding(10, 10, 10, 10) self.window.add(self.alignment) self.entry = gtk.Entry() self.entry.set_width_chars(24) self.entry.modify_font(pango.FontDescription('40')) self.alignment.add(self.entry) # self.window.set_focus(self.entry) self.window.set_position(gtk.WIN_POS_CENTER) self.window.show_all() self.window.window.focus() self.completer = Completer() self.window.add_events(gtk.gdk.KEY_PRESS_MASK) self.entry.connect('key-press-event', self.on_key_press_event) self.entry.connect('key-release-event', self.on_key_release_event)
def gtk2_dialog(): # GTK+ 2 import pygtk pygtk.require('2.0') dialog = gtk.FileChooserDialog(title, None, gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) if extensions: for entry in extensions: file_filter = gtk.FileFilter() file_filter.set_name(entry) for pattern in extensions[entry]: file_filter.add_pattern(pattern) dialog.add_filter(file_filter) dialog.set_select_multiple(multiple_files) response = dialog.run() if response == gtk.RESPONSE_OK: return dialog.get_filenames() elif response == gtk.RESPONSE_CANCEL: return None dialog.destroy()
def dependency_check(): """ This dependency check function uses the information stored in the platforms module to call the function in core.controllers.dependency_check which actually checks for the dependencies. The data in the core.ui.gui.dependency_check.platforms module is actually based on the data stored in core.controllers.dependency_check.platforms, we extend() the lists present in the base module before passing them to mdep_check() """ should_exit = mdep_check(dependency_set=GUI, exit_on_failure=False) try: import pygtk pygtk.require('2.0') import gtk import gobject assert gtk.gtk_version >= (2, 12) assert gtk.pygtk_version >= (2, 12) except: msg = 'The GTK package requirements are not met, please make sure your'\ ' system meets these requirements:\n'\ ' - PyGTK >= 2.12\n'\ ' - GTK >= 2.12\n' print msg should_exit = True if should_exit: sys.exit(1)
def __init__(self, consumer_key, consumer_secret): auth = tweepy.OAuthHandler(consumer_key, consumer_secret) conf = self.__readSettings() if conf: auth.set_access_token(conf[0], conf[1]) else: import pygtk pygtk.require('2.0') import gtk clipboard = gtk.clipboard_get() auth_url = auth.get_authorization_url() oldText = clipboard.wait_for_text() self.__openUrlInBrowser(auth_url) while True: verifier = clipboard.wait_for_text() if verifier is not None and oldText != verifier and re.compile(r"\d{7}").match(verifier): logger.info("Pass verifier: " + str(verifier)) break; else: clipboard.clear() logger.info("wrong verifier: " + str(verifier)) sleep(1) auth.get_access_token(verifier) print "ACCESS_KEY = '%s'" % auth.access_token.key print "ACCESS_SECRET = '%s'" % auth.access_token.secret self.__auth = auth self.__writeSettings()
def lineReceived(self, line): if self.data_mode: if line == ".": self.sendCode(250, "Ok") self.data_mode = 0 try: self.output.close() except BaseException, e: print 'Something strange (%s) appened ' 'while closing the spool file' % e if self.verbose: print "A mail was sent..." if self.notify: import pygtk pygtk.require('2.0') import pynotify n = pynotify.Notification("Fake smtpserver", "a mail was sent...") n.show() else: try: self.output.write(line + '\n') except BaseException, e: print 'Something strange (%s) appened ' 'while writing to spool file' % e
def check_X (display, xauth): # Checking if I can use X os.environ['DISPLAY'] = display os.environ['XAUTHORITY'] = xauth try: import pygtk pygtk.require("2.0") except: pass try: import gtk except: print _("You need to install pyGTK or GTKv2,\n" "or set your PYTHONPATH correctly.\n" "try: export PYTHONPATH= ") sys.exit(1) try: gtk.init_check () except Exception as e: print _("Could not open a connection to X!") print e sys.exit (1)
def gtkui_dependency_check(): ''' This function verifies that the dependencies that are needed by the GTK user interface are met. ''' print('\tGTK UI dependencies...', end='') # Check Gtk try: import pygtk pygtk.require('2.0') import gtk, gobject assert gtk.gtk_version >= (2, 12) assert gtk.pygtk_version >= (2, 12) print(common.console_color('\tOK', 'green')) except: print(common.console_color("\tD'oh!", 'red')) print('You have to install GTK and PyGTK versions >=2.12 to be able to ' 'run the GTK user interface.\n' ' - On Debian-based distributions: apt-get install python-gtk2\n' ' - On Mac: sudo port install py25-gtk') sys.exit(1) # Check GtkSourceView2 try: print('\tGtkSourceView2...', end='') import gtksourceview2 print(common.console_color('\tOK', 'green')) except: print(common.console_color("\tD'oh!", 'red')) print('GtkSourceView2 not installed! Install it for your platform:\n' ' - On Debian-based distributions: apt-get install python-gtksourceview2') sys.exit(1)
def copy_url(url): """Copy the url into the clipboard.""" # try windows first try: import win32clipboard import win32con except ImportError: # then give pbcopy a try. do that before gtk because # gtk might be installed on os x but nobody is interested # in the X11 clipboard there. from subprocess import Popen, PIPE try: client = Popen(['pbcopy'], stdin=PIPE) except OSError: try: import pygtk pygtk.require('2.0') import gtk import gobject except ImportError: return gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD).set_text(url) gobject.idle_add(gtk.main_quit) gtk.main() else: client.stdin.write(url) client.stdin.close() client.wait() else: win32clipboard.OpenClipboard() win32clipboard.EmptyClipboard() win32clipboard.SetClipboardText(url) win32clipboard.CloseClipboard()
def _check_pygtk(self, pygtk_version, gtk_version): try: import gtk gtk # pylint: disable=W0104 except ImportError: try: import pygtk # This modifies sys.path pygtk.require('2.0') # Try again now when pygtk is imported import gtk except ImportError as e: # Can't display a dialog here since gtk is not available raise SystemExit( "ERROR: PyGTK not found, can't start Stoq: %r" % (e, )) if gtk.pygtk_version < pygtk_version: self._too_old(project="PyGTK+", url="http://www.pygtk.org/", found=_tuple2str(gtk.pygtk_version), required=pygtk_version) if gtk.gtk_version < gtk_version: self._too_old(project="Gtk+", url="http://www.gtk.org/", found=_tuple2str(gtk.gtk_version), required=gtk_version)
def __init__(self): try: import pygtk pygtk.require("2.0") except: print "FAILS" pass try: import gtk import gtk.glade except: sys.exit(1) self.widgetTree = gtk.glade.XML("CreateTask.glade") self.window = self.widgetTree.get_widget("mainWindow") dic = { "on_click_create_btn" : self.on_click_create_btn, "on_click_cancel_btn" : self.on_click_cancel_btn } self.widgetTree.signal_autoconnect( dic ) self.set_project_combo()
def import_pygtk(): try: import pygtk except ImportError: raise errors.BzrCommandError("PyGTK not installed.") pygtk.require('2.0') return pygtk
def init_pygtk(self): """ Make sure we have GTK+ >= 2.0 """ import pygtk pygtk.require('2.0') del pygtk
def import_gtk2(): import pygtk pygtk.require("2.0") import gtk return gtk
def copy_url(url): """Copy the url into the clipboard.""" if sys.platform == 'darwin': url = re.escape(url) os.system(r"echo %s | pbcopy" % url) return True try: import win32clipboard import win32con win32clipboard.OpenClipboard() win32clipboard.EmptyClipboard() win32clipboard.SetClipboardText(url) win32clipboard.CloseClipboard() return True except ImportError: try: if os.environ.get('DISPLAY'): import pygtk pygtk.require('2.0') import gtk import gobject gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD).set_text(url) gobject.idle_add(gtk.main_quit) gtk.main() return True except: pass return False
def checkTicket347(): """ Check for a recent enough PyGTK to not leak python integers in message processing (mostly affects soundcard, firewire) """ result = messages.Result() import pygtk pygtk.require('2.0') import gobject # Really, we want to check for pygobject_version, but that doesn't exist in # all versions of pygtk, and this check is sufficient. (major, minor, nano) = gobject.pygtk_version if (major, minor, nano) < (2, 8, 6): m = messages.Warning(T_( N_("Version %d.%d.%d of the PyGTK library contains " "a memory leak.\n"), major, minor, nano), mid='ticket-347') m.add(T_(N_("The Soundcard and Firewire sources may leak a lot of " "memory as a result, and would need to be restarted " "frequently.\n"))) m.add(T_(N_("Please upgrade '%s' to version %s or later."), 'pygtk', '2.8.6')) result.add(m) result.succeed(None) return defer.succeed(result)
def parse_config(self): self.config = ConfigParser.RawConfigParser() self.config.readfp(StringIO.StringIO(self.default_config)) self.config.read([ '/etc/marchobmenu/menu.conf', os.path.expanduser('~/.config/marchobmenu/menu.conf') ]) self.show_icons = self.config.getboolean('Icons', 'show') if self.show_icons: self.default_icon = self.config.get('Icons', 'default') self.icon_size = self.config.getint('Icons', 'size') self.use_gtk_theme = self.config.getboolean('Icons', 'use_gtk_theme') if self.use_gtk_theme: try: import pygtk pygtk.require('2.0') import gtk gtk_settings = gtk.settings_get_default() self.theme = gtk_settings.get_property('gtk-icon-theme-name') except: self.use_gtk_theme = False self.theme = self.config.get('Icons','theme') else: self.theme = self.config.get('Icons','theme')
def check_posix_dependencies(): """ Returns a list with all the import's problems This is run at startup to ease users solving dependencies problems """ resp = [] try: import pygtk pygtk.require("2.0") except ImportError: resp.append("python-gtk2 module not found, please install it") except AssertionError: resp.append("python-gtk module found, please upgrade to python-gtk2") try: from twisted.copyright import version if [int(x) for x in re.search(r'^(\d+)\.(\d+)\.(\d+)', version).groups()] < [ 2, 2, 0, ]: resp.append("python-twisted module is too old, please upgrade it") except ImportError: resp.append("python-twisted module not found, please install it") import gtk if not hasattr(gtk, 'StatusIcon'): try: import egg.trayicon except ImportError: resp.append("egg.trayicon module not found, please install it") return resp
def main(command_args): """Implements the logic of the 0desktop command. @param command_args: the command-line arguments""" parser = OptionParser(usage=_("usage: %prog [options] [URI]")) parser.add_option("-m", "--manage", help=_("manage added applications"), action='store_true') parser.add_option("-v", "--verbose", help=_("more verbose output"), action='count') parser.add_option("-V", "--version", help=_("display version information"), action='store_true') (options, args) = parser.parse_args(command_args) if options.verbose: if options.verbose == 1: logger.setLevel(logging.INFO) else: logger.setLevel(logging.DEBUG) hdlr = logging.StreamHandler() fmt = logging.Formatter("%(levelname)s:%(message)s") hdlr.setFormatter(fmt) logger.addHandler(hdlr) if options.version: import zeroinstall print("0desktop (zero-install) " + zeroinstall.version) print("Copyright (C) 2013 Thomas Leonard") print(_("This program comes with ABSOLUTELY NO WARRANTY," "\nto the extent permitted by law." "\nYou may redistribute copies of this program" "\nunder the terms of the GNU Lesser General Public License." "\nFor more information about these matters, see the file named COPYING.")) sys.exit(0) if not args: interface_uri = None elif len(args) == 1: interface_uri = args[0] else: parser.print_help() sys.exit(1) if sys.version_info[0] < 3: import pygtk pygtk.require('2.0') else: from zeroinstall.gtkui import pygtkcompat pygtkcompat.enable() pygtkcompat.enable_gtk(version = '3.0') import gtk if options.manage: from zeroinstall.gtkui.applistbox import AppListBox, AppList from zeroinstall.injector.iface_cache import iface_cache box = AppListBox(iface_cache, AppList()) else: from zeroinstall.gtkui.addbox import AddBox box = AddBox(interface_uri) box.window.connect('destroy', gtk.main_quit) box.window.show() gtk.main()
def clipboard(clip_text): import pygtk pygtk.require('2.0') import gtk clipboard = gtk.clipboard_get() text = clipboard.wait_for_text() clipboard.set_text(clip_text) clipboard.store()
def check_versions(): print("[gtk2.py] CEF Python {ver}".format(ver=cef.__version__)) print("[gtk2.py] Python {ver} {arch}".format( ver=platform.python_version(), arch=platform.architecture()[0])) print("[gtk2.py] GTK {ver}".format(ver='.'.join( map(str, list(gtk.gtk_version))))) assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this" pygtk.require('2.0')
def has_pygtk(): try: import pygtk pygtk.require('2.0') import gtk return True except: return False
def imports(): import pygtk pygtk.require('2.0') import gtk from xpcom import components from xpcom.server import WrapObject from xpcomponents import BrowserImpl import sys globals().update(locals())
def run_gui(args): parser = OptionParser(usage=_("usage: %prog [options] interface")) parser.add_option("", "--before", help=_("choose a version before this"), metavar='VERSION') parser.add_option("", "--cpu", help=_("target CPU type"), metavar='CPU') parser.add_option("", "--command", help=_("command to select"), metavar='COMMAND') parser.add_option("-d", "--download-only", help=_("fetch but don't run"), action='store_true') parser.add_option("-g", "--force-gui", help=_("display an error if there's no GUI"), action='store_true') parser.add_option("", "--message", help=_("message to display when interacting with user")) parser.add_option("", "--not-before", help=_("minimum version to choose"), metavar='VERSION') parser.add_option("", "--os", help=_("target operation system type"), metavar='OS') parser.add_option("-r", "--refresh", help=_("check for updates of all interfaces"), action='store_true') parser.add_option("", "--select-only", help=_("only download the feeds"), action='store_true') parser.add_option("-s", "--source", help=_("select source code"), action='store_true') parser.add_option("", "--systray", help=_("download in the background"), action='store_true') parser.add_option("-v", "--verbose", help=_("more verbose output"), action='count') parser.add_option("-V", "--version", help=_("display version information"), action='store_true') parser.add_option("", "--with-store", help=_("add an implementation cache"), action='append', metavar='DIR') parser.disable_interspersed_args() (options, args) = parser.parse_args(args) if options.verbose: logger = logging.getLogger() if options.verbose == 1: logger.setLevel(logging.INFO) else: logger.setLevel(logging.DEBUG) if options.version: import gui print("0launch-gui (zero-install) " + gui.version) print("Copyright (C) 2010 Thomas Leonard") print( _("This program comes with ABSOLUTELY NO WARRANTY," "\nto the extent permitted by law." "\nYou may redistribute copies of this program" "\nunder the terms of the GNU Lesser General Public License." "\nFor more information about these matters, see the file named COPYING." )) sys.exit(0) def nogui(ex): if options.force_gui: fn = logging.warn else: fn = logging.info fn("No GUI available", exc_info=ex) sys.exit(100) with warnings.catch_warnings(): if not options.force_gui: warnings.filterwarnings("ignore") if sys.version_info[0] < 3: try: import pygtk pygtk.require('2.0') except ImportError as ex: nogui(ex) import gui try: if sys.version_info[0] > 2: from zeroinstall.gtkui import pygtkcompat pygtkcompat.enable() pygtkcompat.enable_gtk(version='3.0') import gtk except (ImportError, ValueError) as ex: nogui(ex) if gtk.gdk.get_display() is None: try: raise SafeException("Failed to connect to display.") except SafeException as ex: nogui(ex) # logging needs this as a raised exception handler = gui.GUIHandler() config = load_config(handler) if options.with_store: from zeroinstall import zerostore for x in options.with_store: config.stores.stores.append(zerostore.Store(os.path.abspath(x))) if len(args) < 1: @tasks. async def prefs_main(): import preferences box = preferences.show_preferences(config) done = tasks.Blocker('close preferences') box.connect('destroy', lambda w: done.trigger()) yield done tasks.wait_for_blocker(prefs_main()) sys.exit(0) interface_uri = args[0] if len(args) > 1: parser.print_help() sys.exit(1) import mainwindow, dialog r = requirements.Requirements(interface_uri) r.parse_options(options) widgets = dialog.Template('main') driver = Driver(config=config, requirements=r) root_iface = config.iface_cache.get_interface(interface_uri) driver.solver.record_details = True window = mainwindow.MainWindow(driver, widgets, download_only=bool(options.download_only), select_only=bool(options.select_only)) handler.mainwindow = window if options.message: window.set_message(options.message) root = config.iface_cache.get_interface(r.interface_uri) window.browser.set_root(root) window.window.connect('destroy', lambda w: handler.abort_all_downloads()) if options.systray: window.use_systray_icon() @tasks. async def main(): force_refresh = bool(options.refresh) while True: window.refresh_button.set_sensitive(False) window.browser.set_update_icons(force_refresh) solved = driver.solve_with_downloads(force=force_refresh, update_local=True) if not window.systray_icon: window.show() yield solved try: window.refresh_button.set_sensitive(True) window.browser.highlight_problems() tasks.check(solved) except Exception as ex: window.report_exception(ex) if window.systray_icon and window.systray_icon.get_visible() and \ window.systray_icon.is_embedded(): if driver.solver.ready: window.systray_icon.set_tooltip( _('Downloading updates for %s') % root_iface.get_name()) window.run_button.set_active(True) else: # Should already be reporting an error, but # blink it again just in case window.systray_icon.set_blinking(True) refresh_clicked = dialog.ButtonClickedBlocker( window.refresh_button) yield refresh_clicked, _recalculate if refresh_clicked.happened: force_refresh = True tasks.wait_for_blocker(main())
PYGTKVERSION = "2.0" try: import pygtk pygtk.require(PYGTKVERSION) except: print "PyGTK version", PYGTKVERSION, "required." sys.exit(1) try: import gtk except: sys.exit(1) class AboutDialog: """ The about dialog from the main Help menu in the Menu Bar. """ name = 'images2cot' version = '1.2.3.4' copyright = 'Copyright (C) 2009, Geographic Information Network of Alaska,\ University of Alaska Fairbanks' comments = 'my comments' license = 'MIT License' website = 'http://gina.alaska.edu/' authors = [('Jonathan Sawyer')] documenters = [('Jonathan Sawyer')]
| gtkreactor.install() Then use twisted.internet APIs as usual. The other methods here are not intended to be called directly. API Stability: stable Maintainer: U{Itamar Shtull-Trauring<mailto:[email protected]>} """ __all__ = ['install'] # System Imports try: import pygtk pygtk.require('1.2') except ImportError, AttributeError: pass # maybe we're using pygtk before this hack existed. import gtk import sys, time from zope.interface import implements # Twisted Imports from twisted.python import log, threadable, runtime, failure, components from twisted.internet.interfaces import IReactorFDSet # Sibling Imports from twisted.internet import main, posixbase, selectreactor reads = {} writes = {}
# This program is free software; you can redistribute it and#or modify # # it under the terms of the GNU General Public License as published by # # the Free Software Foundation under version 2 of the license. # # # # This program is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this program; if not, write to the # # Free Software Foundation, Inc., # # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # ############################################################################ import pygtk; pygtk.require("2.0") import gtk import datastore from datastore import E_NAME, E_DATA, E_EDITABLE, E_PARENT, E_MODIFIED def get_dragdestdata(treeview, context, x, y, selection, info, etime): iter, value = cselected(treeview,x,y) model = treeview.get_model() if value == True: ldata = data print"global data=", data drop_info = treeview.get_dest_row_at_pos(x,y) print "DROP INFO IS:"; print drop_info if drop_info: path, position = drop_info iteri = model.get_iter(path)
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ''' import os, threading import errno import string import re import datetime from sys import stderr import pygtk; pygtk.require("2.0") # make sure we have the right version import gtk import grp import pwd, cPickle from gettext import gettext as _ from porthole.version import version from porthole._xml.xmlmgr import XMLManager, XMLManagerError from porthole import config from porthole.utils import debug def get_icon_for_package(package): """Return an icon for a package""" # if it's installed, find out if it can be upgraded if package and package.get_installed(): icon = gtk.STOCK_YES
# CDDL HEADER END # import threading import sys import os import time import getopt import locale import shutil import fcntl from bisect import insort try: import pygtk pygtk.require("2.4") except: pass try: import gtk import gtk.glade gtk.gdk.threads_init() except: sys.exit(1) try: import glib import gobject except: sys.exit(1) from os.path import abspath, dirname, join, pardir
--- dynagui.py.orig 2007-12-13 21:04:43 UTC +++ dynagui.py @@ -27,17 +27,17 @@ import sys import pygtk; pygtk.require('2.0') import gtk import gobject -from libs.canvas import MyCanvas -from libs import lab_io -from libs.lab import lab -from libs.gui_router import GuiRouter -from libs.dynamips_properties_dialog import DynamipsPropertiesDialog -from libs.C3600_properties_dialog import C3600PropertiesDialog -from libs.C7200_properties_dialog import C7200PropertiesDialog -from libs.frsw_properties_dialog import FRSwitchPropertiesDialog -from libs.atmsw_properties_dialog import ATMSwitchPropertiesDialog -from libs.ethsw_properties_dialog import EthSwitchPropertiesDialog -from libs.util import RouterSelectionDialog +from dynagui_libs.canvas import MyCanvas +from dynagui_libs import lab_io +from dynagui_libs.lab import lab +from dynagui_libs.gui_router import GuiRouter +from dynagui_libs.dynamips_properties_dialog import DynamipsPropertiesDialog +from dynagui_libs.C3600_properties_dialog import C3600PropertiesDialog +from dynagui_libs.C7200_properties_dialog import C7200PropertiesDialog +from dynagui_libs.frsw_properties_dialog import FRSwitchPropertiesDialog +from dynagui_libs.atmsw_properties_dialog import ATMSwitchPropertiesDialog +from dynagui_libs.ethsw_properties_dialog import EthSwitchPropertiesDialog +from dynagui_libs.util import RouterSelectionDialog ui_popup = \
def main(command_args): """Implements the logic of the 0desktop command. @param command_args: the command-line arguments""" parser = OptionParser(usage=_("usage: %prog [options] [URI]")) parser.add_option("-m", "--manage", help=_("manage added applications"), action='store_true') parser.add_option("-v", "--verbose", help=_("more verbose output"), action='count') parser.add_option("-V", "--version", help=_("display version information"), action='store_true') (options, args) = parser.parse_args(command_args) if options.verbose: logger = logging.getLogger() if options.verbose == 1: logger.setLevel(logging.INFO) else: logger.setLevel(logging.DEBUG) hdlr = logging.StreamHandler() fmt = logging.Formatter("%(levelname)s:%(message)s") hdlr.setFormatter(fmt) logger.addHandler(hdlr) if options.version: import zeroinstall print("0desktop (zero-install) " + zeroinstall.version) print("Copyright (C) 2009 Thomas Leonard") print( _("This program comes with ABSOLUTELY NO WARRANTY," "\nto the extent permitted by law." "\nYou may redistribute copies of this program" "\nunder the terms of the GNU Lesser General Public License." "\nFor more information about these matters, see the file named COPYING." )) sys.exit(0) if not args: interface_uri = None elif len(args) == 1: interface_uri = args[0] else: parser.print_help() sys.exit(1) import pygtk pygtk.require('2.0') import gtk if options.manage: from zeroinstall.gtkui.applistbox import AppListBox, AppList from zeroinstall.injector.iface_cache import iface_cache box = AppListBox(iface_cache, AppList()) else: from zeroinstall.gtkui.addbox import AddBox box = AddBox(interface_uri) box.window.connect('destroy', gtk.main_quit) box.window.show() gtk.main()
#!/usr/bin/env python ''' PyShot is a small light weight screenshot utility written in pygtk. Some features include zoom-in, zoom-out, delay setting Authors: Ikey Doherty <*****@*****.**>, Nick Canupp <*****@*****.**> Packaging: Kendall Weaver <*****@*****.**> License: GPL ''' try: import pygtk pygtk.require("2.0") except: print "You do not have the required PyGTK for this application." try: import gtk from time import sleep import threading except: print "You do not appear to have PyGTK installed" class Shotter: def __init__(self): self.ui_file = '/usr/lib/pyshot/interface.ui' self.ui = gtk.Builder() self.ui.add_from_file(self.ui_file) self.spinner = self.ui.get_object("spinbutton") adj = gtk.Adjustment() adj.set_upper(30) adj.set_lower(0)
modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. GNU Radio Companion is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA """ import pygtk pygtk.require('2.0') import gtk from Constants import MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT, DND_TARGETS class DrawingArea(gtk.DrawingArea): """ DrawingArea is the gtk pixel map that graphical elements may draw themselves on. The drawing area also responds to mouse and key events. """ def __init__(self, flow_graph): """ DrawingArea contructor. Connect event handlers. Args:
def __init__(self, diagram, data, props): import pygtk pygtk.require("2.0") import gtk self.diagram = diagram self.data = data self.props = props self.win = gtk.Window() self.win.connect("delete_event", self.on_delete) self.win.set_title("Group Properties") box1 = gtk.VBox() self.win.add(box1) box1.show() box2 = gtk.VBox(spacing=2) box2.set_border_width(10) box1.pack_start(box2) box2.show() self.checkboxes = [] self.optionmenues = [] if len(props): table = gtk.Table(2, len(props), 0) else: table = gtk.Table(2, 1, 0) table.set_row_spacings(2) table.set_col_spacings(5) table.set_border_width(5) if len(props): y = 0 for s in props.keys(): w = gtk.CheckButton(s) self.checkboxes.append(w) table.attach(w, 0, 1, y, y + 1) w.show() menu = gtk.Menu() milist = None for opt in props[s].opts: #print opt menuitem = gtk.RadioMenuItem(milist, str(opt.value)) milist = menuitem # GSlist menu.append(menuitem) menuitem.show() menu.show() w = gtk.OptionMenu() w.set_menu(menu) self.optionmenues.append(w) table.attach(w, 1, 2, y, y + 1) w.show() y = y + 1 else: w = gtk.Label( "The selected objects don't share any\n properties to change at once." ) table.attach(w, 0, 1, y, y + 1) w.show() box2.pack_start(table) table.show() separator = gtk.HSeparator() box1.pack_start(separator, expand=0) separator.show() box2 = gtk.VBox(spacing=10) box2.set_border_width(10) box1.pack_start(box2, expand=0) box2.show() button = gtk.Button("Ok") button.connect("clicked", self.on_ok) box2.pack_start(button) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() button.show() self.win.show()