def check_required_version(modulename): """ Checks if the installed module is the required version or more recent. Returns [None, None] if it's recent enough, else will return a list containing the strings of the required version and the installed version. This function does not check for the existence of the given module ! """ if modulename == "gtk": if list(gtk.pygtk_version) < _string_to_list(PYGTK_REQ): return [PYGTK_REQ, _version_to_string(gtk.pygtk_version)] if modulename == "pygst": if list(gst.get_pygst_version()) < _string_to_list(PYGST_REQ): return [PYGST_REQ, _version_to_string(gst.get_pygst_version())] if modulename == "cairo": import cairo if _string_to_list(cairo.cairo_version_string()) < _string_to_list(PYCAIRO_REQ): return [PYCAIRO_REQ, cairo.cairo_version_string()] if modulename == "gst": if list(gst.get_gst_version()) < _string_to_list(GST_REQ): return [GST_REQ, _version_to_string(gst.get_gst_version())] if modulename == "gnonlin": gnlver = gst.registry_get_default().find_plugin("gnonlin").get_version() if _string_to_list(gnlver) < _string_to_list(GNONLIN_REQ): return [GNONLIN_REQ, gnlver] return [None, None]
def check_required_version(modulename): """ Checks if the installed module is the required version or more recent. Returns [None, None] if it's recent enough, else will return a list containing the strings of the required version and the installed version. This function does not check for the existence of the given module ! """ if modulename == "gtk": if list(gtk.pygtk_version) < _string_to_list(PYGTK_REQ): return [PYGTK_REQ, _version_to_string(gtk.pygtk_version)] if modulename == "pygst": if list(gst.get_pygst_version()) < _string_to_list(PYGST_REQ): return [PYGST_REQ, _version_to_string(gst.get_pygst_version())] if modulename == "cairo": import cairo if _string_to_list( cairo.cairo_version_string()) < _string_to_list(PYCAIRO_REQ): return [PYCAIRO_REQ, cairo.cairo_version_string()] if modulename == "gst": if list(gst.get_gst_version()) < _string_to_list(GST_REQ): return [GST_REQ, _version_to_string(gst.get_gst_version())] if modulename == "gnonlin": gnlver = gst.registry_get_default().find_plugin( "gnonlin").get_version() if _string_to_list(gnlver) < _string_to_list(GNONLIN_REQ): return [GNONLIN_REQ, gnlver] return [None, None]
def test_version(): cairo.cairo_version() cairo.cairo_version_string() assert cairo.CAIRO_VERSION == cairo.cairo_version() assert cairo.CAIRO_VERSION_STRING == cairo.cairo_version_string() ver_tuple = (cairo.CAIRO_VERSION_MAJOR, cairo.CAIRO_VERSION_MINOR, cairo.CAIRO_VERSION_MICRO) assert tuple(map(int, cairo.CAIRO_VERSION_STRING.split("."))) == \ ver_tuple
def _check_required_deps(): try: import nbxmpp except ImportError: print('Gajim needs python-nbxmpp to run. Quitting…') sys.exit(1) if V(nbxmpp.__version__) < V(_MIN_NBXMPP_VER): print('Gajim needs python-nbxmpp >= %s to run. ' 'Quitting...' % _MIN_NBXMPP_VER) sys.exit(1) try: import cairo except ImportError: print('Gajim needs python-cairo to run. Quitting…') sys.exit(1) if V(cairo.cairo_version_string()) < V(_MIN_CAIRO_VER): print('Gajim needs libcairo >= %s to run. ' 'Quitting...' % _MIN_CAIRO_VER) sys.exit(1) if V(cairo.version) < V(_MIN_CAIRO_VER): print('Gajim needs python-cairo >= %s to run. ' 'Quitting...' % _MIN_CAIRO_VER) sys.exit(1)
def get_libs_version_string(): """Get a string describing the versions of important libs. >>> type(get_libs_version_string()) == str True """ versions = [ ("Python", "{major}.{minor}.{micro}".format( major = sys.version_info.major, minor = sys.version_info.minor, micro = sys.version_info.micro, )), ("GTK", "{major}.{minor}.{micro}".format( major = Gtk.get_major_version(), minor = Gtk.get_minor_version(), micro = Gtk.get_micro_version(), )), ("GdkPixbuf", GdkPixbuf.PIXBUF_VERSION), ("Cairo", cairo.cairo_version_string()), # NOT cairo.version ("GLib", "{major}.{minor}.{micro}".format( major = GLib.MAJOR_VERSION, minor = GLib.MINOR_VERSION, micro = GLib.MICRO_VERSION, )), ] return ", ".join([" ".join(t) for t in versions])
def get_libs_version_string(): """Get a string describing the versions of important libs. >>> type(get_libs_version_string()) == str True """ versions = [ ("Python", "{major}.{minor}.{micro}".format( major=sys.version_info.major, minor=sys.version_info.minor, micro=sys.version_info.micro, )), ("GTK", "{major}.{minor}.{micro}".format( major=Gtk.get_major_version(), minor=Gtk.get_minor_version(), micro=Gtk.get_micro_version(), )), ("GdkPixbuf", GdkPixbuf.PIXBUF_VERSION), ("Cairo", cairo.cairo_version_string()), # NOT cairo.version ("GLib", "{major}.{minor}.{micro}".format( major=GLib.MAJOR_VERSION, minor=GLib.MINOR_VERSION, micro=GLib.MICRO_VERSION, )), ] return ", ".join([" ".join(t) for t in versions])
def get_summary(): summary = "Sanaviron version: %s (%s)\n" % (VERSION, 'Testing' if "--testing" in sys.argv else 'Production') summary += "System: %s %s %s\n" % (platform.system(), platform.release(), platform.version()) summary += "Python version: %s\n" % platform.python_version() summary += "GTK version: %s.%s.%s\n" % (Gtk.MAJOR_VERSION, Gtk.MINOR_VERSION, Gtk.MICRO_VERSION) summary += "Cairo version: %s" % cairo.cairo_version_string() return summary
def check_pycairo(): PYCAIRO_INSTALLED = None try: import cairo PYCAIRO_INSTALLED = cairo.cairo_version_string() except ImportError: pass finally: dependency_check("PyCairo", PYCAIRO_REQUIRED, PYCAIRO_INSTALLED)
def get_summary(): summary = "Sanaviron version: %s (%s)\n" % ( VERSION, 'Testing' if "--testing" in sys.argv else 'Production') summary += "System: %s %s %s\n" % (platform.system(), platform.release(), platform.version()) summary += "Python version: %s\n" % platform.python_version() summary += "GTK version: %s\n" % '.'.join(map(str, gtk.ver)) summary += "Cairo version: %s" % cairo.cairo_version_string() return summary
def main(argv=sys.argv[1:]): """ Entry point of pympress. Parse command line arguments, instantiate the UI, and start the main loop. """ signal.signal(signal.SIGINT, signal.SIG_DFL) # prefere X11 on posix systems because Wayland still has some shortcomings for us, # specifically libVLC and the ability to disable screensavers if util.IS_POSIX: Gdk.set_allowed_backends('x11,*') Gtk.init(argv) pympress_meta = util.get_pympress_meta()['version'] logger.info(' '.join([ 'Pympress:', pympress_meta, '; Python:', platform.python_version(), '; OS:', platform.system(), platform.release(), platform.version(), '; Gtk {}.{}.{}'.format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), '; GLib {}.{}.{}'.format(GLib.MAJOR_VERSION, GLib.MINOR_VERSION, GLib.MICRO_VERSION), '; Poppler', document.Poppler.get_version(), document.Poppler.get_backend().value_nick, '; Cairo', cairo.cairo_version_string(), ', pycairo', cairo.version, '; Media:', extras.Media.backend_version() ])) try: opts, args = getopt.getopt(argv, "hn:t:", ["help", "notes=", "talk-time=", "log="]) opts = dict(opts) except getopt.GetoptError: usage() sys.exit(2) ett, log_level, notes_pos = parse_opts(opts) logger.setLevel(log_level) # Create windows gui = ui.UI() # Connect proper exit function to interrupt signal.signal(signal.SIGINT, gui.save_and_quit) # pass command line args if ett: gui.est_time.set_time(ett) gui.swap_document(os.path.abspath(args[0])) if args else gui.pick_file() if notes_pos is not None: gui.change_notes_pos(notes_pos, force_change=True) gui.run()
def _check_required_deps(): error_message = 'Gajim needs %s to run. Quitting… (Error: %s)' try: import nbxmpp except ImportError as error: sys.exit(error_message % ('python-nbxmpp', error)) try: import gi except ImportError as error: sys.exit(error_message % ('pygobject', error)) try: gi.require_versions({ 'GLib': '2.0', 'Gio': '2.0', 'Gtk': '3.0', 'GObject': '2.0', 'Pango': '1.0', 'Soup': '2.4' }) except ValueError as error: sys.exit('Missing dependency: %s' % error) try: import cairo except ImportError as error: sys.exit(error_message % ('python-cairo', error)) from gi.repository import Gtk gtk_ver = '%s.%s.%s' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) from gi.repository import GLib glib_ver = '.'.join( map(str, [GLib.MAJOR_VERSION, GLib.MINOR_VERSION, GLib.MICRO_VERSION])) check_version('python-nbxmpp', nbxmpp.__version__, _MIN_NBXMPP_VER) check_version('pygobject', gi.__version__, _MIN_PYGOBJECT_VER) check_version('libcairo', cairo.cairo_version_string(), _MIN_CAIRO_VER) check_version('python-cairo', cairo.version, _MIN_CAIRO_VER) check_version('gtk3', gtk_ver, _MIN_GTK_VER) check_version('glib', glib_ver, _MIN_GLIB_VER)
def test_typing(): mod = types.ModuleType("cairo") stub = os.path.join(cairo.__path__[0], "__init__.pyi") with io.open(stub, "r", encoding="utf-8") as h: code = compile(h.read(), stub, "exec") exec(code, mod.__dict__) def collect_names(t): names = set() for key, value in vars(t).items(): if key in [ "XlibSurface", "XCBSurface", "Win32PrintingSurface", "Win32Surface" ]: continue if key.startswith("_"): continue if key.startswith("__") and key.endswith("__"): continue if getattr(value, "__module__", "") == "typing" or key == "Text": continue if isinstance(value, type): names.add(key) for k, v in vars(value).items(): name = key + "." + k if k.startswith("_"): continue names.add(name) else: names.add(key) return names # We expose all potential API in the typing stubs, so only check # if it exactly matches the Python module with a new enough cairo cairo_version = tuple(map(int, cairo.cairo_version_string().split("."))) if cairo_version >= (1, 16, 0): assert collect_names(cairo) == collect_names(mod) else: assert collect_names(cairo) <= collect_names(mod)
def show_settings(): """ Shows settings of all of the major components. """ py_str = '%d.%d.%d' % sys.version_info[:3] try: import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk try: gtkver_str = '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) except: # any failure to 'get' the version gtkver_str = 'unknown version' except ImportError: gtkver_str = 'not found' # no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14) except RuntimeError: gtkver_str = 'DISPLAY not set' # exept TypeError: To handle back formatting on version split try: from gi.repository import GObject try: pygobjectver_str = '%d.%d.%d' % GObject.pygobject_version except: # any failure to 'get' the version pygobjectver_str = 'unknown version' except ImportError: pygobjectver_str = 'not found' try: from gi.repository import Pango try: pangover_str = Pango.version_string() except: # any failure to 'get' the version pangover_str = 'unknown version' except ImportError: pangover_str = 'not found' try: import cairo try: pycairover_str = '%d.%d.%d' % cairo.version_info cairover_str = cairo.cairo_version_string() except: # any failure to 'get' the version pycairover_str = 'unknown version' cairover_str = 'unknown version' except ImportError: pycairover_str = 'not found' cairover_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("OsmGpsMap"): import gi gi.require_version('OsmGpsMap', '1.0') from gi.repository import OsmGpsMap as osmgpsmap try: osmgpsmap_str = osmgpsmap._version except: # any failure to 'get' the version osmgpsmap_str = 'unknown version' else: osmgpsmap_str = 'not found' except ImportError: osmgpsmap_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("GExiv2"): import gi gi.require_version('GExiv2', '0.10') from gi.repository import GExiv2 try: gexiv2_str = GExiv2._version except: # any failure to 'get' the version gexiv2_str = 'unknown version' else: gexiv2_str = 'not found' except ImportError: gexiv2_str = 'not found' except ValueError: gexiv2_str = 'not new enough' try: import PyICU try: pyicu_str = PyICU.VERSION icu_str = PyICU.ICU_VERSION except: # any failure to 'get' the version pyicu_str = 'unknown version' icu_str = 'unknown version' except ImportError: pyicu_str = 'not found' icu_str = 'not found' try: import bsddb3 as bsddb bsddb_str = bsddb.__version__ bsddb_db_str = str(bsddb.db.version()).replace(', ', '.')\ .replace('(', '').replace(')', '') bsddb_location_str = bsddb.__file__ except: bsddb_str = 'not found' bsddb_db_str = 'not found' bsddb_location_str = 'not found' try: import sqlite3 sqlite3_py_version_str = sqlite3.version sqlite3_version_str = sqlite3.sqlite_version sqlite3_location_str = sqlite3.__file__ except: sqlite3_version_str = 'not found' sqlite3_py_version_str = 'not found' sqlite3_location_str = 'not found' try: from .gen.const import VERSION gramps_str = VERSION except: gramps_str = 'not found' if hasattr(os, "uname"): kernel = os.uname()[2] else: kernel = None lang_str = get_env_var('LANG', 'not set') language_str = get_env_var('LANGUAGE', 'not set') grampsi18n_str = get_env_var('GRAMPSI18N', 'not set') grampshome_str = get_env_var('GRAMPSHOME', 'not set') grampsdir_str = get_env_var('GRAMPSDIR', 'not set') gramps_resources_str = get_env_var('GRAMPS_RESOURCES', 'not set') try: dotversion_str = Popen(['dot', '-V'], stderr=PIPE).communicate(input=None)[1] if isinstance(dotversion_str, bytes) and sys.stdin.encoding: dotversion_str = dotversion_str.decode(sys.stdin.encoding) if dotversion_str: dotversion_str = dotversion_str.replace('\n', '')[23:27] except: dotversion_str = 'Graphviz not in system PATH' try: if win(): try: gsversion_str = Popen(['gswin32c', '--version'], stdout=PIPE).communicate(input=None)[0] except: gsversion_str = Popen(['gswin64c', '--version'], stdout=PIPE).communicate(input=None)[0] else: gsversion_str = Popen(['gs', '--version'], stdout=PIPE).communicate(input=None)[0] if isinstance(gsversion_str, bytes) and sys.stdin.encoding: gsversion_str = gsversion_str.decode(sys.stdin.encoding) if gsversion_str: gsversion_str = gsversion_str.replace('\n', '') except: gsversion_str = 'Ghostscript not in system PATH' os_path = get_env_var('PATH', 'not set') os_path = os_path.split(os.pathsep) print("Gramps Settings:") print("----------------") print(' python : %s' % py_str) print(' gramps : %s' % gramps_str) print(' gtk++ : %s' % gtkver_str) print(' pygobject : %s' % pygobjectver_str) print(' pango : %s' % pangover_str) print(' cairo : %s' % cairover_str) print(' pycairo : %s' % pycairover_str) print(' osmgpsmap : %s' % osmgpsmap_str) print(' GExiv2 : %s' % gexiv2_str) print(' ICU : %s' % icu_str) print(' PyICU : %s' % pyicu_str) print(' o.s. : %s' % sys.platform) if kernel: print(' kernel : %s' % kernel) print('') print("Environment settings:") print("---------------------") print(' LANG : %s' % lang_str) print(' LANGUAGE : %s' % language_str) print(' GRAMPSI18N: %s' % grampsi18n_str) print(' GRAMPSHOME: %s' % grampshome_str) print(' GRAMPSDIR : %s' % grampsdir_str) if __debug__: print(' GRAMPS_RESOURCES : %s' % gramps_resources_str) print(' PYTHONPATH:') for folder in sys.path: print(" ", folder) print('') print("Non-python dependencies:") print("------------------------") print(' Graphviz : %s' % dotversion_str) print(' Ghostscr. : %s' % gsversion_str) print('') print("System PATH env variable:") print("-------------------------") for folder in os_path: print(" ", folder) print('') print("Databases:") print("-------------------------") print(' bsddb :') print(' version : %s' % bsddb_str) print(' db version : %s' % bsddb_db_str) print(' location : %s' % bsddb_location_str) print(' sqlite3 :') print(' version : %s' % sqlite3_version_str) print(' py version : %s' % sqlite3_py_version_str) print(' location : %s' % sqlite3_location_str) print('')
def cairo_ver(): return tuple(map(int, cairo.cairo_version_string().split(".")))
def show_settings(): """ Shows settings of all of the major components. """ py_str = '%d.%d.%d' % sys.version_info[:3] try: from gi.repository import Gtk try: gtkver_str = '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) except : # any failure to 'get' the version gtkver_str = 'unknown version' except ImportError: gtkver_str = 'not found' # no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14) except RuntimeError: gtkver_str = 'DISPLAY not set' #exept TypeError: To handle back formatting on version split try: from gi.repository import GObject try: pygobjectver_str = '%d.%d.%d' % GObject.pygobject_version except :# any failure to 'get' the version pygobjectver_str = 'unknown version' except ImportError: pygobjectver_str = 'not found' try: from gi.repository import Pango try: pangover_str = Pango.version_string() except :# any failure to 'get' the version pangover_str = 'unknown version' except ImportError: pangover_str = 'not found' try: import cairo try: pycairover_str = '%d.%d.%d' % cairo.version_info cairover_str = cairo.cairo_version_string() except :# any failure to 'get' the version pycairover_str = 'unknown version' cairover_str = 'unknown version' except ImportError: pycairover_str = 'not found' cairover_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("OsmGpsMap"): from gi.repository import OsmGpsMap as osmgpsmap try: osmgpsmap_str = osmgpsmap._version except :# any failure to 'get' the version osmgpsmap_str = 'unknown version' else: osmgpsmap_str = 'not found' except ImportError: osmgpsmap_str = 'not found' try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("GExiv2"): from gi.repository import GExiv2 try: gexiv2_str = GExiv2._version except: # any failure to 'get' the version gexiv2_str = 'unknown version' else: gexiv2_str = 'not found' except ImportError: gexiv2_str = 'not found' try: import PyICU try: pyicu_str = PyICU.VERSION icu_str = PyICU.ICU_VERSION except: # any failure to 'get' the version pyicu_str = 'unknown version' icu_str = 'unknown version' except ImportError: pyicu_str = 'not found' icu_str = 'not found' try: import bsddb3 as bsddb bsddb_str = bsddb.__version__ bsddb_db_str = str(bsddb.db.version()).replace(', ', '.')\ .replace('(', '').replace(')', '') except: bsddb_str = 'not found' bsddb_db_str = 'not found' try: from .gen.const import VERSION gramps_str = VERSION except: gramps_str = 'not found' if hasattr(os, "uname"): kernel = os.uname()[2] else: kernel = None lang_str = get_env_var('LANG','not set') language_str = get_env_var('LANGUAGE','not set') grampsi18n_str = get_env_var('GRAMPSI18N','not set') grampshome_str = get_env_var('GRAMPSHOME','not set') grampsdir_str = get_env_var('GRAMPSDIR','not set') try: dotversion_str = Popen(['dot', '-V'], stderr=PIPE).communicate(input=None)[1] if isinstance(dotversion_str, bytes) and sys.stdin.encoding: dotversion_str = dotversion_str.decode(sys.stdin.encoding) if dotversion_str: dotversion_str = dotversion_str.replace('\n','')[23:27] except: dotversion_str = 'Graphviz not in system PATH' try: if win(): gsversion_str = Popen(['gswin32c', '--version'], stdout=PIPE).communicate(input=None)[0] else: gsversion_str = Popen(['gs', '--version'], stdout=PIPE).communicate(input=None)[0] if isinstance(gsversion_str, bytes) and sys.stdin.encoding: gsversion_str = gsversion_str.decode(sys.stdin.encoding) if gsversion_str: gsversion_str = gsversion_str.replace('\n', '') except: gsversion_str = 'Ghostscript not in system PATH' os_path = get_env_var('PATH','not set') os_path = os_path.split(os.pathsep) print ("Gramps Settings:") print ("----------------") print (' python : %s' % py_str) print (' gramps : %s' % gramps_str) print (' gtk++ : %s' % gtkver_str) print (' pygobject : %s' % pygobjectver_str) print (' pango : %s' % pangover_str) print (' bsddb : %s' % bsddb_str) print (' bsddb.db : %s' % bsddb_db_str) print (' cairo : %s' % cairover_str) print (' pycairo : %s' % pycairover_str) print (' osmgpsmap : %s' % osmgpsmap_str) print (' GExiv2 : %s' % gexiv2_str) print (' ICU : %s' % icu_str) print (' PyICU : %s' % pyicu_str) print (' o.s. : %s' % sys.platform) if kernel: print (' kernel : %s' % kernel) print ('') print ("Environment settings:") print ("---------------------") print (' LANG : %s' % lang_str) print (' LANGUAGE : %s' % language_str) print (' GRAMPSI18N: %s' % grampsi18n_str) print (' GRAMPSHOME: %s' % grampshome_str) print (' GRAMPSDIR : %s' % grampsdir_str) print (' PYTHONPATH:') for folder in sys.path: print (" ", folder) print ('') print ("Non-python dependencies:") print ("------------------------") print (' Graphviz : %s' % dotversion_str) print (' Ghostscr. : %s' % gsversion_str) print ('') print ("System PATH env variable:") print ("-------------------------") for folder in os_path: print (" ", folder) print ('')
op_set('lat_max', lat, operator.lt) op_set('lng_max', lng, operator.lt) lat_min, lng_min, lat_max, lng_max = 115.44237, 39.12191, 117.36474, 40.91122 print 'all', lat_min, lng_min, lat_max, lng_max # 所有公交覆盖的面积 w = distance((lat_min, lng_min), (lng_max, lng_max)) h = distance((lat_min, lng_min), (lat_min, lng_max)) # 8298384.21147, 106369.665212 # = 882696.350377 平方公里 import cairo print 'version', cairo.cairo_version_string() WIDTH, HEIGHT = 32000/10, 32000/10 print 'WIDTH, HEIGHT=', WIDTH, HEIGHT surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, WIDTH, HEIGHT) ctx = cairo.Context(surface) ctx.set_source_rgb (1, 1, 1) ctx.set_operator (cairo.OPERATOR_SOURCE) ctx.paint() faraway_min = lat_min + (lat_max-lat_min)*7/20, lng_min + (lng_max-lng_min)*7/20 faraway_max = lat_max - (lat_max-lat_min)*8/20, lng_max - (lng_max-lng_min)*8/20 print 'faraway', faraway_min, faraway_max
def test_version(): cairo.cairo_version() cairo.cairo_version_string()
def get_version(): cairo_ver = cairo.cairo_version_string() pycairo_ver = '' for item in cairo.version_info: pycairo_ver += str(item) + '.' return (cairo_ver, pycairo_ver[:-1])
def get_version(): v0, v1, v2 = cairo.version_info return (cairo.cairo_version_string(), '%d.%d.%d' % (v0, v1, v2))
def show_settings(): """ Shows settings of all of the major components. """ py_str = '%d.%d.%d' % sys.version_info[:3] try: from gi.repository import Gtk try: gtkver_str = '%d.%d.%d' % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) except : # any failure to 'get' the version gtkver_str = 'unknown version' except ImportError: gtkver_str = 'not found' # no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14) except RuntimeError: gtkver_str = 'DISPLAY not set' #exept TypeError: To handle back formatting on version split try: from gi.repository import GObject try: pygobjectver_str = '%d.%d.%d' % GObject.pygobject_version except :# any failure to 'get' the version pygobjectver_str = 'unknown version' except ImportError: pygobjectver_str = 'not found' try: from gi.repository import Pango try: pangover_str = Pango.version_string() except :# any failure to 'get' the version pangover_str = 'unknown version' except ImportError: pangover_str = 'not found' try: import cairo try: pycairover_str = '%d.%d.%d' % cairo.version_info cairover_str = cairo.cairo_version_string() except :# any failure to 'get' the version pycairover_str = 'unknown version' cairover_str = 'unknown version' except ImportError: pycairover_str = 'not found' cairover_str = 'not found' # # try: # import PyICU # try: # pyicu_str = PyICU.VERSION # icu_str = PyICU.ICU_VERSION # except: # any failure to 'get' the version # pyicu_str = 'unknown version' # icu_str = 'unknown version' # # except ImportError: # pyicu_str = 'not found' # icu_str = 'not found' try: from .gen.const import VERSION wearnow_str = VERSION except: wearnow_str = 'not found' if hasattr(os, "uname"): kernel = os.uname()[2] else: kernel = None lang_str = get_env_var('LANG','not set') language_str = get_env_var('LANGUAGE','not set') wearnowi18n_str = get_env_var('WEARNOWI18N','not set') wearnowhome_str = get_env_var('WEARNOWHOME','not set') wearnowdir_str = get_env_var('WEARNOWDIR','not set') os_path = get_env_var('PATH','not set') os_path = os_path.split(os.pathsep) print ("ComfiSense Settings:") print ("----------------") print (' python : %s' % py_str) print (' wearnow : %s' % wearnow_str) print (' gtk++ : %s' % gtkver_str) print (' pygobject : %s' % pygobjectver_str) print (' pango : %s' % pangover_str) print (' cairo : %s' % cairover_str) print (' pycairo : %s' % pycairover_str) print (' o.s. : %s' % sys.platform) if kernel: print (' kernel : %s' % kernel) print ('') print ("Environment settings:") print ("---------------------") print (' LANG : %s' % lang_str) print (' LANGUAGE : %s' % language_str) print (' WEARNOWI18N: %s' % wearnowi18n_str) print (' WEARNOWHOME: %s' % wearnowhome_str) print (' WEARNOWDIR : %s' % wearnowdir_str) print (' PYTHONPATH:') for folder in sys.path: print (" ", folder) print ('') print ("Non-python dependencies:") print ("------------------------") print (' Not Present ') print ('') print ("System PATH env variable:") print ("-------------------------") for folder in os_path: print (" ", folder) print ('')
import cairo print("Cairo Version " + cairo.cairo_version_string()) test_surface = cairo.ImageSurface(cairo.FORMAT_A1, 512, 512) test_context = cairo.Context(test_surface) test_context.scale(256, 256) test_context.set_line_width(0.007) # linear_bezier # draws a striaght line between two points, p0 and p0 # t is not strictly necessary here, but the orignal # bezier function produces a point in space, ranging 0 <= t <= 1 def linear_bezier(p0x, p0y, p1x, p1y, t): test_context.move_to(p0x, p0y) tx = t * (p1x - p0x) ty = t * (p1y - p0y) test_context.line_to(tx, ty) test_context.stroke() test_surface.write_to_png("line.png") # quadratic_bezier # draws a series of points which are interpolations between p0 and p2, from p1, the control node # p0 x,y values are the start # p2 x,y values are the end # the control point is p1, x,y # t is default zero, to run through the entire curve process
def show_settings(): """ Shows settings of all of the major components. """ py_str = "%d.%d.%d" % sys.version_info[:3] try: import gi gi.require_version("Gtk", "3.0") from gi.repository import Gtk try: gtkver_str = "%d.%d.%d" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()) except: # any failure to 'get' the version gtkver_str = "unknown version" except ImportError: gtkver_str = "not found" # no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14) except RuntimeError: gtkver_str = "DISPLAY not set" # exept TypeError: To handle back formatting on version split try: from gi.repository import GObject try: pygobjectver_str = "%d.%d.%d" % GObject.pygobject_version except: # any failure to 'get' the version pygobjectver_str = "unknown version" except ImportError: pygobjectver_str = "not found" try: from gi.repository import Pango try: pangover_str = Pango.version_string() except: # any failure to 'get' the version pangover_str = "unknown version" except ImportError: pangover_str = "not found" try: import cairo try: pycairover_str = "%d.%d.%d" % cairo.version_info cairover_str = cairo.cairo_version_string() except: # any failure to 'get' the version pycairover_str = "unknown version" cairover_str = "unknown version" except ImportError: pycairover_str = "not found" cairover_str = "not found" try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("OsmGpsMap"): import gi gi.require_version("OsmGpsMap", "1.0") from gi.repository import OsmGpsMap as osmgpsmap try: osmgpsmap_str = osmgpsmap._version except: # any failure to 'get' the version osmgpsmap_str = "unknown version" else: osmgpsmap_str = "not found" except ImportError: osmgpsmap_str = "not found" try: from gi import Repository repository = Repository.get_default() if repository.enumerate_versions("GExiv2"): import gi gi.require_version("GExiv2", "0.10") from gi.repository import GExiv2 try: gexiv2_str = GExiv2._version except: # any failure to 'get' the version gexiv2_str = "unknown version" else: gexiv2_str = "not found" except ImportError: gexiv2_str = "not found" except ValueError: gexiv2_str = "not new enough" try: import PyICU try: pyicu_str = PyICU.VERSION icu_str = PyICU.ICU_VERSION except: # any failure to 'get' the version pyicu_str = "unknown version" icu_str = "unknown version" except ImportError: pyicu_str = "not found" icu_str = "not found" try: import bsddb3 as bsddb bsddb_str = bsddb.__version__ bsddb_db_str = str(bsddb.db.version()).replace(", ", ".").replace("(", "").replace(")", "") bsddb_location_str = bsddb.__file__ except: bsddb_str = "not found" bsddb_db_str = "not found" bsddb_location_str = "not found" try: import sqlite3 sqlite3_py_version_str = sqlite3.version sqlite3_version_str = sqlite3.sqlite_version sqlite3_location_str = sqlite3.__file__ except: sqlite3_version_str = "not found" sqlite3_py_version_str = "not found" sqlite3_location_str = "not found" try: from .gen.const import VERSION gramps_str = VERSION except: gramps_str = "not found" if hasattr(os, "uname"): kernel = os.uname()[2] else: kernel = None lang_str = get_env_var("LANG", "not set") language_str = get_env_var("LANGUAGE", "not set") grampsi18n_str = get_env_var("GRAMPSI18N", "not set") grampshome_str = get_env_var("GRAMPSHOME", "not set") grampsdir_str = get_env_var("GRAMPSDIR", "not set") gramps_resources_str = get_env_var("GRAMPS_RESOURCES", "not set") try: dotversion_str = Popen(["dot", "-V"], stderr=PIPE).communicate(input=None)[1] if isinstance(dotversion_str, bytes) and sys.stdin.encoding: dotversion_str = dotversion_str.decode(sys.stdin.encoding) if dotversion_str: dotversion_str = dotversion_str.replace("\n", "")[23:27] except: dotversion_str = "Graphviz not in system PATH" try: if win(): try: gsversion_str = Popen(["gswin32c", "--version"], stdout=PIPE).communicate(input=None)[0] except: gsversion_str = Popen(["gswin64c", "--version"], stdout=PIPE).communicate(input=None)[0] else: gsversion_str = Popen(["gs", "--version"], stdout=PIPE).communicate(input=None)[0] if isinstance(gsversion_str, bytes) and sys.stdin.encoding: gsversion_str = gsversion_str.decode(sys.stdin.encoding) if gsversion_str: gsversion_str = gsversion_str.replace("\n", "") except: gsversion_str = "Ghostscript not in system PATH" os_path = get_env_var("PATH", "not set") os_path = os_path.split(os.pathsep) print("Gramps Settings:") print("----------------") print(" python : %s" % py_str) print(" gramps : %s" % gramps_str) print(" gtk++ : %s" % gtkver_str) print(" pygobject : %s" % pygobjectver_str) print(" pango : %s" % pangover_str) print(" cairo : %s" % cairover_str) print(" pycairo : %s" % pycairover_str) print(" osmgpsmap : %s" % osmgpsmap_str) print(" GExiv2 : %s" % gexiv2_str) print(" ICU : %s" % icu_str) print(" PyICU : %s" % pyicu_str) print(" o.s. : %s" % sys.platform) if kernel: print(" kernel : %s" % kernel) print("") print("Environment settings:") print("---------------------") print(" LANG : %s" % lang_str) print(" LANGUAGE : %s" % language_str) print(" GRAMPSI18N: %s" % grampsi18n_str) print(" GRAMPSHOME: %s" % grampshome_str) print(" GRAMPSDIR : %s" % grampsdir_str) if __debug__: print(" GRAMPS_RESOURCES : %s" % gramps_resources_str) print(" PYTHONPATH:") for folder in sys.path: print(" ", folder) print("") print("Non-python dependencies:") print("------------------------") print(" Graphviz : %s" % dotversion_str) print(" Ghostscr. : %s" % gsversion_str) print("") print("System PATH env variable:") print("-------------------------") for folder in os_path: print(" ", folder) print("") print("Databases:") print("-------------------------") print(" bsddb :") print(" version : %s" % bsddb_str) print(" db version : %s" % bsddb_db_str) print(" location : %s" % bsddb_location_str) print(" sqlite3 :") print(" version : %s" % sqlite3_version_str) print(" py version : %s" % sqlite3_py_version_str) print(" location : %s" % sqlite3_location_str) print("")
def __init__(self): Gtk.EventBox.__init__(self) self.set_visible_window(False) self.connect('draw', self.on_draw) print 'Cairo' , cairo.cairo_version_string()
with open(d["filepath"]) as f: code = f.read() if "# BEGIN" in code and "# END" in code: # TODO: use regex, allow several chunks code = code.split("# BEGIN")[1].lstrip("\n").split("# END")[0].rstrip() s += '<td>\n' s += "<code><b>/%s</b></code>\n" % d["filename_with_parent_dir"] hightlighted_code = highlight(code, PythonLexer(), HtmlFormatter()) s += "%s\n" % hightlighted_code s += "</td>\n" s += "</tr>\n" s += "</table>\n" with open("template.html", "r") as f: template = f.read() d = {"pycairo_version": cairo.cairo_version_string(), "content": s, "date": strftime("%Y-%m-%d %H:%M:%S")} html = template.format(**d) with open("index.html", "w") as f: f.write(html)
class Pympress(Gtk.Application): """ Class representing the single pympress Gtk application. """ #: The :class:`~pympress.ui.UI` object that is the interface of pympress gui = None #: The :class:`~pympress.config.Config` object that holds pympress conferences config = None #: `list` of actions to be passsed to the GUI that were queued before GUI was created action_startup_queue = [] #: `bool` to automatically upgrade log level (DEBUG / INFO at init, then ERROR), False if user set log level auto_log_level = True options = { # long_name: (short_name (int), flags (GLib.OptionFlags), arg (GLib.OptionArg) 'talk-time': (ord('t'), GLib.OptionFlags.NONE, GLib.OptionArg.STRING), 'notes': (ord('N'), GLib.OptionFlags.NONE, GLib.OptionArg.STRING), 'log': (0, GLib.OptionFlags.NONE, GLib.OptionArg.STRING), 'version': (ord('v'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'pause': (ord('P'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'reset': (ord('r'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'next': (ord('n'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'prev': (ord('p'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'first': (ord('f'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'last': (ord('l'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'blank': (ord('b'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), 'quit': (ord('q'), GLib.OptionFlags.NONE, GLib.OptionArg.NONE), } option_descriptions = { # long_name: (description, arg_description) 'talk-time': (_('The estimated (intended) talk time in minutes') + ' ' + _('(and optionally seconds)'), 'mm[:ss]'), 'notes': (_('Set the position of notes on the pdf page') + ' ' + _('(none, left, right, top, bottom, or after).') + ' ' + _('Overrides the detection from the file.'), '<position>'), 'log': (_('Set level of verbosity in log file:') + ' ' + _('{}, {}, {}, {}, or {}').format('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'), '<level>'), 'version': (_('Print version and exit'), None), 'pause': (_('Toggle pause of talk timer'), None), 'reset': (_('Reset talk timer'), None), 'next': (_('Next slide'), None), 'prev': (_('Previous slide'), None), 'first': (_('First slide'), None), 'last': (_('Last slide'), None), 'blank': (_('Blank/unblank content screen'), None), 'quit': (_('Close opened pympress instance'), None), } version_string = ' '.join([ 'Pympress:', util.get_pympress_meta()['version'], '; Python:', platform.python_version(), '; OS:', platform.system(), platform.release(), platform.version(), '; Gtk {}.{}.{}'.format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()), '; GLib {}.{}.{}'.format(GLib.MAJOR_VERSION, GLib.MINOR_VERSION, GLib.MICRO_VERSION), '; Poppler', document.Poppler.get_version(), document.Poppler.get_backend().value_nick, '; Cairo', cairo.cairo_version_string(), ', pycairo', cairo.version, ]) def __init__(self): GLib.set_application_name('pympress') Gtk.Application.__init__(self, application_id='io.github.pympress', flags=Gio.ApplicationFlags.HANDLES_OPEN | Gio.ApplicationFlags.CAN_OVERRIDE_APP_ID) self.register(None) if not self.get_is_remote(): builder.Builder.setup_actions( { 'log-level': dict(activate=self.set_log_level, state=logger.getEffectiveLevel(), parameter_type=int), }, action_map=self) # Connect proper exit function to interrupt signal.signal(signal.SIGINT, self.quit) for opt in self.options: self.add_main_option( opt, *self.options[opt], *self.option_descriptions.get(opt, ['', None])) def quit(self, *args): """ Quit and ignore other arguments e.g. sent by signals. """ Gtk.Application.quit(self) return False def do_startup(self): """ Common start-up tasks for primary and remote instances. NB. super(self) causes segfaults, Gtk.Application needs to be used as base. """ self.config = config.Config() # prefere X11 on posix systems because Wayland still has some shortcomings for us, # specifically libVLC and the ability to disable screensavers if util.IS_POSIX: Gdk.set_allowed_backends('x11,*') logger.info(self.version_string) Gtk.Application.do_startup(self) def do_activate(self, timestamp=GLib.get_current_time()): """ Activate: show UI windows. Build them if they do not exist, otherwise bring to front. """ if self.gui is None: if self.auto_log_level: self.activate_action('log-level', logging.INFO) self.action_startup_queue.append(('log-level', logging.ERROR)) # Build the UI and windows self.gui = ui.UI(self, self.config) while self.action_startup_queue: self.activate_action(*self.action_startup_queue.pop(0)) Gtk.Application.do_activate(self) self.gui.p_win.present_with_time(timestamp) def set_action_enabled(self, name, value): """ Parse an action name and set its enabled state to True or False. Args: name (`str`): the name of the stateful action value (`bool`): wheether the action should be enabled or disabled """ self.lookup_action(name).set_enabled(value) def set_action_state(self, name, value): """ Parse an action name and set its state wrapped in a :class:`~GLib.Variant`. Args: name (`str`): the name of the stateful action value (`str`, `int`, `bool` or `float`): the value to set. """ self.lookup_action(name).change_state( GLib.Variant(builder.Builder._glib_type_strings[type(value)], value)) def get_action_state(self, name): """ Parse an action name and return its unwrapped state from the :class:`~GLib.Variant`. Args: name (`str`): the name of the stateful action Returns: `str`, `int`, `bool` or `float`: the value contained in the action """ state = self.lookup_action(name).get_state() return builder.Builder._glib_type_getters[state.get_type_string()]( state) def activate_action(self, name, parameter=None): """ Parse an action name and activate it, with parameter wrapped in a :class:`~GLib.Variant` if it is not None. Args: name (`str`): the name of the stateful action parameter: an object or None to pass as a parameter to the action, wrapped in a GLib.Variant """ if not self.get_is_remote() and self.gui is None and name not in [ 'log-level' ]: self.action_startup_queue.append((name, parameter)) return if parameter is not None: parameter = GLib.Variant( builder.Builder._glib_type_strings[type(parameter)], parameter) Gio.ActionGroup.activate_action(self, name, parameter) def do_open(self, files, n_files, hint): """ Handle opening files. In practice we only open once, the last one. Args: files (`list` of :class:`~Gio.File`s): representing an array of files to open n_files (`int`): the number of files passed. hint (`str`): a hint, such as view, edit, etc. Should always be the empty string. """ if not n_files: return self.do_activate(timestamp=GLib.get_current_time()) self.gui.swap_document(files[-1].get_uri()) def do_shutdown(self): """ Perform various cleanups and save preferences. """ if self.gui is not None: self.gui.cleanup() self.config.save_config() Gtk.Application.do_shutdown(self) def set_log_level(self, action, param): """ Action that sets the logging level (on the root logger of the active instance) Args: action (:class:`~Gio.Action`): The action activatd param (:class:~`GLib.Variant`): The desired level as an int wrapped in a GLib.Variant """ logging.getLogger(None).setLevel(param.get_int64()) action.change_state(param) def do_handle_local_options(self, opts_variant_dict): """ Parse command line options, returned as a VariantDict Returns: `tuple`: estimated talk time, log level, notes positions. """ # convert GVariantDict -> GVariant -> dict opts = opts_variant_dict.end().unpack() simple_actions = { 'pause': 'pause-timer', 'reset': 'reset-timer', 'next': 'next-page', 'prev': 'prev-page', 'blank': 'blank-screen', 'quit': 'quit', 'first': 'first-page', 'last': 'last-page', } for opt, arg in opts.items(): if opt == "version": print(self.version_string) return 0 elif opt == "log": numeric_level = getattr(logging, arg.upper(), None) if isinstance(numeric_level, int): self.auto_log_level = False self.activate_action('log-level', numeric_level) else: print( _("Invalid log level \"{}\", try one of {}").format( arg, "DEBUG, INFO, WARNING, ERROR, CRITICAL")) elif opt == "notes": arg = arg.lower()[:1] if arg == 'n': self.activate_action('notes-pos', 'none') if arg == 'l': self.activate_action('notes-pos', 'left') if arg == 'r': self.activate_action('notes-pos', 'right') if arg == 't': self.activate_action('notes-pos', 'top') if arg == 'b': self.activate_action('notes-pos', 'bottom') if arg == 'a': self.activate_action('notes-pos', 'after') elif opt == "talk-time": t = ["0" + n.strip() for n in arg.split(':')] try: m = int(t[0]) s = int(t[1]) except ValueError: print( _("Invalid time (mm or mm:ss expected), got \"{}\""). format(arg)) return 2 except IndexError: s = 0 self.activate_action('set-talk-time', m * 60 + s) elif opt in simple_actions: self.activate_action(simple_actions[opt]) return -1