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 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 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 get_version():
v0, v1, v2 = cairo.version_info
return (cairo.cairo_version_string(), '%d.%d.%d' % (v0, v1, v2))
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
