def __init__(self, config, begin, end):
super(changesWindow, self).__init__()
builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
builder.add_from_file(pkg_resources.resource_filename("snappergui", "glade/changesWindow.glade"))
builder.get_object("titlelabel").set_text("%s -> %s"%(begin, end))
self.window = builder.get_object("changesWindow")
self.statusbar = builder.get_object("statusbar1")
self.pathstreeview = builder.get_object("pathstreeview")
self.fileview = builder.get_object("fileview")
self.choicesviewgroup = builder.get_object("actiongroup")
builder.connect_signals(self)
# save mountpoints for begin and end snapshots
self.beginpath = snapper.GetMountPoint(config, begin)
self.endpath = snapper.GetMountPoint(config, end)
self.config = config
self.snapshot_begin = begin
self.snapshot_end = end
self.choicesviewgroup.get_action("begin").set_label(str(begin))
self.choicesviewgroup.get_action("end").set_label(str(end))
self.sourcebuffer = GtkSource.Buffer()
self.fileview.set_buffer(self.sourcebuffer)
self.window.show_all()
GObject.idle_add(self.on_idle_init_paths_tree)
def __init__(self, *args):
self.builder = Gtk.Builder()
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
GObject.type_register(GtkSource.View)
self.builder.add_from_file("pyide.glade")
self.my_accelerators = Gtk.AccelGroup()
fileSystemTreeStore = Gtk.TreeStore(str, Pixbuf, str)
FsTree.populateFileSystemTreeStore(fileSystemTreeStore, os.path.expanduser("~"))
fileSystemTreeView = self.builder.get_object("treeview1")
fileSystemTreeView.set_model(fileSystemTreeStore)
treeViewCol = Gtk.TreeViewColumn("File")
colCellText = Gtk.CellRendererText()
colCellImg = Gtk.CellRendererPixbuf()
treeViewCol.pack_start(colCellImg, False)
treeViewCol.pack_start(colCellText, True)
treeViewCol.add_attribute(colCellText, "text", 0)
treeViewCol.add_attribute(colCellImg, "pixbuf", 1)
fileSystemTreeView.append_column(treeViewCol)
fileSystemTreeView.connect("row-expanded", FsTree.onFSRowExpanded)
fileSystemTreeView.connect("row-collapsed", FsTree.onFSRowCollapsed)
fileSystemTreeView.connect("row-activated", FsTree.onFSRowActivated)
self.builder.connect_signals(Handler())
def __init__(self, lotto=None, tipps=None, file=None):
self.file = file
self.config = ConfigParser()
self.config.read(os.path.expanduser("~/.local/share/lotto/preferences.ini"))
if tipps == None:
tipps = self.config.getint("tipps", "tipps")
if lotto == None:
self.lotto = Lotto([Tipp() for i in range(tipps)]) # @UnusedVariable
else:
self.lotto = lotto
Gtk.Notebook.__init__(self)
self.set_scrollable(True)
GObject.type_register(LottoWidget)
GObject.signal_new("reaload",LottoWidget,GObject.SIGNAL_RUN_FIRST,
GObject.TYPE_NONE, [])
self.tippwidgets = []
for i in range(self.lotto.get_n_tipps()):
self.tippwidgets.append(TippWidget(self.lotto.get_nth_tipp(i)))
self.append_page(child=self.tippwidgets[i],tab_label=Gtk.Label(label="tipp %s"%(i+1)))
self.set_buttons()
def instance_register(self, controller):
GObject.Object.__init__(controller)
type_ = type(controller)
if type_ not in self.conroller_types:
log.debug("Registering GObject type %s", type_)
GObject.type_register(type_)
self.conroller_types.add(type_)
def main():
GObject.type_register(Sexy.SpellEntry)
builder = Gtk.Builder()
builder.add_from_file(UI_FILE)
win = builder.get_object('window')
win.connect('delete-event', Gtk.main_quit)
entry = Sexy.SpellEntry()
entry.set_text('I was nto, but i hav a custom style!')
box = builder.get_object('box')
box.add(entry)
provider = Gtk.CssProvider()
provider.load_from_path(CSS_FILE)
context = entry.get_style_context()
context.add_provider(provider, 800)
label = builder.get_object('label')
label_str = '<b>Available Languages</b>:\n{}\n'.format('\n'.join(entry.get_languages()))
label_str += '<b>Enabled Languages</b>:\n{}'.format('\n'.join(entry.get_active_languages()))
label.set_markup(label_str)
win.show_all()
Gtk.main()
def __init__(self, window):
"""Class initialiser"""
if isinstance(window.get_child(), Gtk.Notebook):
err('There is already a Notebook at the top of this window')
raise(ValueError)
Container.__init__(self)
GObject.GObject.__init__(self)
self.terminator = Terminator()
self.window = window
GObject.type_register(Notebook)
self.register_signals(Notebook)
self.connect('switch-page', self.deferred_on_tab_switch)
self.configure()
child = window.get_child()
window.remove(child)
window.add(self)
window_last_active_term = window.last_active_term
self.newtab(widget=child)
if window_last_active_term:
self.set_last_active_term(window_last_active_term)
window.last_active_term = None
self.show_all()
def init_ui(self):
# Create a "Builder", which basically allows me to import the Glade file for a complete interface.
# I love Glade, btw. So much quicker than manually coding everything.
GObject.type_register(GtkSource.View)
self.builder.add_from_file(program_loc + "UI.glade")
go = self.builder.get_object
profile_editor = go("profileEditor")
menu_prof_exit = go("exitProfWin")
save_button = go("saveMenuProf")
save_tool_button = go("saveToolBtn")
open_tool_button = go("openToolBtn")
clear_button = go("clearToolBtn")
attributes_button = go("attributesToolBtn")
exit_profile_button = go("exitToolBtn")
self.netctlEditor = go("profileEditorView")
self.buffer = go("textbuffer1")
# Connecting the "clicked" signals of each button to the relevant function.
save_button.connect("activate", self.save_clicked)
save_tool_button.connect("clicked", self.save_clicked)
attributes_button.connect("clicked", self.attributes_clicked)
clear_button.connect("clicked", self.clear_clicked)
profile_editor.connect("show", self.on_load)
exit_profile_button.connect("clicked", self.exit_prof_clicked)
menu_prof_exit.connect("activate", self.exit_prof_clicked)
open_tool_button.connect("clicked", self.open_clicked)
# Opening the Prefereces Dialog.
profile_editor.show_all()
def __init__(self):
self.docpath = None
self.message_q = Queue.Queue()
GLib.idle_add(self.on_idle)
builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
builder.add_from_file(UI_PATH)
self.window = builder.get_object("window1")
self.statusbar = builder.get_object("statusbar1")
self.statuscontext = self.statusbar.get_context_id("info")
view = builder.get_object("gtksourceview1")
handlers = {
"on_compile_clicked": self.compileclicked,
"on_deploy_clicked": self.deployclicked,
"on_newBtn_activate": self.newbuttonclicked,
"on_openBtn_activate": self.openbuttonclicked,
"on_saveasBtn_activate": self.saveasbuttonclicked,
"on_saveBtn_activate": self.savebuttonclicked,
"on_cutBtn_activate": self.cutbuttonclicked,
"on_copyBtn_activate": self.copybuttonclicked,
"on_pasteBtn_activate": self.pastebuttonclicked,
"quit": Gtk.main_quit
}
builder.connect_signals(handlers)
lang = GtkSource.LanguageManager.get_default().get_language('python')
self.sourcebuffer = GtkSource.Buffer.new_with_language(lang)
font_desc = Pango.FontDescription('monospace 10')
if font_desc:
view.modify_font(font_desc)
view.set_buffer(self.sourcebuffer)
if self.window:
self.window.connect("destroy", Gtk.main_quit)
self.window.set_size_request(600, 650)
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
def __init__(self):
self.builder = Gtk.Builder()
self.glade_file = join(abspath(dirname(__file__)), "UI.glade")
GObject.type_register(GtkSource.View)
self.builder.add_from_file(self.glade_file)
self.main_window = self.builder.get_object("window1")
self.main_window.connect("delete-event", Gtk.main_quit)
self.main_window.show_all()
def __init__(self):
GObject.Object.__init__(self)
GObject.type_register(type(self))
self.connect("application_shutdown", ignore_sender_function(self.application_shutdown))
self.connect("note_content_added", ignore_sender_function(self.handle_note_content_added))
# event.listen(db_session, "before_commit", self._db_changed_callback)
self.conroller_types = set()
self.sync_control = SyncControl(self)
def __init__(self, note):
self.path = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..'))
self.note = note
self.noteset = note.noteset
self.locked = self.note.properties.get("locked", False)
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(os.path.join(self.path,
"StickyNotes.glade"))
self.builder.connect_signals(self)
# Get necessary objects
self.txtNote = self.builder.get_object("txtNote")
self.winMain = self.builder.get_object("MainWindow")
self.winMain.set_name("main-window")
self.bAdd = self.builder.get_object("bAdd")
self.imgAdd = self.builder.get_object("imgAdd")
self.imgResizeR = self.builder.get_object("imgResizeR")
self.eResizeR = self.builder.get_object("eResizeR")
self.bLock = self.builder.get_object("bLock")
self.imgLock = self.builder.get_object("imgLock")
self.imgUnlock = self.builder.get_object("imgUnlock")
self.bClose = self.builder.get_object("bClose")
self.confirmDelete = self.builder.get_object("confirmDelete")
# Load CSS template and initialize Gtk.CssProvider
with open(os.path.join(self.path, "style.css")) as css_file:
self.css_template = Template(css_file.read())
self.css = Gtk.CssProvider()
self.style_contexts = [self.winMain.get_style_context(),
self.txtNote.get_style_context()]
# Update window-specific style. Global styles are loaded initially!
self.update_style()
# Ensure buttons are displayed with images
settings = Gtk.Settings.get_default()
settings.props.gtk_button_images = True
# Set text buffer
self.bbody = GtkSource.Buffer()
self.bbody.begin_not_undoable_action()
self.bbody.set_text(self.note.body)
self.bbody.set_highlight_matching_brackets(False)
self.bbody.end_not_undoable_action()
self.txtNote.set_buffer(self.bbody)
# Show and hide so winMain and widgets are realized and mapped.
self.winMain.show()
self.winMain.hide()
# Make resize work
self.winMain.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.eResizeR.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
# Move Window
self.winMain.move(*self.note.properties.get("position", (10,10)))
self.winMain.resize(*self.note.properties.get("size", (200,150)))
# Mouse over
self.eResizeR.get_window().set_cursor(Gdk.Cursor.new_for_display(
self.eResizeR.get_window().get_display(),
Gdk.CursorType.BOTTOM_RIGHT_CORNER))
# Set locked state
self.set_locked_state(self.locked)
def build_note(self):
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(os.path.join(self.path,
"StickyNotes.glade"))
self.builder.connect_signals(self)
self.winMain = self.builder.get_object("MainWindow")
# Get necessary objects
self.winMain.set_name("main-window")
widgets = ["txtNote", "bAdd", "imgAdd", "imgResizeR", "eResizeR",
"bLock", "imgLock", "imgUnlock", "imgClose", "imgDropdown",
"bClose", "confirmDelete", "movebox1", "movebox2"]
for w in widgets:
setattr(self, w, self.builder.get_object(w))
self.style_contexts = [self.winMain.get_style_context(),
self.txtNote.get_style_context()]
# Update window-specific style. Global styles are loaded initially!
self.update_style()
self.update_font()
# Ensure buttons are displayed with images
settings = Gtk.Settings.get_default()
settings.props.gtk_button_images = True
# Set text buffer
self.bbody = GtkSource.Buffer()
self.bbody.begin_not_undoable_action()
self.bbody.set_text(self.note.body)
self.bbody.set_highlight_matching_brackets(False)
self.bbody.end_not_undoable_action()
self.txtNote.set_buffer(self.bbody)
# Make resize work
self.winMain.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.eResizeR.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
# Move Window
self.winMain.move(*self.note.properties.get("position", (10,10)))
self.winMain.resize(*self.note.properties.get("size", (200,150)))
# Show the window
self.winMain.set_skip_pager_hint(True)
self.winMain.show_all()
# Mouse over
self.eResizeR.get_window().set_cursor(Gdk.Cursor.new_for_display(
self.eResizeR.get_window().get_display(),
Gdk.CursorType.BOTTOM_RIGHT_CORNER))
# Set locked state
self.set_locked_state(self.locked)
# call set_keep_above just to have the note appearing
# above everything else.
# without it, it still won't appear above a window
# in which a cursor is active
self.winMain.set_keep_above(True)
# immediately undo the set keep above after the window
# is shown, so that windows won't stay up if we switch to
# a different window
self.winMain.set_keep_above(False)
def __init__ ( self, _dir="gui", start_type="input" ): self.dir = DIR GObject.type_register ( configitem.ConfigItem ) GObject.type_register ( configfile.ConfigFile ) GObject.signal_new ( "new_config", configitem.ConfigItem, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configitem.ConfigItem, ) ) GObject.signal_new ( "remove_item", configitem.ConfigItem, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configfile.ConfigFile, ) ) GObject.signal_new ( "remove_config", configfile.ConfigFile, GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ( configfile.ConfigFile, ) ) self.project = project.Project ( _dir, start_type, main_handlers, self.dir ) self.project.load_config ( self.project.files, "parser.cfg" ) self.config = "parser.cfg"
def registerSignals(cls): GObject.type_register(cls) for name, args in cls.signals: GObject.signal_new( name, cls, GObject.SignalFlags.RUN_LAST, None, args, ) return cls
def __init__(self):
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file("main.glade")
self.main_window = self.builder.get_object("MainWindow")
self.view = self.builder.get_object("View")
self.textbuff = GtkSource.Buffer()
self.view.set_buffer(self.textbuff)
self.lm = GtkSource.LanguageManager()
self.textbuff.set_language(self.lm.get_language('python'))
self.main_window.connect("destroy", Gtk.main_quit)
self.keywords = """
def type_register(gtype):
"""Register the type, but only if it's not already registered
:param gtype: the class to register
"""
# copied from gobjectmodule.c:_wrap_type_register
if (getattr(gtype, '__gtype__', None) !=
getattr(gtype.__base__, '__gtype__', None)):
return False
GObject.type_register(gtype)
return True
def testImplementInterface(self):
class MyObject(GObject.GObject, testhelper.Interface):
some_property = GObject.Property(type=str)
def __init__(self):
GObject.GObject.__init__(self)
self.called = False
def do_iface_method(self):
self.called = True
GObject.type_register(MyObject)
m = MyObject()
m.iface_method()
self.assertEqual(m.called, True)
def _type_register(cls, namespace):
## don't register the class if already registered
if '__gtype__' in namespace:
return
if not ('__gproperties__' in namespace or
'__gsignals__' in namespace or
'__gtype_name__' in namespace):
return
# Do not register a new GType for the overrides, as this would sort
# of defeat the purpose of overrides...
if cls.__module__.startswith('gi.overrides.'):
return
GObject.type_register(cls, namespace.get('__gtype_name__'))
def testReImplementInterface(self):
class MyUnknown(Unknown, testhelper.Interface):
some_property = GObject.Property(type=str)
def __init__(self):
Unknown.__init__(self)
self.called = False
def do_iface_method(self):
self.called = True
Unknown.do_iface_method(self)
GObject.type_register(MyUnknown)
m = MyUnknown()
m.iface_method()
self.assertEqual(m.called, True)
def _init_plugin(plugin, userarg):
# Before registering the filter plugin we must ensure that the
# plugin's metadata and pad templates are set.
# Usually the data should be set automatically based on the
# __gstmetadata__ and __gsttemplates__ attributes. This works as
# expected on:
# Xubuntu 14.04
# (python-gst-1.0 [1.2.0-1], gstreamer1.0-x [1.2.4-1])
# Xubuntu 15.05
# (python-gst-1.0 [1.2.1-1.1], gstreamer1.0-x [1.4.5-1])
# However on Windows 7 running PyGI 3.14.0 AIO rev19 (including
# gstreamer 1.4.5) these values must be set explicitly using
# set_metadata and add_pad_template. If we would not set the values
# explicitly we would get the following warning/error:
# GStreamer-WARNING **: Element factory metadata for
# 'timeclbfilter' has no valid long-name field
# CRITICAL **: gst_base_transform_init: assertion 'pad_template !=
# NULL' failed
try:
TimeClbFilter.set_metadata(*TimeClbFilter.__gstmetadata__)
TimeClbFilter.add_pad_template(TimeClbFilter._sinktemplate)
TimeClbFilter.add_pad_template(TimeClbFilter._srctemplate)
except AttributeError:
pass
TimeClbFilterType = GObject.type_register(TimeClbFilter)
Gst.Element.register(plugin, 'timeclbfilter', 0, TimeClbFilterType)
return True
def __init__(self, logger):
self.log = logger
Gtk.VBox.__init__(self, spacing=3)
GObject.GObject.__init__(self)
# top navi
self.set_no_show_all(True)
tbox = Gtk.HBox(spacing=3)
# navigation buttons
self.link_button = Gtk.LinkButton('', label='Article Title')
self.link_button.set_relief(Gtk.ReliefStyle.NONE)
tbox.pack_start(self.link_button, True, True,0)
self.file_img = Gtk.Image().new_from_stock('gtk-file', Gtk.IconSize.BUTTON)
tbox.pack_start(self.file_img, False, False,0)
self.star_img = Gtk.Image().new_from_stock('gtk-about', Gtk.IconSize.BUTTON)
tbox.pack_start(self.star_img, False, False,0)
self.feed_img = Gtk.Image().new_from_stock('missing', Gtk.IconSize.BUTTON)
tbox.pack_start(self.feed_img, False, False,0)
# webkit view
self.feedview = WebKit.WebView()
self.feedview.set_full_content_zoom(True)
self.feedview.connect("navigation-policy-decision-requested", self.__override_clicks)
self.feedview.connect("hovering-over-link", self.__hover_webview)
self.link_button.connect("enter-notify-event", self.__hover_link, "in")
self.link_button.connect("leave-notify-event", self.__hover_link)
# containers
tal = Gtk.Alignment.new(0.5, 0.5, 1, 1)
tal.show()
tal.add(tbox)
tbox.show()
msc = Gtk.ScrolledWindow()
msc.show()
msc.set_shadow_type(Gtk.ShadowType.IN)
msc.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
msc.add(self.feedview)
mal = Gtk.Alignment.new(0.5, 0.5, 1, 1)
mal.show()
mal.add(msc)
self.pack_start(tal, False, False,0)
self.pack_start(mal, True, True,0)
GObject.type_register(View)
self.valid_links = ['file:']
self.show()
self.link_button.show()
self.feedview.show()
self.feed_img.show()
self.file_img.show()
self.__art_id = None
def check_gtk_prerequisites():
try:
from gi.repository import Gtk
except ImportError:
logger.critical('Missing dependency: GTK3 Python interface.')
sys.exit(1)
try:
from gi.repository import GtkSource, GObject
GObject.type_register(GtkSource.View)
except ImportError:
logger.critical('Missing dependency: GtkSourceView widget.')
sys.exit(1)
try:
import cairo
except ImportError:
logger.critical('Missing dependency: Python Cairo interface.')
sys.exit(1)
def __init__(self, filename=None, custom_widget_types=[], extra_bind_op={}):
super(View, self).__init__()
self.signal_handlers = {}
for each in custom_widget_types:
GObject.type_register(each)
self.update_binding_op(extra_bind_op)
if filename is None:
return
self.builder = Gtk.Builder()
self.get_object = self.builder.get_object
self.builder.add_from_file(filename)
objects = self.prepare_objects()
self.top = [each for each in objects if isinstance(each, Gtk.Container) and each.get_parent() is None][0]
def __init__(self):
"""Class initialiser"""
self.terminator = Terminator()
self.terminator.register_window(self)
Container.__init__(self)
GObject.GObject.__init__(self)
GObject.type_register(Window)
self.register_signals(Window)
self.get_style_context().add_class("terminator-terminal-window")
# self.set_property('allow-shrink', True) # FIXME FOR GTK3, or do we need this actually?
icon_to_apply=''
self.register_callbacks()
self.apply_config()
self.title = WindowTitle(self)
self.title.update()
self.preventHide = False
options = self.config.options_get()
if options:
if options.forcedtitle:
self.title.force_title(options.forcedtitle)
if options.role:
self.set_role(options.role)
if options.forcedicon is not None:
icon_to_apply = options.forcedicon
if options.geometry:
if not self.parse_geometry(options.geometry):
err('Window::__init__: Unable to parse geometry: %s' %
options.geometry)
self.apply_icon(icon_to_apply)
self.pending_set_rough_geometry_hint = False
def __init__(self):
Gtk.Window.__init__(self)
GObject.GObject.__init__(self)
GObject.type_register(Reader)
self.log = Logger("reader.log", "BRss-Reader")
self.settings = Gio.Settings.new(BASE_KEY)
self.settings.connect("changed::show-status", self.__toggle_status)
# ui elements
self.tree = Tree(self.log)
self.ilist = ArticleList(self.log)
self.ilist.set_property("height-request", 250)
self.view = View(self.log)
self.status = Status()
# layout
self.__layout_ui()
#signals
self.__connect_signals()
self.__get_engine()
# ready to go
self.emit('loaded')
def __init__(self):
self.scanning = False
self.thread = None
self.APindex = 0
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(str(Path(program_loc, "UI.glade")))
self.password_dialog = self.builder.get_object("passwordDialog")
self.ap_list = self.builder.get_object("treeview1")
self.ap_store = Gtk.ListStore(str, str, str, str)
self.statusbar = self.builder.get_object("statusbar1")
self.context = self.statusbar.get_context_id("netgui")
self.interface_name = ""
self.NoWifiMode = False
self.interface_control = InterfaceControl()
self.next_function = None
self.generate_config = GenConfig(profile_dir)
self.notifications = Notification()
self.init_ui()
def __init__(self):
"""Class initialiser"""
self.terminator = Terminator()
self.terminator.register_window(self)
Container.__init__(self)
GObject.GObject.__init__(self)
GObject.type_register(Window)
self.register_signals(Window)
self.set_property('allow-shrink', True)
icon_to_apply=''
self.register_callbacks()
self.apply_config()
self.title = WindowTitle(self)
self.title.update()
options = self.config.options_get()
if options:
if options.forcedtitle:
self.title.force_title(options.forcedtitle)
if options.role:
self.set_role(options.role)
if options.classname is not None:
self.set_wmclass(options.classname, self.wmclass_class)
if options.forcedicon is not None:
icon_to_apply = options.forcedicon
if options.geometry:
if not self.parse_geometry(options.geometry):
err('Window::__init__: Unable to parse geometry: %s' %
options.geometry)
self.apply_icon(icon_to_apply)
self.pending_set_rough_geometry_hint = False
def check_gui_prerequisites():
try:
from gi.repository import Gtk
except ImportError:
logging.critical('You need the Python GTK interface!')
sys.exit(1)
try:
from gi.repository import GtkSource, GObject
GObject.type_register(GtkSource.View)
except ImportError:
logging.critical('You need the GtkSourceView widget!')
sys.exit(1)
try:
import cairo
except ImportError:
logging.critical('You need the Python Cairo interface!')
sys.exit(1)
try:
from gi.repository import Vte
except ImportError:
logging.critical('You need VTE!')
sys.exit(1)
def testPyGObject(self):
class Foo(GObject.GObject):
gsignal('hcf', bool, str)
gproperty(bool, 'burning', 'If the object is burning',
False)
def __init__(xself):
GObject.GObject.__init__(xself)
xself.connect('hcf', xself.on_hcf)
xself.set_property('burning', False)
def on_hcf(xself, again_self, x, y):
self.assert_(isinstance(x, bool))
self.assert_(isinstance(y, str))
xself.set_property('burning', True)
GObject.type_register(Foo)
o = Foo()
self.assertEquals(False, o.get_property('burning'))
o.emit('hcf', False, 'foogoober')
self.assertEquals(True, o.get_property('burning'))
def init_ui(self):
GObject.type_register(GtkSource.View)
self.builder.add_from_file(str(Path(self.program_loc, "UI.glade")))
# Get everything we need from UI.glade
go = self.builder.get_object
self.preferences_dialog = go("prefDialog")
save_button = go("saveButton")
cancel_button = go("cancelButton")
self.interface_entry = go("wiInterface")
self.default_profile = go("defaultProfilePath")
self.unsecure_switch = go("unsecureSwitch")
self.autoconnect_switch = go("autoconnectSwitch")
self.notification_type = go("notification_type")
filechooser = go("chooseDefaultProfile")
# Connecting the "clicked" signals of each button to the relevant function.
save_button.connect("clicked", self.save_clicked)
cancel_button.connect("clicked", self.cancel_clicked)
self.preferences_dialog.connect("show", self.on_load)
filechooser.connect("clicked", self.choose_profile)
# Opening the Preferences Dialog.
self.preferences_dialog.run()
def deactivate(self):
# Revert color back to normal
default_bg_color = self.get_style().bg[Gtk.StateType.NORMAL]
self.modify_bg(Gtk.StateType.NORMAL, default_bg_color)
#self.unset_flags(Gtk.CAN_FOCUS)
self.set_can_focus(False)
self.active = False
keybinding = self.getKeybinding()
if not keybinding:
self._label.set_text(DEFAULT_TEXT)
else:
self._label.set_text(keybinding)
GObject.type_register(KeybindingWidget)
GObject.signal_new("keybinding-changed", KeybindingWidget,
GObject.SignalFlags.RUN_LAST,
GObject.TYPE_NONE,
(GObject.TYPE_PYOBJECT,))
# Tests below
def on_keybinding_changed(widget, keybinding):
print "on_keybinding_changed()"
print "New keybinding is", keybinding
if __name__ == '__main__':
logging.basicConfig()
log.setLevel(logging.DEBUG)
else:
iter = pre
break
if not iter:
iter = pre
if iter:
path = self.treestore.get_path(iter)
self.treeview.scroll_to_cell(path, None, False, 0, 0)
self.treeview.set_cursor(path, None, False)
self.treeview.grab_focus()'''
# Called when a row of customer table get activated by mouse double-click or Enter key
def selectCustomerFromList(self, treeview, path, view_column):
iter = self.treestore.get_iter(path)
if self.treestore.iter_parent(iter) != None:
code = utility.convertToLatin(self.treestore.get_value(iter, 0))
query = share.config.db.session.query(Customers).select_from(
Customers)
query = query.filter(Customers.custCode == code)
customer_id = query.first().custId
self.emit("customer-selected", customer_id, code)
GObject.type_register(Customer)
GObject.signal_new("customer-selected", Customer, GObject.SignalFlags.RUN_LAST,
None, (GObject.TYPE_INT, GObject.TYPE_STRING))
## @}
if angle == 0:
return
a_x = self.grips[0].img_position[0]
a_y = self.grips[0].img_position[1]
b_x = self.grips[1].img_position[0]
b_y = self.grips[1].img_position[1]
logger.info(
"Rotating chopping coords {} by {} degrees (img size: {})".format(
(a_x, a_y, b_x, b_y), angle, (size_x, size_y)))
if angle == 90:
# beware: img_size has already been changed, but not our coords
(a_x, a_y, b_x, b_y) = (size_x - b_y, a_x, size_x - a_y, b_x)
elif angle == 180:
(a_x, a_y, b_x, b_y) = (size_x - b_x, size_y - b_y, size_x - a_x,
size_y - a_y)
elif angle == 270:
# beware: img_size has already been changed, but not our coords
(a_x, a_y, b_x, b_y) = (a_y, size_y - b_x, b_y, size_y - a_x)
logger.info("Rotation result: {} (img size: {})".format(
(a_x, a_y, b_x, b_y), (size_x, size_y)))
self.grips[0].img_position = (a_x, a_y)
self.grips[1].img_position = (b_x, b_y)
GObject.type_register(ImgGripHandler)
"""
podata = []
for candidate in odata[1]:
if candidate['class'] == "func":
info = candidate['class'] + " " + candidate[
'name'] + candidate['type'][len("func"):]
icon = self._plugin.icons['func']
# if we have a function add a parenthesis for the code completion
candidate['name'] += '('
else:
info = candidate['class'] + " " + candidate[
'name'] + " " + candidate['type']
icon = self._plugin.icons['var'] # default
if candidate['class'] == "const":
icon = self._plugin.icons['const']
elif candidate['class'] == "package":
icon = self._plugin.icons['package']
elif candidate['class'] == "type":
if candidate['type'] == "interface":
icon = self._plugin.icons['interface']
elif candidate['type'] == "struct":
icon = self._plugin.icons['struct']
podata.append(
(candidate['name'], candidate['name'][odata[0]:], icon, info))
return podata
GObject.type_register(GoProvider)
def __init__(self):
# Create the temporary directory
self.tmp_dir = tempfile.mkdtemp('pdfshuffler')
os.chmod(self.tmp_dir, 0o700)
iconsdir = os.path.join(sharedir, 'pdfshuffler', 'icons')
if not os.path.exists(iconsdir):
iconsdir = os.path.join(sharedir, 'data')
Gtk.IconTheme.get_default().append_search_path(iconsdir)
Gtk.Window.set_default_icon_name('pdfshuffler')
# Import the user interface file, trying different possible locations
ui_path = os.path.join(basedir, 'share', 'pdfshuffler',
'pdfshuffler.ui')
if not os.path.exists(ui_path):
ui_path = os.path.join(basedir, 'data', 'pdfshuffler.ui')
if not os.path.exists(ui_path):
ui_path = '/usr/share/pdfshuffler/pdfshuffler.ui'
if not os.path.exists(ui_path):
ui_path = '/usr/local/share/pdfshuffler/pdfshuffler.ui'
self.uiXML = Gtk.Builder()
self.uiXML.set_translation_domain('pdfshuffler')
self.uiXML.add_from_file(ui_path)
self.uiXML.connect_signals(self)
# Create the main window, and attach delete_event signal to terminating
# the application
self.window = self.uiXML.get_object('main_window')
self.window.set_title(APPNAME)
self.window.set_border_width(0)
self.window.set_default_size(self.prefs['window width'],
self.prefs['window height'])
self.window.connect('delete_event', self.close_application)
# Create a scrolled window to hold the thumbnails-container
self.sw = self.uiXML.get_object('scrolledwindow')
self.sw.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.DROP | Gtk.DestDefaults.MOTION, self.TARGETS_SW,
Gdk.DragAction.COPY | Gdk.DragAction.MOVE)
self.sw.connect('drag_data_received', self.sw_dnd_received_data)
self.sw.connect('button_press_event', self.sw_button_press_event)
self.sw.connect('scroll_event', self.sw_scroll_event)
# Create an alignment to keep the thumbnails center-aligned
align = Gtk.Alignment.new(0.5, 0.5, 0, 0)
self.sw.add_with_viewport(align)
# Create ListStore model and IconView
self.model = Gtk.ListStore(
str, # 0.Text descriptor
GObject.TYPE_PYOBJECT,
# 1.Cached page image
int, # 2.Document number
int, # 3.Page number
float, # 4.Scale
str, # 5.Document filename
int, # 6.Rotation angle
float, # 7.Crop left
float, # 8.Crop right
float, # 9.Crop top
float, # 10.Crop bottom
float, # 11.Page width
float, # 12.Page height
float) # 13.Resampling factor
self.zoom_set(self.prefs['initial zoom level'])
self.iv_col_width = self.prefs['initial thumbnail size']
self.iconview = Gtk.IconView(self.model)
self.iconview.clear()
self.iconview.set_item_width(-1) #self.iv_col_width + 12)
self.cellthmb = CellRendererImage()
self.iconview.pack_start(self.cellthmb, False)
self.iconview.set_cell_data_func(self.cellthmb,
self.set_cellrenderer_data, None)
# self.iconview.add_attribute(self.cellthmb, 'image', 1)
# self.iconview.add_attribute(self.cellthmb, 'scale', 4)
# self.iconview.add_attribute(self.cellthmb, 'rotation', 6)
# self.iconview.add_attribute(self.cellthmb, 'cropL', 7)
# self.iconview.add_attribute(self.cellthmb, 'cropR', 8)
# self.iconview.add_attribute(self.cellthmb, 'cropT', 9)
# self.iconview.add_attribute(self.cellthmb, 'cropB', 10)
# self.iconview.add_attribute(self.cellthmb, 'width', 11)
# self.iconview.add_attribute(self.cellthmb, 'height', 12)
# self.iconview.add_attribute(self.cellthmb, 'resample', 13)
# self.celltxt = Gtk.CellRendererText()
# self.celltxt.set_property('width', self.iv_col_width)
# self.celltxt.set_property('wrap-width', self.iv_col_width)
# self.celltxt.set_property('alignment', Pango.Alignment.CENTER)
# self.iconview.pack_start(self.celltxt, False)
# self.iconview.add_attribute(self.celltxt, 'text', 0)
self.iconview.set_text_column(0)
self.iconview.set_selection_mode(Gtk.SelectionMode.MULTIPLE)
self.iconview.enable_model_drag_source(
Gdk.ModifierType.BUTTON1_MASK, self.TARGETS_IV,
Gdk.DragAction.COPY | Gdk.DragAction.MOVE)
self.iconview.enable_model_drag_dest(self.TARGETS_IV,
Gdk.DragAction.DEFAULT)
self.iconview.connect('drag_begin', self.iv_drag_begin)
self.iconview.connect('drag_data_get', self.iv_dnd_get_data)
self.iconview.connect('drag_data_received', self.iv_dnd_received_data)
self.iconview.connect('drag_data_delete', self.iv_dnd_data_delete)
self.iconview.connect('drag_motion', self.iv_dnd_motion)
self.iconview.connect('drag_leave', self.iv_dnd_leave_end)
self.iconview.connect('drag_end', self.iv_dnd_leave_end)
self.iconview.connect('button_press_event', self.iv_button_press_event)
align.add(self.iconview)
# Progress bar
self.progress_bar = self.uiXML.get_object('progressbar')
self.progress_bar_timeout_id = 0
# Define window callback function and show window
self.window.connect('size_allocate',
self.on_window_size_request) # resize
self.window.connect('key_press_event',
self.on_keypress_event) # keypress
self.window.show_all()
self.progress_bar.hide()
# Change iconview color background
style_context_sw = self.sw.get_style_context()
color_selected = self.iconview.get_style_context()\
.get_background_color(Gtk.StateFlags.SELECTED)
color_prelight = color_selected.copy()
color_prelight.alpha = 0.3
for state in (Gtk.StateFlags.NORMAL, Gtk.StateFlags.ACTIVE):
self.iconview.override_background_color \
(state, style_context_sw.get_background_color(state))
self.iconview.override_background_color(Gtk.StateFlags.SELECTED,
color_selected)
self.iconview.override_background_color(Gtk.StateFlags.PRELIGHT,
color_prelight)
# Creating the popup menu
self.popup = Gtk.Menu()
labels = (_('_Rotate Right'), _('Rotate _Left'), _('C_rop...'),
_('_Delete'), _('_Export selection...'))
cbs = (self.rotate_page_right, self.rotate_page_left,
self.crop_page_dialog, self.clear_selected,
self.choose_export_selection_pdf_name)
for label, cb in zip(labels, cbs):
popup_item = Gtk.MenuItem.new_with_mnemonic(label)
popup_item.connect('activate', cb)
popup_item.show()
self.popup.append(popup_item)
# Initializing variables
self.export_directory = os.getenv('HOME')
self.import_directory = self.export_directory
self.nfile = 0
self.iv_auto_scroll_direction = 0
self.iv_auto_scroll_timer = None
self.pdfqueue = []
GObject.type_register(PDF_Renderer)
GObject.signal_new(
'update_thumbnail', PDF_Renderer, GObject.SignalFlags.RUN_FIRST,
None,
[GObject.TYPE_INT, GObject.TYPE_PYOBJECT, GObject.TYPE_FLOAT])
self.rendering_thread = 0
self.set_unsaved(False)
# Importing documents passed as command line arguments
for filename in sys.argv[1:]:
self.add_pdf_pages(filename)
from gi.repository import GObject # for using custom signals
from gi.repository import Pango # for adjusting the text alignment in CellRendererText
from gi.repository import Gio # for inquiring mime types information
gi.require_version('Poppler', '0.18')
from gi.repository import Poppler #for the rendering of pdf pages
import cairo
try:
from pyPdf import PdfFileWriter, PdfFileReader
except ImportError:
from PyPDF2 import PdfFileWriter, PdfFileReader
from .pdfshuffler_iconview import CellRendererImage
GObject.type_register(CellRendererImage)
import time
class PdfShuffler:
prefs = {
'window width': min(700,
Gdk.Screen.get_default().get_width() / 2),
'window height': min(600,
Gdk.Screen.get_default().get_height() - 50),
'initial thumbnail size': 300,
'initial zoom level': -14,
}
MODEL_ROW_INTERN = 1001
GObject.threads_init()
Gdk.threads_init()
from gi.repository import OsmGpsMap as osmgpsmap
print "using library: %s (version %s)" % (osmgpsmap.__file__,
osmgpsmap._version)
assert osmgpsmap._version == "1.0"
class DummyMapNoGpsPoint(osmgpsmap.Map):
def do_draw_gps_point(self, drawable):
pass
GObject.type_register(DummyMapNoGpsPoint)
class DummyLayer(GObject.GObject, osmgpsmap.MapLayer):
def __init__(self):
GObject.GObject.__init__(self)
def do_draw(self, gpsmap, gdkdrawable):
pass
def do_render(self, gpsmap):
pass
def do_busy(self):
return False
# its title (which is supposed to be the name of the window manager).
# NB, GDK will do strange things to this window. We don't want to use
# it for anything. (In particular, it will call XSelectInput on it,
# which is fine normally when GDK is running in a client, but since it
# happens to be using the same connection as we the WM, it will
# clobber any XSelectInput calls that *we* might have wanted to make
# on this window.) Also, GDK might silently swallow all events that
# are detected on it, anyway.
self._ewmh_window = GDKX11Window(
self._root,
wclass=Gdk.WindowWindowClass.INPUT_ONLY,
title=self._wm_name)
prop_set(self._ewmh_window, "_NET_SUPPORTING_WM_CHECK", "window",
self._ewmh_window)
self.root_set("_NET_SUPPORTING_WM_CHECK", "window", self._ewmh_window)
self.root_set("_NET_WM_NAME", "utf8", self._wm_name)
def get_net_wm_name(self):
try:
return prop_get(self._ewmh_window,
"_NET_WM_NAME",
"utf8",
ignore_errors=False,
raise_xerrors=False)
except Exception as e:
log.error("error querying _NET_WM_NAME: %s", e)
GObject.type_register(Wm)
if row[STATE_COL] == State.CANCELED:
os.remove(tmp_filepath)
if os.path.exists(conf_filepath):
os.remove(conf_filepath)
elif row[STATE_COL] == State.ERROR:
self.emit('network-error', row[FSID_COL])
elif row[STATE_COL] == State.FINISHED:
self.emit('downloaded', row[FSID_COL])
os.rename(tmp_filepath, filepath)
if os.path.exists(conf_filepath):
os.remove(conf_filepath)
def destroy(self):
'''自毁'''
self.pause()
def run(self):
'''实现了Thread的方法, 线程启动入口'''
self.download()
def pause(self):
'''暂停下载任务'''
self.row[STATE_COL] = State.PAUSED
def stop(self):
'''停止下载, 并删除之前下载的片段'''
self.row[STATE_COL] = State.CANCELED
GObject.type_register(Downloader)
def __init__(self, window, core):
Gtk.Entry.__init__(self)
self.events = core.events
self.core = core
self.win = window
# we don't want key events to propogate so we stop them in
# connect_after
self.connect('key-press-event', TextInput.keypress)
self.connect_after('key-press-event', lambda *a: True)
self.connect('activate', TextInput.entered_text, False)
GObject.type_register(TextInput)
def prop_to_Gtk(textview, xxx_todo_changeme):
(prop, val) = xxx_todo_changeme
if val == parse_mirc.BOLD:
val = Pango.Weight.BOLD
elif val == parse_mirc.UNDERLINE:
val = Pango.Underline.SINGLE
return {prop: val}
def word_from_pos(text, pos):
if text[pos] == ' ':
def do_clicked(self):
dialog = EmojiLangChooser(id=self.__lang,
transient_for=self.get_toplevel())
id = dialog.run()
if id != Gtk.ResponseType.APPLY:
dialog.destroy()
return
self.set_lang(dialog.get_selected_lang())
dialog.destroy()
def set_lang(self, lang):
self.__lang = lang
self.notify("lang")
self.set_label(IBus.get_language_name(lang))
def get_lang(self, lang):
return self.__lang
GObject.type_register(EmojiLangButton)
if __name__ == "__main__":
dialog = EmojiLangChooser()
id = dialog.run()
if id != Gtk.ResponseType.APPLY:
dialog.destroy()
import sys
sys.exit(0)
print("Selected language:", dialog.get_selected_lang())
track = self.book.chapters.first()
path = os.path.dirname(track.file)
subprocess.Popen(['xdg-open', path])
def __on_storage_changed(self, event, message):
if (event == "storage-online" and not super().get_sensitive()
) or event == "external-storage-removed":
if message in self.book.chapters[0].file:
super().set_sensitive(True)
self.box.set_tooltip_text(self.ONLINE_TOOLTIP_TEXT)
elif (event == "storage-offline" and super().get_sensitive()):
if message in self.book.chapters[0].file and not self.book.offline:
super().set_sensitive(False)
self.box.set_tooltip_text(self.OFFLINE_TOOLTIP_TEXT)
elif event == "external-storage-added":
if FilesystemMonitor().is_book_online(self.book.db_object):
super().set_sensitive(True)
else:
super().set_sensitive(False)
self.box.set_tooltip_text(self.OFFLINE_TOOLTIP_TEXT)
if event == "external-storage-removed":
first_track = self.book.chapters[0]
if first_track and message in first_track.file:
self.box.set_tooltip_text(self.ONLINE_TOOLTIP_TEXT)
GObject.type_register(AlbumElement)
GObject.signal_new('play-pause-clicked', BookElement, GObject.SIGNAL_RUN_LAST,
GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT, ))
GObject.signal_new('open-book-overview', BookElement, GObject.SIGNAL_RUN_LAST,
GObject.TYPE_PYOBJECT, (GObject.TYPE_PYOBJECT, ))
layout.set_text(text, -1)
fd = Pango.font_description_from_string("Sans 10")
layout.set_font_description(fd)
w, h = layout.get_pixel_size()
context.move_to(cell_area.x, cell_area.y)
context.rel_move_to(70 - w, (height - h) / 2)
PangoCairo.show_layout(context, layout)
def do_get_size(self, widget, cell_area=None):
return (0, 0, width, height)
GObject.type_register(StrengthCellRenderer)
################################################################################
# StrengthCellRenderer functions #
################################################################################
from math import ceil
def stoplightColor(x):
interp = lambda y0, yh, y1: y0 + (y1 + 4 * yh - 3 * y0) * x + (
-4 * yh + 2 * y0) * x * x
r = interp(239, 252, 138) / 255
g = interp(41, 233, 226) / 255
b = interp(41, 79, 52) / 255
return r, g, b
def register_elements(plugin):
gtype = GObject.type_register(Freezer)
Gst.Element.register(plugin, 'freezer', 0, gtype)
return True
def __init__(self, journal):
self.journal = journal
# Load Glade file.
# TODO: Remove workaround for Windows once it is no longer needed.
self.gladefile = os.path.join(filesystem.files_dir,
'main_window.glade')
self.builder = Gtk.Builder()
# Register GtkSourceView so builder can use it when loading the file
# https://stackoverflow.com/q/10524196/434217
GObject.type_register(GtkSource.View)
if filesystem.IS_WIN:
import xml.etree.ElementTree as ET
tree = ET.parse(self.gladefile)
for node in tree.iter():
if 'translatable' in node.attrib:
node.text = _(node.text)
xml_text = ET.tostring(tree.getroot(), encoding='unicode')
self.builder = Gtk.Builder.new_from_string(xml_text, len(xml_text))
else:
self.builder.set_translation_domain('rednotebook')
self.builder.add_from_file(self.gladefile)
# Get the main window and set the icon
self.main_frame = self.builder.get_object('main_frame')
self.main_frame.set_title('RedNotebook')
icon = GdkPixbuf.Pixbuf.new_from_file(
os.path.join(filesystem.frame_icon_dir, 'rednotebook.svg'))
self.main_frame.set_icon(icon)
self.is_fullscreen = False
self.uimanager = Gtk.UIManager()
# Before fetching the menubar, add all menus and actiongroups.
# Setup the toolbar items first to avoid warnings for missing actions.
insert_menu.InsertMenu(self)
format_menu.FormatMenu(self)
self.menubar_manager = MainMenuBar(self)
self.menubar = self.menubar_manager.get_menu_bar()
main_vbox = self.builder.get_object('vbox3')
main_vbox.pack_start(self.menubar, False, False, 0)
main_vbox.reorder_child(self.menubar, 0)
self.undo_action = self.uimanager.get_action('/MainMenuBar/Edit/Undo')
self.redo_action = self.uimanager.get_action('/MainMenuBar/Edit/Redo')
self.calendar = MainCalendar(self.journal,
self.builder.get_object('calendar'))
self.day_text_field = DayEditor(
self.builder.get_object('day_text_view'))
self.day_text_field.connect('can-undo-redo-changed',
self.update_undo_redo_buttons)
self.update_undo_redo_buttons()
self.day_text_field.day_text_view.grab_focus()
can_spell_check = self.day_text_field.can_spell_check()
spell_check_enabled = bool(self.journal.config.read('spellcheck'))
for actiongroup in self.menubar_manager.uimanager.get_action_groups():
if actiongroup.get_name() == 'MainMenuActionGroup':
for action in actiongroup.list_actions():
if action.get_name() == 'CheckSpelling':
action.set_sensitive(can_spell_check)
action.set_active(spell_check_enabled
and can_spell_check)
self.day_text_field.enable_spell_check(spell_check_enabled)
self.statusbar = Statusbar(self.builder.get_object('statusbar'))
self.new_entry_dialog = NewEntryDialog(self)
self.categories_tree_view = categories.CategoriesTreeView(
self.builder.get_object('categories_tree_view'), self)
self.new_entry_dialog.categories_tree_view = self.categories_tree_view
self.back_one_day_button = self.builder.get_object(
'back_one_day_button')
self.today_button = self.builder.get_object('today_button')
self.forward_one_day_button = self.builder.get_object(
'forward_one_day_button')
self.edit_pane = self.builder.get_object('edit_pane')
self.text_vbox = self.builder.get_object('text_vbox')
use_cef = True
if browser.WebKit2:
class Preview(browser.HtmlView):
def __init__(self, journal):
browser.HtmlView.__init__(self)
self.journal = journal
self.internal = True
def show_day(self, new_day):
html = self.journal.convert(new_day.text, 'xhtml')
self.load_html(html)
def shutdown(self):
pass
self.html_editor = Preview(self.journal)
self.html_editor.connect('button-press-event',
self.on_browser_clicked)
self.html_editor.connect('decide-policy',
self.on_browser_decide_policy)
self.text_vbox.pack_start(self.html_editor, True, True, 0)
self.html_editor.set_editable(False)
elif browser_cef.cef and use_cef:
class Preview(browser_cef.HtmlView):
def __init__(self, journal):
super().__init__()
self.journal = journal
self.internal = True
def show_day(self, new_day):
html = self.journal.convert(new_day.text, 'xhtml')
self.load_html(html)
def highlight(self, text):
pass
self.html_editor = Preview(self.journal)
self.text_vbox.pack_start(self.html_editor, True, True, 0)
else:
self.html_editor = mock.MagicMock()
self.html_editor.internal = False
preview_button = self.builder.get_object('preview_button')
preview_button.set_label(_('Preview in Browser'))
self.html_editor.hide()
self.preview_mode = False
# Let the edit_paned respect its childs size requests
self.edit_pane.child_set_property(self.text_vbox, 'shrink', False)
# Add InfoBar.
self.infobar = customwidgets.Info()
self.text_vbox.pack_start(self.infobar, False, False, 0)
self.text_vbox.reorder_child(self.infobar, 1)
# Add TemplateBar.
self.template_bar = customwidgets.TemplateBar()
self.text_vbox.pack_start(self.template_bar, False, False, 0)
self.text_vbox.reorder_child(self.template_bar, 1)
self.template_bar.hide()
self.load_values_from_config()
self.main_frame.show()
self.options_manager = OptionsManager(self)
self.export_assistant = ExportAssistant(self.journal)
self.export_assistant.set_transient_for(self.main_frame)
self.setup_clouds()
self.setup_search()
# Create an event->method dictionary and connect it to the widgets
dic = {
'on_back_one_day_button_clicked':
self.on_back_one_day_button_clicked,
'on_today_button_clicked': self.on_today_button_clicked,
'on_forward_one_day_button_clicked':
self.on_forward_one_day_button_clicked,
'on_preview_button_clicked': self.on_preview_button_clicked,
'on_edit_button_clicked': self.on_edit_button_clicked,
'on_main_frame_configure_event':
self.on_main_frame_configure_event,
'on_main_frame_window_state_event':
self.on_main_frame_window_state_event,
'on_add_new_entry_button_clicked':
self.on_add_new_entry_button_clicked,
'on_main_frame_delete_event': self.on_main_frame_delete_event,
# connect_signals can only be called once, it seems
# Otherwise RuntimeWarnings are raised: RuntimeWarning: missing handler '...'
}
self.builder.connect_signals(dic)
self.set_shortcuts()
self.setup_stats_dialog()
self.template_manager = templates.TemplateManager(self)
self.template_manager.make_empty_template_files()
self.setup_template_menu()
self.set_tooltips()
self.setup_tray_icon()
# Show/hide the "tags" panel on the right.
self.builder.get_object('annotations_pane').set_visible(
self.journal.config.read('showTagsPane'))
def contacts_window(self, widget):
import contacts
contacts.GUI(self)
def database_tools_activated(self, widget):
from db import database_tools
database_tools.GUI(self.db, False)
def new_purchase_order(self, widget=None):
import purchase_order_window
purchase_order_window.PurchaseOrderGUI(self)
def new_invoice(self, widget=None):
global invoice_window
if invoice_window == None:
import invoice_window
invoice_window.InvoiceGUI(self)
GObject.type_register(MainGUI)
def main_gui():
app = MainGUI()
Gtk.main()
if __name__ == "__main__":
sys.exit(main_gui())
def register(cls): """Register this class as a Gtk widget.""" GObject.type_register(SettingsDialog)
cr.set_source_rgb(1, 1, 1)
cr.paint()
for _, dic in self.state["players"].items():
cr.set_source_rgb(.8,.8,.8)
cr.rectangle(dic["x"], dic["y"],self.state["player_size"],self.state["player_size"])
cr.fill()
for pos, _ in self.state["fruits"].items():
pos = [int(x) for x in pos[1:-1].split(',')]
cr.set_source_rgb(0,1,0)
cr.rectangle(pos[0], pos[1],self.state["player_size"],self.state["player_size"])
cr.fill()
cr.set_source_rgb(0, 0, 0)
x, y = self.state["players"][self.id]["x"], self.state["players"][self.id]["y"]
cr.rectangle(x, y,self.state["player_size"],self.state["player_size"])
cr.fill()
def on_key_press_event(self, widget, event):
key = Gdk.keyval_name(event.keyval).upper()
if key == "ESCAPE":
self.window.get_application().on_quit(self.window)
else:
self.emit("move", key)
GObject.type_register(GameHandler)
GObject.signal_new("get_state", GameHandler, GObject.SIGNAL_ACTION, None, ())
GObject.signal_new("get_id", GameHandler, GObject.SIGNAL_ACTION, str, ())
GObject.signal_new("get_nick", GameHandler, GObject.SIGNAL_ACTION, str, ())
GObject.signal_new("move", GameHandler, GObject.SIGNAL_ACTION, None, (str,))
Gdk.KEY_Down: (0, +v_offset),
}
if event.keyval not in ops:
return False
offset = ops[event.keyval]
return self.__scroll(offset)
def __on_mouse_leave(self, _, event):
self.mouse_position = (0, 0)
def __apply_scrolling(self):
if (self.__scroll_origin == (0, 0) or self.mouse_position == (0, 0)):
# no scrolling for now
return
SCROLLING_REDUCTION_FACTOR = 2
scroll_x = self.mouse_position[0] - self.__scroll_origin[0]
scroll_y = self.mouse_position[1] - self.__scroll_origin[1]
scroll_x /= SCROLLING_REDUCTION_FACTOR
scroll_y /= SCROLLING_REDUCTION_FACTOR
scroll_x = max(min(scroll_x, 50), -50)
scroll_y = max(min(scroll_y, 50), -50)
return self.__scroll((scroll_x, scroll_y))
def __get_position(self):
return (int(self.hadjustment.get_value()),
int(self.vadjustment.get_value()))
position = property(__get_position)
GObject.type_register(Canvas)
# pylint: disable-msg=W0613
"""handle keypressed in Gtk.Entry"""
key = Gdk.keyval_name(event.keyval)
if key == 'Escape':
self._entry_to_label(None, None)
def _on_entry_buttonpress(self, widget, event):
"""handle button events in Gtk.Entry."""
# Block right clicks to avoid a deadlock.
# The correct solution here would be for _entry_to_label to trigger a
# deferred execution handler and for that handler to check if focus is
# in a GtkMenu. The problem being that we are unable to get a context
# menu for the GtkEntry.
if event.button == 3:
return True
def modify_fg(self, state, color):
"""Set the label foreground"""
self._label.modify_fg(state, color)
def is_custom(self):
"""Return whether or not we have a custom string set"""
return (self._custom)
def set_custom(self):
"""Set the customness of the string to True"""
self._custom = True
GObject.type_register(EditableLabel)
# $ export GST_PLUGIN_PATH=$GST_PLUGIN_PATH:$PWD/plugin:$PWD/examples/plugins
# $ GST_DEBUG=python:4 gst-launch-1.0 fakesrc num-buffers=10 ! identity_py ! fakesink
import gi
gi.require_version('GstBase', '1.0')
from gi.repository import Gst, GObject, GstBase
Gst.init(None)
#
# Simple Identity element created entirely in python
#
class Identity(GstBase.BaseTransform):
__gstmetadata__ = ('Identity Python','Transform', \
'Simple identity element written in python', 'Marianna S. Buschle')
__gsttemplates__ = (Gst.PadTemplate.new("src",
Gst.PadDirection.SRC,
Gst.PadPresence.ALWAYS,
Gst.Caps.new_any()),
Gst.PadTemplate.new("sink",
Gst.PadDirection.SINK,
Gst.PadPresence.ALWAYS,
Gst.Caps.new_any()))
def do_transform_ip(self, buffer):
Gst.info("timestamp(buffer):%s" % (Gst.TIME_ARGS(buffer.pts)))
return Gst.FlowReturn.OK
GObject.type_register(Identity)
__gstelementfactory__ = ("identity_py", Gst.Rank.NONE, Identity)
def __init__(self):
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(UI_FILE)
self.builder.connect_signals(self)
style_provider = Gtk.CssProvider()
with open('./custom.css', 'rb') as f:
css_data = f.read()
style_provider.load_from_data(css_data)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
language_manager = GtkSource.LanguageManager()
self.source_view = self.builder.get_object('gtksourceview1')
self.source_buffer = GtkSource.Buffer()
self.source_buffer.connect_after('changed', self.code_buffer_changed)
self.source_view.set_buffer(self.source_buffer)
self.source_buffer.set_language(
language_manager.get_language('arduino'))
completion = self.source_view.get_completion()
keyword_provider = GtkSource.CompletionWords.new('Keywords')
keyword_provider.register(self.source_buffer)
completion.add_provider(keyword_provider)
self.search_context = GtkSource.SearchContext.new(
self.source_buffer, None)
self.search_settings = self.search_context.get_settings()
self.search_settings.set_wrap_around(True)
self.search_mark = Gtk.TextMark()
self.window = self.builder.get_object('window')
self.statusbar = self.builder.get_object('statusbar1')
self.search_grid = self.builder.get_object('grid1')
self.terminal = Vte.Terminal()
ino_dir = subprocess.check_output(["which", "ino"])
self.ino = ino_dir.decode("utf-8").strip('\n')
self.terminal.set_scroll_on_output(True)
self.builder.get_object('scrolledwindow2').add(self.terminal)
self.builder.get_object('comboboxtext1').set_active(0)
self.window.show_all()
config = configparser.ConfigParser()
config.read('./preferences.ini')
self.path = config['paths']['toolpath']
if not os.path.exists(self.path):
self.show_message("Folder '%s' does not exist, \nwhich should "
"contain the Arduino toolchain" % (self.path, ))
path_string = "Arduino folder is %s" % self.path
self.builder.get_object('toolpath_directory_label').set_label(
path_string)
self.populate_sketch_menu()
GLib.idle_add(self.populate_examples)
self.passed_filename_check()
self.load_code_from_file()
sort = Gtk.SortType.ASCENDING
self.builder.get_object('function_store').set_sort_column_id(1, sort)
self.builder.get_object('radiomenuitem2').set_active(True)
raise
img = self.scan_session.images[-1]
self.emit('scan-done', img)
logger.info("Scan done")
del self.scan_session
def stop(self, will_resume=False):
self.can_run = False
self._stop_wait()
if not will_resume:
self.scan_session.scan.cancel()
del self.scan_session
GObject.type_register(JobScan)
class JobFactoryScan(JobFactory):
def __init__(self, scan_workflow):
JobFactory.__init__(self, "Scan")
self.scan_workflow = scan_workflow
def make(self, scan_session):
job = JobScan(self, next(self.id_generator), scan_session)
job.connect(
"scan-started",
lambda job: GLib.idle_add(self.scan_workflow.on_scan_start))
job.connect(
"scan-info", lambda job, x, y: GLib.idle_add(
self.scan_workflow.on_scan_info, x, y))
if not success:
raise RuntimeError("Could not map buffer")
else:
ctypes_region = ctypes.cast(
mapping.data, ctypes.POINTER(ctypes.c_byte * mapping.size))
raw_ptr = ctypes_region.contents
# create ctypes array from the raw pointer
ptr = (ctypes.c_byte * mapping.size).from_address(
ctypes.addressof(raw_ptr))
# cast array to uint32 to work with RGBA/BGRx data
# FIXME: hardcode caps to only allow 4-byte modes?
ptr = ctypes.cast(ptr, ctypes.POINTER(ctypes.c_uint8))
np_arr = np.ctypeslib.as_array(ptr, shape=(height, width, 4))
cv_img = cv2.imdecode(np_arr, cv2.IMREAD_UNCHANGED)
#self.__mxnet_detector__.process(cv_img, np_arr)
self.__mxnet_detector__.process(np_arr, np_arr)
if False:
cv2.rectangle(np_arr, (10, 10), (100, 100), (0, 255, 0), 4)
_libgst.gst_buffer_unmap(pbuffer, mapping)
mo.refcount = saved_refcount
return Gst.FlowReturn.OK
GObject.type_register(GstMxnetFace)
__gstelementfactory__ = ("gst_mxnet_face", Gst.Rank.NONE, GstMxnetFace)
ssid = model[iterator][0]
parent = model.iter_parent(iterator)
if parent and self.wifi_model.is_connected(model[parent][0], ssid):
return True
else:
return False
def connect_to_selection(self, passphrase):
model, iterator = self.get_selection().get_selected()
ssid = model[iterator][0]
parent = model.iter_parent(iterator)
if parent:
self.wifi_model.connect_to_ap(model[parent][0], ssid, passphrase)
GObject.type_register(NetworkManagerTreeView)
class NetworkManagerWidget(Gtk.Box):
__gtype_name__ = 'NetworkManagerWidget'
__gsignals__ = {
'connection': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
(GObject.TYPE_UINT, )),
'selection_changed':
(GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ()),
'pw_validated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
(GObject.TYPE_BOOLEAN, ))
}
def __init__(self):
Gtk.Box.__init__(self)
############################################################################
def _munge_raw_selection_to_wire(self, target, dtype, dformat, data):
if dformat == 32 and dtype in ("ATOM", "ATOM_PAIR"):
return "atoms", self.remote_targets(xatoms_to_strings(data))
return super()._munge_raw_selection_to_wire(target, dtype, dformat,
data)
def _munge_wire_selection_to_raw(self, encoding, dtype, dformat, data):
if encoding == "atoms":
return strings_to_xatoms(self.local_targets(data))
return super()._munge_wire_selection_to_raw(encoding, dtype, dformat,
data)
GObject.type_register(X11Clipboard)
class ClipboardProxy(ClipboardProxyCore, GObject.GObject):
__gsignals__ = {
"xpra-client-message-event": one_arg_signal,
"xpra-selection-request": one_arg_signal,
"xpra-selection-clear": one_arg_signal,
"xpra-property-notify-event": one_arg_signal,
"xpra-xfixes-selection-notify-event": one_arg_signal,
#
"send-clipboard-token": one_arg_signal,
"send-clipboard-request": n_arg_signal(2),
}
shell=shell,
name=_("Python Source"),
query_model=model)
self.source.setup()
group = RB.DisplayPageGroup.get_by_id("library")
shell.append_display_page(self.source, group)
def do_deactivate(self):
print "deactivating sample python plugin"
self.source.delete_thyself()
self.source = None
class PythonSource(RB.Source):
def __init__(self, **kwargs):
super(PythonSource, self).__init__(kwargs)
def setup(self):
shell = self.props.shell
songs = RB.EntryView(db=shell.props.db,
shell_player=shell.props.shell_player,
is_drag_source=False,
is_drag_dest=False)
songs.append_column(RB.EntryViewColumn.TITLE, True)
songs.set_model(self.props.query_model)
songs.show_all()
self.pack_start(songs, expand=True, fill=True, padding=0)
GObject.type_register(PythonSource)
class BaseText(Gtk.TextView):
__gtype_name__ = 'BaseText'
def __init__(self, parent):
super(BaseText, self).__init__()
self.buffer = self.get_buffer()
self._parent = parent
self.modify_font(Pango.FontDescription(parent.font))
self.set_editable(False)
self.texttag = self.buffer.create_tag(None)
GObject.type_register(BaseText)
class OffsetText(BaseText):
__gtype_name__ = 'OffsetText'
def __init__(self, parent):
super(OffsetText, self).__init__(parent)
self.off_len = 1
self.connect('button-press-event', self.__on_button_press)
self.connect('realize', self.__on_realize)
self.set_cursor_visible(False)
self.texttag.set_property('weight', Pango.Weight.BOLD)
def __on_button_press(self, widget, evt):
try:
logger.info("Looking for scan devices ...")
sys.stdout.flush()
devices = pyinsane2.get_devices()
for device in devices:
selected = (self.__selected_devid == device.name)
name = self.__get_dev_name(device)
logger.info("Device found: [%s] -> [%s]" % (name, device.name))
sys.stdout.flush()
self.emit('device-found', name, device.name, selected)
logger.info("End of scan for device")
finally:
self.emit("device-finding-end")
GObject.type_register(JobDeviceFinder)
class JobFactoryDeviceFinder(JobFactory):
def __init__(self, settings_win, selected_devid):
JobFactory.__init__(self, "DeviceFinder")
self.__selected_devid = selected_devid
self.__settings_win = settings_win
def make(self):
job = JobDeviceFinder(self, next(self.id_generator),
self.__selected_devid)
job.connect(
'device-finding-start', lambda job: GLib.idle_add(
self.__settings_win.on_device_finding_start_cb))
job.connect(
self._props = props
self._root = root_window
self._saved_event_mask = self._root.get_events()
self._root.set_events(self._saved_event_mask
| Gdk.EventMask.PROPERTY_CHANGE_MASK)
add_event_receiver(self._root, self)
def cleanup(self):
#this must be called from the UI thread!
remove_event_receiver(self._root, self)
self._root.set_events(self._saved_event_mask)
def __repr__(self): #pylint: disable=arguments-differ
return "XRootPropWatcher"
def do_xpra_property_notify_event(self, event):
log("XRootPropWatcher.do_xpra_property_notify_event(%s)", event)
if event.atom in self._props:
self.do_notify(str(event.atom))
def do_notify(self, prop):
log("XRootPropWatcher.do_notify(%s)", prop)
self.emit("root-prop-changed", prop)
def notify_all(self):
for prop in self._props:
self.do_notify(prop)
GObject.type_register(XRootPropWatcher)
