def draw(self, cr=None): ''' Draw the sprite (and label) ''' if cr is None: cr = self._sprites.cr if cr is None: # print 'sprite.draw: no Cairo context.' return for i, img in enumerate(self.cached_surfaces): cr.set_source_surface(img, self.rect[0] + self._dx[i], self.rect[1] + self._dy[i]) cr.rectangle(self.rect[0] + self._dx[i], self.rect[1] + self._dy[i], self.rect[2], self.rect[3]) cr.fill() if self._embedded_picture is not None: w = self.rect[2] h = self.rect[3] x = self.rect[0] + w / 2 - self._embedded_picture.get_width() / 2 y = self.rect[1] + h / 2 - self._embedded_picture.get_height() / 2 Gdk.cairo_set_source_pixbuf(cr, self._embedded_picture, x, y) cr.rectangle(x, y, w, h) cr.fill() if len(self.labels) > 0: self.draw_label(cr)
def draw_cb(self, widget, cairo_ctx): style = widget.get_style_context() bg_color = style.get_background_color(0) Gdk.cairo_set_source_rgba(cairo_ctx, bg_color) cairo_ctx.paint() return True
def main(): for opt in sys.argv[1:]: if opt in ('-h', '--help'): usage() sys.exit() elif opt in ('-d', '--dev'): config.ENABLE_INSPECTOR = True else: print "hotot: unrecognized option '%s'" % opt usage() sys.exit(1) try: import i18n except: from gettext import gettext as _ try: import prctl prctl.set_name('hotot') except: pass GObject.threads_init() config.loads(); agent.init_notify() app = Hotot() agent.app = app Gdk.threads_enter() Gtk.main() Gdk.threads_leave()
def __init__(self): super(TestVte, self).__init__() self.set_size_request(400, 400) self.connect("destroy", Gtk.main_quit) vbox = Gtk.VBox() self.vte = Vte.Terminal() vbox.add(self.vte) self.vte.set_colors(Gdk.color_parse('#000000'), Gdk.color_parse('#FFFFFF'), []) self.vte.set_emulation('xterm') sucess_, pid = self.vte.fork_command_full(Vte.PtyFlags.DEFAULT, os.environ["HOME"], ["/bin/bash"], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) button1 = Gtk.Button('Get text') button1.connect('clicked', self.__get_text_cb) vbox.add(button1) self.add(vbox) self.show_all()
def setImage(self, fileName): if not self.settingsManager.resizeImage: mpixbuf = Pixbuf.new_from_file(fileName) else: mpixbuf = Pixbuf.new_from_file_at_scale(fileName, self.iCurWidth, self.iCurHeight, True) self.currentFile = fileName Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT_IDLE, self.GtkSetImage, mpixbuf)
def draw(self, widget, context): name = self.imagename.strip("\n") #print name if name.lower().endswith("png") : self.image = cairo.ImageSurface.create_from_png(name) context.set_source_surface(self.image, self.space_left, self.space_top) context.paint() width = self.image.get_width() height = self.image.get_height() self.set_size_request(width, height) #print 'png image', width, height if name.lower().endswith("jpg") or name.lower().endswith("jpeg"): self.pb = GdkPixbuf.Pixbuf.new_from_file(name) Gdk.cairo_set_source_pixbuf(context, self.pb, self.space_left, self.space_top) context.paint() self.dim = GdkPixbuf.Pixbuf.get_file_info(name) self.set_size_request(self.dim.width, self.dim.height) #print 'jpg image' if self.draw_enum == self.ENUM_BOXES: context.set_line_width(1) context.set_source_rgb(1, 0, 0) self.box_list(context, self.boxlist_red) context.set_source_rgb(0, 1, 0) self.box_list(context, self.boxlist_green) context.set_source_rgb(0, 0, 1) self.box_list(context, self.boxlist_blue) return False elif self.draw_enum == self.ENUM_GRADIENT_RGB: self.gradient_rgb(context, widget) pass
def __init__(self, activity_path, default): super(XoIcon, self).__init__(orientation=Gtk.Orientation.VERTICAL) self.icons = XoIcons(default) self.home = XoHome(self.icons.get_icon(), activity_path) self.icons.connect('icon_changed', self.home.update) self.home_box = Gtk.EventBox() self.home_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) self.home_box.add(self.home) self.icons_box = Gtk.EventBox() self.icons_box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) self.icons_box.add(self.icons) self.icons_scroll = Gtk.ScrolledWindow() self.icons_scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.icons_scroll.add_with_viewport(self.icons_box) self.icons_scroll.set_size_request(-1, style.MEDIUM_ICON_SIZE + 30) self.pack_start(self.home_box, True, True, 0) self.pack_start(Gtk.HSeparator(), False, False, 0) self.pack_start(self.icons_scroll, False, False, 0) self.show_all()
def printpm(self, widget, pm): Gdk.threads_enter() endoftext = self.pmbuffer1.get_end_iter() self.pmbuffer1.insert(endoftext,pm+"\n") mark = self.pmbuffer1.get_insert() self.pm1.scroll_mark_onscreen(self.pmbuffer1.get_insert()) Gdk.threads_leave()
def printjl(self, widget, jl): Gdk.threads_enter() endoftext = self.jlbuffer1.get_end_iter() self.jlbuffer1.insert(endoftext,jl+"\n") mark = self.jlbuffer1.get_insert() self.jl1.scroll_mark_onscreen(self.jlbuffer1.get_insert()) Gdk.threads_leave()
def _load_pulse_bar(): Gdk.threads_enter() try: persistance.load_dialog.progress_bar.pulse() except: pass Gdk.threads_leave()
def printmsg(self, widget, msg): Gdk.threads_enter() endoftext = self.roombuffer1.get_end_iter() self.roombuffer1.insert(endoftext,msg+"\n") mark = self.roombuffer1.get_insert() self.room1.scroll_mark_onscreen(self.roombuffer1.get_insert()) Gdk.threads_leave()
def traceTreeview_drag_motion_cb(self, treeView, context, x, y, time): """This callbacks helps managing highlight of the dest treeview when draging data onto it. Here, we highlight treeView only when target is a 'Session' and that it's not a new item (but rather, data are droped into it).""" dropInfo = treeView.get_dest_row_at_pos(x, y) if dropInfo is not None: (path, position) = dropInfo model = treeView.get_model() # We only allow to drop data *into* a row (and not before # and after) and to drop data in a session, items that # have a parent. if model[path].get_parent() is not None: if position in (Gtk.TreeViewDropPosition.INTO_OR_BEFORE, Gtk.TreeViewDropPosition.INTO_OR_AFTER): treeView.drag_highlight() Gdk.drag_status(context, 0, time) return False else: # We are on an ImportedTrace item, we try to expand # it. treeView.expand_to_path(path) treeView.drag_unhighlight() Gdk.drag_status(context, 0, time) return True
def _error_stop(self, dialog, ticker): editorstate.project_is_loading = False Gdk.threads_enter() updater.set_info_icon(None) dialog.destroy() Gdk.threads_leave() ticker.stop_ticker()
def onKeyPress (self, widget, event): if event.keyval in map(Gdk.keyval_from_name,("Return", "KP_Enter")): if not event.get_state() & Gdk.ModifierType.CONTROL_MASK: buffer = self.writeView.get_buffer() self.connection.client.run_command(buffer.props.text, show_reply=True) self.emit("messageTyped", buffer.props.text) self.addMessage(buffer.props.text, True) self.history.append(buffer.props.text) buffer.props.text = "" self.pos = len(self.history) return True elif event.keyval == Gdk.keyval_from_name("Up"): if self.pos > 0: buffer = self.writeView.get_buffer() self.pos -= 1 buffer.props.text = self.history[self.pos] widget.grab_focus() return True elif event.keyval == Gdk.keyval_from_name("Down"): buffer = self.writeView.get_buffer() if self.pos == len(self.history)-1: self.pos += 1 buffer.props.text = "" elif self.pos < len(self.history): self.pos += 1 buffer.props.text = self.history[self.pos] widget.grab_focus() return True
def emit(self, record): """ Function inserts log messages to list_view """ msg = record.getMessage() list_store = self.list_view.get_model() Gdk.threads_enter() if msg: # Underline URLs in the record message msg = replace_markup_chars(record.getMessage()) record.msg = URL_FINDER.sub(r'<u>\1</u>', msg) self.parent.debug_logs['logs'].append(record) # During execution if level is bigger then DEBUG # then GUI shows the message. event_type = getattr(record, 'event_type', '') if event_type: if event_type == 'dep_installation_start': switch_cursor(Gdk.CursorType.WATCH, self.parent.run_window) list_store.append([format_entry(record)]) if event_type == 'dep_installation_end': switch_cursor(Gdk.CursorType.ARROW, self.parent.run_window) if not self.parent.debugging: # We will show only INFO messages and messages who have no dep_ event_type if int(record.levelno) > 10: if event_type == "dep_check" or event_type == "dep_found": list_store.append([format_entry(record)]) elif not event_type.startswith("dep_"): list_store.append([format_entry(record, colorize=True)]) if self.parent.debugging: if event_type != "cmd_retcode": list_store.append([format_entry(record, show_level=True, colorize=True)]) Gdk.threads_leave()
def do_draw (self, cr): if not self.ensure_merged_pixbuf (): return False if self.merged_pixbuf.props.width != self.size: draw_pb = self.merged_pixbuf.scale_simple (self.size, self.size, GdkPixbuf.InterpType.NEAREST) else: draw_pb = self.merged_pixbuf # center the image if we're wider than we are tall pad = (self.get_allocation().width - self.size) / 2 left = pad right = pad + self.size top = 0 bottom = self.size if right > left and bottom > top: Gdk.cairo_set_source_pixbuf(cr, draw_pb, pad, 0) cr.rectangle(left, top, right - left, bottom - top) cr.fill() if self.anim: x, y, w, h = self.anim_rect () Gdk.cairo_set_source_pixbuf(cr, self.anim, max(0, x), max(0, y)) cr.rectangle(max(0, x), max(0, y), w, h) cr.fill() return False
def __init__(self): Gtk.Notebook.__init__(self) self.accion_instrospeccion = [] self.copy_cut = [] self.estructura_proyecto = Estructura_Proyecto() self.introspeccion = Introspeccion() scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add(self.introspeccion) label = Gtk.Label("Introspección") label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#000000')) self.append_page(scroll, label) scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scroll.add(self.estructura_proyecto) label = Gtk.Label("Proyecto") label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('#000000')) self.append_page(scroll, label) self.show_all() self.introspeccion.connect("new_select", self.__re_emit_new_select) # FIXME: La Interfaz se cuelga #self.estructura_proyecto.connect("button-press-event", # self.__click_derecho_en_estructura) self.estructura_proyecto.connect("open", self.__re_emit_open)
def render_grid(self, cr): context = self.get_style_context() context.save() context.add_class("grid-lines") bg = context.get_border_color(self.get_state_flags()) context.restore() cr.save() Gdk.cairo_set_source_rgba(cr, bg) cr.set_line_width(1) a = self.get_allocation() w = a.width / self.n_columns for i in range(self.n_columns): cr.move_to(i * w + 0.5, 0) cr.rel_line_to(0, a.height - 3) cr.stroke() w = a.height / self.n_rows for i in range(self.n_rows): cr.move_to(2, i * w + 0.5) cr.rel_line_to(a.width - 4, 0) cr.stroke() cr.restore()
def _sync_message_cb(self, bus, mess): if mess.type == Gst.MessageType.ELEMENT: if mess.has_name('prepare-window-handle'): sink = mess.src # We need to set force-aspect-ratio and handle-expose properties # to the real videosink. Depending on how the pipeline was # configured and the version of gstreamer, the source of this # message could be the videosink itself or playsink. If it's # playsink, we need to get the videosink that is inside it. # Even better, the sink inside playsink could be autovideosink, # which isn't a real sink, therefore we get the sink inside it. try: if sink.get_factory().get_name() == 'playsink': realsink = sink.get_property('video-sink') else: realsink = sink if realsink.get_factory().get_name() == 'autovideosink': realsink = realsink.iterate_sinks().next()[1] realsink.set_property('force-aspect-ratio', True) realsink.set_property("handle-expose", True) finally: Gdk.threads_enter() sink.set_window_handle(self.preview_video.window_xid) sink.expose() Gdk.threads_leave() return Gst.BusSyncReply.PASS
def scan_source(self, source, artist, title): Gdk.threads_enter() self.textbuffer.set_text("searching lyrics...") Gdk.threads_leave() newthread = Thread(target=self._scan_source_thread, args=(source, artist, title)) newthread.start()
def add_border(pixbuf, color, round=False, width=1): """Add a border to the pixbuf and round of the edges. color is a Gdk.RGBA The resulting pixbuf will be width * 2px higher and wider. Can not fail. """ w, h = pixbuf.get_width(), pixbuf.get_height() w += width * 2 h += width * 2 surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, w, h) ctx = cairo.Context(surface) pi = math.pi r = min(w, h) / 10.0 if round else 0 ctx.new_path() ctx.arc(w - r, r, r, -pi / 2, 0) ctx.arc(w - r, h - r, r, 0, pi / 2) ctx.arc(r, h - r, r, pi / 2, pi) ctx.arc(r, r, r, pi, pi * 3 / 2) ctx.close_path() Gdk.cairo_set_source_pixbuf(ctx, pixbuf, width, width) ctx.clip_preserve() ctx.paint() ctx.set_source_rgba(color.red, color.green, color.blue, color.alpha) ctx.set_line_width(width * 2) ctx.stroke() return Gdk.pixbuf_get_from_surface(surface, 0, 0, w, h)
def initialize_modules(): """ Initialize the modules. This has to be done in a specific order otherwise the app crashes on some systems. """ from gi.repository import Gdk Gdk.init([]) from gi.repository import GtkClutter GtkClutter.init([]) import gi if not gi.version_info >= (3, 11): from gi.repository import GObject GObject.threads_init() from gi.repository import Gst Gst.init(None) from gi.repository import GES GES.init() # This is required because of: # https://bugzilla.gnome.org/show_bug.cgi?id=656314 from gi.repository import GdkX11 GdkX11 # noop
def _draw_image(self, context, pixbuf, rect, rgba): Gdk.cairo_set_source_pixbuf(context, pixbuf, rect.x, rect.y) pattern = context.get_source() context.rectangle(*rect) context.set_source_rgba(*rgba) context.mask(pattern) context.new_path()
def devassistant_start(self): #logger_gui.info("Thread run") path = self.parent.assistant_class.get_selected_subassistant_path(**self.parent.kwargs) self.pr = path_runner.PathRunner(path) try: self.pr.run(**self.parent.kwargs) Gdk.threads_enter() if not self.project_canceled: self.info_label.set_label('<span color="#008000">Done</span>') self.cancel_btn.set_label("Close") else: self.cancel_btn.set_sensitive(True) self.info_label.set_label('<span color="#FF0000">Failed</span>') self.back_btn.show() self.debug_btn.set_sensitive(True) Gdk.threads_leave() except exceptions.ClException as cl: self.debug_btn.set_sensitive(True) self.cancel_btn.set_label("Close") self.back_btn.show() self.info_label.set_label('<span color="#FF0000">Failed: {0}</span>'.format(cl.message)) except exceptions.ExecutionException as ee: self.debug_btn.set_sensitive(True) self.cancel_btn.set_label("Close") self.back_btn.show() self.info_label.set_label('<span color="#FF0000">Failed: {0}</span>'.format((ee.message[:50]+'...') if len(ee.message) > 50 else ee.message)) except IOError as ie: self.debug_btn.set_sensitive(True) self.cancel_btn.set_label("Close") self.back_btn.show() self.info_label.set_label('<span color="#FF0000">Failed: {0}</span>'.format((ie.message[:50]+'...') if len(ie.message) > 50 else ie.message))
def on_vte_key_press(self, term, event): modifiers = event.state & Gtk.accelerator_get_default_mod_mask() if event.keyval in (Gdk.KEY_Tab, Gdk.KEY_KP_Tab, Gdk.KEY_ISO_Left_Tab): if modifiers == Gdk.ModifierType.CONTROL_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_FORWARD) return True elif modifiers == Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK: self.get_toplevel().child_focus(Gtk.DirectionType.TAB_BACKWARD) return True for name in self._accels: path = self._accel_base + '/' + name entry = Gtk.AccelMap.lookup_entry(path) if entry and entry[0] and entry[1].accel_key == event.keyval and entry[1].accel_mods == modifiers: self._accels[name][2]() return True keyval_name = Gdk.keyval_name(Gdk.keyval_to_upper(event.keyval)) # Special case some Vte.Terminal shortcuts # so the global shortcuts do not override them if modifiers == Gdk.ModifierType.CONTROL_MASK and keyval_name in 'ACDEHKLRTUWZ': return False if modifiers == Gdk.ModifierType.MOD1_MASK and keyval_name in 'BF': return False return Gtk.accel_groups_activate(self.get_toplevel(), event.keyval, modifiers)
def pbar_pulse(): if(not self.should_pulse): return False Gdk.threads_enter() self.progress.pulse() Gdk.threads_leave() return self.should_pulse
def background_thread(path,mail): global win time.sleep(1) old_mail = [] while (not win.shutDown): new_mail = split_mail(path,mail) time.sleep(1) if len(new_mail) > len(old_mail): to_screen = [] for i in range(len(old_mail),len(old_mail)+(len(new_mail) - len(old_mail))): if new_mail[i] != "\n": Gdk.threads_enter() win.write_text("\n"+new_mail[i]) #apply_com(new[i]) win.set_keep_above(True) win.present() Gdk.threads_leave() old_mail = new_mail
def ControlsKeyPress(self, widget, event, mapping): modkeys = ["Control_R", "Shift_R", "Alt_R", "Control_L", "Super_L", "Super_R", "Alt_L", "Shift_L", "Meta_L", "Meta_R"] masks = {'GDK_SHIFT_MASK':'Shift', 'GDK_CONTROL_MASK':'Control', 'GDK_SUPER_MASK':'Super', 'GDK_MOD1_MASK':'Alt' } if not Gdk.keyval_name(event.get_keyval()[1]) in modkeys: modifiers = [] for mod in event.get_state().value_names: try: modifiers.append(masks[mod]) except KeyError: pass keystring = "" for mod in modifiers: keystring += mod + "+" try: keyname = chr(event.get_keyval()[1]).upper() if keyname == " ": keyname = "Space" except ValueError: keyname = Gdk.keyval_name(Gdk.keyval_to_upper(event.get_keyval()[1])) keystring += keyname mapping.set("Mapping",keystring) widget.destroy() self.queue_draw()
def destroy(self): # Wait for the thread to terminate Gdk.threads_leave() FreeStationApp2._self = None from signal import SIGTERM self.finished = True
def _draw_badge(self, context, size, sensitive, widget): theme = Gtk.IconTheme.get_default() badge_info = theme.lookup_icon(self.badge_name, int(size), 0) if badge_info: badge_file_name = badge_info.get_filename() if badge_file_name.endswith('.svg'): handle = self._loader.load(badge_file_name, {}, self.cache) icon_width = handle.props.width icon_height = handle.props.height pixbuf = handle.get_pixbuf() else: pixbuf = GdkPixbuf.Pixbuf.new_from_file(badge_file_name) icon_width = pixbuf.get_width() icon_height = pixbuf.get_height() context.scale(float(size) / icon_width, float(size) / icon_height) if not sensitive: pixbuf = self._get_insensitive_pixbuf(pixbuf, widget) Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0) context.paint()
# GTK libraries # #------------------------------------------------------------------------- from gi.repository import Gtk from gi.repository import Gdk #------------------------------------------------------------------------- # # Gramps classes # #------------------------------------------------------------------------- from ...widgets import SimpleButton from .grampstab import GrampsTab from gramps.gen.errors import WindowActiveError _KP_ENTER = Gdk.keyval_from_name("KP_Enter") _RETURN = Gdk.keyval_from_name("Return") _DEL = Gdk.keyval_from_name("Delete") _ADD = Gdk.keyval_from_name("Insert") _OPEN = Gdk.keyval_from_name("o") _LEFT = Gdk.keyval_from_name("Left") _RIGHT = Gdk.keyval_from_name("Right") #------------------------------------------------------------------------- # # Classes # #------------------------------------------------------------------------- class ButtonTab(GrampsTab): """
def checkGetLayerAt(self, heights, preferred, past_middle_when_adjacent, expectations): timeline_container = common.create_timeline_container() timeline = timeline_container.timeline # Allocate layers y = 0 for priority, height in enumerate(heights): ges_layer = timeline.create_layer(priority=priority) rect = Gdk.Rectangle() rect.y = y rect.height = height ges_layer.ui.set_allocation(rect) y += height + SEPARATOR_HEIGHT ges_layers = timeline.ges_timeline.get_layers() if preferred is None: preferred_ges_layer = None else: preferred_ges_layer = ges_layers[preferred] # The heights of the layers. h = [ges_layer.ui.get_allocation().height for ges_layer in ges_layers] s = SEPARATOR_HEIGHT def assertLayerAt(ges_layer, y): result = timeline._get_layer_at( int(y), prefer_ges_layer=preferred_ges_layer, past_middle_when_adjacent=past_middle_when_adjacent) self.assertEqual( ges_layer, result[0], "Expected %d, got %d at %d" % (ges_layers.index(ges_layer), ges_layers.index(result[0]), y)) # y on the top layer. assertLayerAt(ges_layers[expectations[0]], 0) assertLayerAt(ges_layers[expectations[1]], h[0] / 2 - 1) assertLayerAt(ges_layers[expectations[2]], h[0] / 2) assertLayerAt(ges_layers[expectations[3]], h[0] - 1) # y on the separator. assertLayerAt(ges_layers[expectations[4]], h[0]) assertLayerAt(ges_layers[expectations[5]], h[0] + s - 1) # y on the middle layer. assertLayerAt(ges_layers[expectations[6]], h[0] + s) assertLayerAt(ges_layers[expectations[7]], h[0] + s + h[1] / 2 - 1) assertLayerAt(ges_layers[expectations[8]], h[0] + s + h[1] / 2) assertLayerAt(ges_layers[expectations[9]], h[0] + s + h[1] - 1) # y on the separator. assertLayerAt(ges_layers[expectations[10]], h[0] + s + h[1]) assertLayerAt(ges_layers[expectations[11]], h[0] + s + h[1] + s - 1) # y on the bottom layer. assertLayerAt(ges_layers[expectations[12]], h[0] + s + h[1] + s) assertLayerAt(ges_layers[expectations[13]], h[0] + s + h[1] + s + h[2] / 2 - 1) assertLayerAt(ges_layers[expectations[14]], h[0] + s + h[1] + s + h[2] / 2) assertLayerAt(ges_layers[expectations[15]], h[0] + s + h[1] + s + h[2] - 1)
def get_eventbox(self, widget, color): box = Gtk.EventBox() box.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(color)) box.add(widget) return box
def set_header_cursor(self, eb, *a): """ Sets cursor over top part of infobox to hand """ eb.get_window().set_cursor(Gdk.Cursor(Gdk.CursorType.HAND1))
def reset_terminal_bg_color(self, _widget, terminal): bg_color = Gdk.RGBA() bg_color.parse(terminal.config['background_color']) terminal.bgcolor = bg_color
def get_inactive_color(self, transmit_color): return Gdk.Color(transmit_color.red * self.ratio, transmit_color.green * self.ratio, transmit_color.blue * self.ratio)
def is_terminal_default_bg(self, terminal): bg_color = Gdk.RGBA() bg_color.parse(terminal.config['background_color']) return terminal.bgcolor.equal(bg_color)
def make_transparent(widget): rgba = Gdk.RGBA() rgba.parse('rgba(0, 0, 0, 0)') widget.override_background_color(Gtk.StateFlags.NORMAL, rgba)
def ungrab_keyboard(*_args): v = Gdk.keyboard_ungrab(0) action_label.set_text("keyboard_ungrab(0)=%s" % GRAB_STATUS_STRING.get(v, v))
def get_cairo_colour(self, col): p = Gdk.color_parse(col) r = p.red / 65536.0 g = p.green / 65536.0 b = p.blue / 65536.0 return r, g, b
def ungrab_pointer(*_args): v = Gdk.pointer_ungrab(0) action_label.set_text("pointer_ungrab(0)=%s" % GRAB_STATUS_STRING.get(v, v)) window.unmaximize()
# Python classes # #------------------------------------------------------------------------- from gramps.gen.const import GRAMPS_LOCALE as glocale _ = glocale.translation.sgettext #------------------------------------------------------------------------- # # GTK classes # #------------------------------------------------------------------------- from gi.repository import Gtk from gi.repository import Gdk from gi.repository import GObject from gi.repository import Pango _TAB = Gdk.keyval_from_name("Tab") _ENTER = Gdk.keyval_from_name("Enter") #------------------------------------------------------------------------- # # GRAMPS classes # #------------------------------------------------------------------------- from .surnamemodel import SurnameModel from .embeddedlist import EmbeddedList, TEXT_COL, MARKUP_COL, ICON_COL from ...ddtargets import DdTargets from gramps.gen.lib import Surname, NameOriginType from gramps.gen.constfunc import conv_to_unicode #-------------------------------------------------------------------------
def on_window_key_press(window, event): log.debug('on_window_key_press: %s %s' % (window.get_title(), event)) # Tabbing related shortcuts if not gamewidget.getheadbook(): pagecount = 0 else: pagecount = gamewidget.getheadbook().get_n_pages() if pagecount > 1: if event.get_state() & Gdk.ModifierType.CONTROL_MASK: page_num = gamewidget.getheadbook().get_current_page() # Move selected if event.get_state() & Gdk.ModifierType.SHIFT_MASK: child = gamewidget.getheadbook().get_nth_page(page_num) if event.keyval == Gdk.KEY_Page_Up: gamewidget.getheadbook().reorder_child( child, (page_num - 1) % pagecount) return True elif event.keyval == Gdk.KEY_Page_Down: gamewidget.getheadbook().reorder_child( child, (page_num + 1) % pagecount) return True # Change selected else: if event.keyval == Gdk.KEY_Page_Up: gamewidget.getheadbook().set_current_page( (page_num - 1) % pagecount) return True elif event.keyval == Gdk.KEY_Page_Down: gamewidget.getheadbook().set_current_page( (page_num + 1) % pagecount) return True gmwidg = gamewidget.cur_gmwidg() if gmwidg is not None: for panel in gmwidg.panels: focused = panel.get_focus_child() # Do nothing in chat panel if focused is not None and isinstance(focused, Gtk.Entry): return False # Navigate on boardview with arrow keys if event.keyval in leftkeys: if event.get_state() & Gdk.ModifierType.CONTROL_MASK: gmwidg.board.view.backToMainLine() return True else: gmwidg.board.view.showPrev() return True elif event.keyval in rightkeys: gmwidg.board.view.showNext() return True elif event.keyval in upkeys: gmwidg.board.view.showPrev(step=2) return True elif event.keyval in downkeys: gmwidg.board.view.showNext(step=2) return True elif event.keyval in homekeys: gmwidg.board.view.showFirst() return True elif event.keyval in endkeys: gmwidg.board.view.showLast() return True if (not event.get_state() & Gdk.ModifierType.CONTROL_MASK) and \ (not event.get_state() & Gdk.ModifierType.MOD1_MASK) and \ (event.keyval != Gdk.KEY_Escape) and \ (event.keyval not in functionkeys): # Enter moves with keyboard board_control = gmwidg.board keyname = Gdk.keyval_name(event.keyval) board_control.key_pressed(keyname) gmwidg.status(board_control.keybuffer) return True return False
def grab_keyboard(*_args): v = Gdk.keyboard_grab(window.get_window(), True, 0) action_label.set_text("keyboard_grab(..)=%s" % GRAB_STATUS_STRING.get(v, v)) GLib.timeout_add(10*1000, Gdk.keyboard_ungrab, 0)
def do_begin_print(self, op, print_ctx): op.set_n_pages(1) Gdk.cairo_set_source_pixbuf(print_ctx.get_cairo_context(), self.main_pixbuf, 0, 0) print_ctx.get_cairo_context().paint()
def keyevent_info(event): keyval = event.keyval keycode = event.hardware_keycode keyname = Gdk.keyval_name(keyval) return "%i:%s" % (keycode, keyname)
def use_stable_pixbuf(self): # print('image/384: use_stable_pixbuf') self.surface = Gdk.cairo_surface_create_from_pixbuf( self.main_pixbuf, 0, None)
from pychess.widgets.TaskerManager import NewGameTasker from pychess.widgets.TaskerManager import InternetGameTasker from pychess.Players.engineNest import discoverer from pychess.Savers import chesspastebin from pychess.ic import ICLogon # from pychess.Database.gamelist import GameList from pychess import VERSION, VERSION_NAME leftkeys = list(map(Gdk.keyval_from_name, ("Left", "KP_Left"))) rightkeys = list(map(Gdk.keyval_from_name, ("Right", "KP_Right"))) upkeys = list(map(Gdk.keyval_from_name, ("Up", "KP_Up"))) downkeys = list(map(Gdk.keyval_from_name, ("Down", "KP_Down"))) homekeys = list(map(Gdk.keyval_from_name, ("Home", "KP_Home"))) endkeys = list(map(Gdk.keyval_from_name, ("End", "KP_End"))) functionkeys = [ Gdk.keyval_from_name(k) for k in ("F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11") ] # gameDic - containing the gamewidget:gamemodel of all open games gameDic = {} recentManager = Gtk.RecentManager.get_default() TARGET_TYPE_URI_LIST = 0xbadbeef DRAG_ACTION = Gdk.DragAction.COPY DRAG_RESTRICT = Gtk.TargetFlags.OTHER_APP DND_LIST = [ Gtk.TargetEntry.new("text/uri-list", DRAG_RESTRICT, TARGET_TYPE_URI_LIST) ]
def do_render(self, cr, widget, background_area, cell_area, flags): if not self.visible: return button_width = self.button_width() state = self.get_state(widget, flags) context = widget.get_style_context() context.save() context.add_class('button') xpad, ypad = self.get_padding() x = cell_area.x + xpad y = cell_area.y + ypad w = cell_area.width - 2 * xpad h = cell_area.height - 2 * ypad padding = context.get_padding(state) layout = widget.create_pango_layout(self.size) lwidth = w - button_width - padding.left - padding.right if lwidth < 0: lwidth = 0 layout.set_width(lwidth * Pango.SCALE) layout.set_ellipsize(Pango.EllipsizeMode.END) layout.set_wrap(Pango.WrapMode.CHAR) layout.set_alignment(Pango.Alignment.RIGHT) if lwidth > 0: lw, lh = layout.get_size() # Can not use get_pixel_extents lw /= Pango.SCALE lh /= Pango.SCALE lx = x + padding.left if self.buttons and self.buttons[0] == 'open': pxbf_width = self.images['open'][2] lx += pxbf_width + 2 * BUTTON_BORDER + BUTTON_SPACING ly = y + padding.top + 0.5 * (h - padding.top - padding.bottom - lh) Gtk.render_layout(context, cr, lx, ly, layout) for index, button_name in enumerate(self.buttons): pxbf_sens, pxbf_insens, pxbf_width, pxbf_height = \ self.images[button_name] if (not self.editable and button_name in {'select', 'clear'} or not self.size and button_name in {'open', 'save'}): pixbuf = pxbf_insens else: pixbuf = pxbf_sens if index == 0 and button_name == 'open': x_offset = 0 else: x_offset = (w - button_width + (pxbf_width + (2 * BUTTON_BORDER) + BUTTON_SPACING) * index) if x_offset < 0: continue bx = cell_area.x + x_offset by = cell_area.y bw = pxbf_width + (2 * BUTTON_BORDER) Gtk.render_background(context, cr, bx, by, bw, h) Gtk.render_frame(context, cr, bx, by, bw, h) Gdk.cairo_set_source_pixbuf(cr, pixbuf, bx + BUTTON_BORDER, by + (h - pxbf_height) / 2) cr.paint() context.restore()
def do_draw_page(self, op, print_ctx, page_num): # XXX TODO if it's too big for one page ? Gdk.cairo_set_source_pixbuf(print_ctx.get_cairo_context(), self.main_pixbuf, 0, 0) print_ctx.get_cairo_context().paint()
def color_activated(dialog): color = dialog.get_rgba() # deprecated self.txtTotaleParziale.override_color(Gtk.StateFlags.NORMAL, Gdk.RGBA(*color))
def set_surface_as_stable_pixbuf(self): # print('image/379: set_surface_as_stable_pixbuf') self.main_pixbuf = Gdk.pixbuf_get_from_surface(self.surface, 0, 0, \ self.surface.get_width(), self.surface.get_height())
def a_delete_event(): ev = Gdk.Event() ev.type = Gdk.EventType.KEY_PRESS ev.keyval, accel_mod = Gtk.accelerator_parse("Delete") ev.state = Gtk.accelerator_get_default_mod_mask() & accel_mod return ev
from galicaster.classui import message from galicaster.classui import get_ui_path, get_image_path from galicaster.utils import readable from galicaster.utils.resize import relabel, resize_button from galicaster.utils.i18n import _ from galicaster.recorder.service import STATUSES from galicaster.recorder.service import INIT_STATUS from galicaster.recorder.service import PREVIEW_STATUS from galicaster.recorder.service import RECORDING_STATUS from galicaster.recorder.service import PAUSED_STATUS from galicaster.recorder.service import ERROR_STATUS from collections import OrderedDict Gdk.threads_init() logger = context.get_logger() status_label_changed = True status_label_blink = True signalized = False # No-op function for i18n def N_(string): return string TIME_BLINK_START = 20 TIME_BLINK_STOP = 20 TIME_RED_START = 50
def on_settings_file_changed(self): color = Gdk.RGBA() Gdk.RGBA.parse(color, self.get_val()) self.chooser.handler_block(self.handler) self.chooser.set_rgba(color) self.chooser.handler_unblock(self.handler)
def on_action_quit_activate(self, action): """Close the application by closing the main window""" event = Gdk.Event() event.key.type = Gdk.EventType.DELETE self.ui.win_main.event(event)
def __init__(self, task, parent=None): Gtk.Dialog.__init__(self, parent=parent) self.task = task self.finished = False # Progress goes directly to this window task.client_progress_cb = self.window_client_progress_cb # finished callbacks route thru the installer # but we want to see them in this window also. self.final_finished_cb = task.client_finished_cb task.client_finished_cb = self.window_client_finished_cb self.pulse_timer = 0 self.active_task_state = task.progress_state self.real_progress_text = None self.num_dots = 0 # Setup the dialog self.set_border_width(6) self.set_resizable(False) self.get_content_area().set_spacing(6) # Setup the cancel button self.button = Gtk.Button.new_from_stock(Gtk.STOCK_CANCEL) self.button.set_use_stock(True) self.get_action_area().pack_start(self.button, False, False, 0) self.button.connect("clicked", self.on_button_clicked) self.button.show() # labels and progressbar hbox = Gtk.HBox() hbox.set_spacing(12) hbox.set_border_width(6) vbox = Gtk.VBox() vbox.set_spacing(12) self.phase_label = Gtk.Label() vbox.pack_start(self.phase_label, False, False, 0) self.phase_label.set_halign(Gtk.Align.START) vbox_progress = Gtk.VBox() vbox_progress.set_spacing(6) self.progress = Gtk.ProgressBar() vbox_progress.pack_start(self.progress, False, True, 0) self.progress_label = Gtk.Label() vbox_progress.pack_start(self.progress_label, False, False, 0) self.progress_label.set_halign(Gtk.Align.START) self.progress_label.set_line_wrap(True) self.progress_label.set_max_width_chars(60) vbox.pack_start(vbox_progress, False, True, 0) hbox.pack_start(vbox, True, True, 0) self.get_content_area().pack_start(hbox, True, True, 0) self.set_title(_("Flatpak Progress")) XApp.set_window_icon_name(self, "system-software-installer") hbox.show_all() self.realize() self.progress.set_size_request(350, -1) functions = Gdk.WMFunction.MOVE | Gdk.WMFunction.RESIZE try: self.get_window().set_functions(functions) except TypeError: # workaround for older and broken GTK typelibs self.get_window().set_functions(Gdk.WMFunction(functions)) self.update_labels() # catch ESC and behave as if cancel was clicked self.connect("delete-event", self._on_dialog_delete_event)
sublabel=err.message, expander=[ _('_Details'), _("There was an error launching the url: %s" % url) ]) # Set up custom STOCK items and ICONS! icon_factory = Gtk.IconFactory() def add_icon(file_name, stock_id, label=None, modifier=0, keyval=0): pb = GdkPixbuf.Pixbuf.new_from_file(file_name) iconset = Gtk.IconSet(pb) icon_factory.add(stock_id, iconset) icon_factory.add_default() # TODO: fix adding icons return Gtk.stock_add([(stock_id, label, modifier, keyval, "")]) for filename, stock_id, label, modifier, keyval in [ ('AddToShoppingList.png', 'add-to-shopping-list', _('Add to _Shopping List'), Gdk.ModifierType.CONTROL_MASK, Gdk.keyval_from_name('l')), ('reccard.png', 'recipe-card', None, 0, 0), ('reccard_edit.png', 'edit-recipe-card', None, 0, 0), ]: add_icon(os.path.join(imagedir, filename), stock_id, label, modifier, keyval)
class GeneralPreferences(): GENERAL_PREFERENCES_UI = os.path.join(UI_DIR, "general_preferences.ui") INVALID_COLOR = Gdk.Color(50000, 0, 0) def __init__(self, req, app): self.req = req self.config = self.req.get_config('browser') builder = Gtk.Builder() builder.add_from_file(self.GENERAL_PREFERENCES_UI) self.ui_widget = builder.get_object("general_pref_window") self.preview_button = builder.get_object("preview_button") self.bg_color_button = builder.get_object("bg_color_button") self.font_button = builder.get_object("font_button") self.app = app self.timer = app.timer self.refresh_time = builder.get_object("time_entry") self.autoclean_enable = builder.get_object("autoclean_enable") self.autoclean_days = builder.get_object("autoclean_days") self.dark_mode = builder.get_object("darkmode_enable") builder.connect_signals(self) # Following 3 methods: get_name, get_title, get_ui are # required for all children of stack in Preferences class. # Plugins and Synchronisation must have them, too! # They are used for easier, more abstract adding of the # children and setting the headerbar title. def get_name(self): return 'general' def get_title(self): return _('General') def get_ui(self): """ This method returns widget displayed in Preferences window. """ return self.ui_widget def activate(self): self._refresh_preferences_store() def get_default_editor_font(self): editor_font = self.config.get("font_name") if editor_font == "": font = self.ui_widget.get_style_context().get_font( Gtk.StateFlags.NORMAL) editor_font = font.to_string() return editor_font def _refresh_preferences_store(self): """ Sets the correct value in the preferences checkboxes """ show_preview = self.config.get("contents_preview_enable") self.preview_button.set_active(show_preview) bg_color = self.config.get("bg_color_enable") self.bg_color_button.set_active(bg_color) self.refresh_time.set_text(self.timer.get_formatted_time()) self.refresh_time.modify_fg(Gtk.StateFlags.NORMAL, None) self.font_button.set_font_name(self.get_default_editor_font()) enable_autoclean = self.config.get("autoclean") self.autoclean_enable.set_active(enable_autoclean) autoclean_days = self.config.get("autoclean_days") self.autoclean_days.set_value(autoclean_days) dark_mode = self.config.get("dark_mode") self.dark_mode.set_active(dark_mode) def _refresh_task_browser(self): """ Refresh tasks in task browser """ task_tree = self.req.get_tasks_tree(refresh=False).get_basetree() task_tree.refresh_all() def on_valid_time_check(self, widget): """ This function checks for validity of the user input with every new key-stroke from the user by parsing the input. """ try: input_time = self.refresh_time.get_text() self.timer.parse_time(input_time) color = None except ValueError: color = self.INVALID_COLOR self.refresh_time.modify_fg(Gtk.StateFlags.NORMAL, color) def on_leave_time_entry(self, widget, data=None): """ This function not only parses the user input, but is called only when the time entry is focused out. It also sets the time value for the widget. """ try: input_time = self.refresh_time.get_text() correct_time = self.timer.parse_time(input_time) self.timer.set_configuration(correct_time) except ValueError: pass self._refresh_preferences_store() def on_preview_toggled(self, widget, state): """ Toggle previews in the task view on or off.""" curstate = self.config.get("contents_preview_enable") if curstate != self.preview_button.get_active(): self.config.set("contents_preview_enable", not curstate) self._refresh_task_browser() def on_bg_color_toggled(self, widget, state): """ Save configuration and refresh nodes to apply the change """ curstate = self.config.get("bg_color_enable") if curstate != self.bg_color_button.get_active(): self.config.set("bg_color_enable", not curstate) self._refresh_task_browser() def on_font_change(self, widget): """ Set a new font for editor """ self.config.set("font_name", self.font_button.get_font_name()) def on_autoclean_toggled(self, widget, state): """Toggle automatic deletion of old closed tasks.""" self.config.set("autoclean", state) def on_autoclean_days_changed(self, widget): """Update value for maximum days before removing a task.""" self.config.set("autoclean_days", int(widget.get_value())) def on_purge_clicked(self, widget): """Purge old tasks immediately.""" self.app.purge_old_tasks(widget) def on_dark_mode_toggled(self, widget, state): """Toggle darkmode.""" self.config.set("dark_mode", state) self.app.toggle_darkmode(state) # Refresh panes func = self.app.browser.tv_factory.get_task_bg_color for pane in self.app.browser.vtree_panes.values(): pane.set_bg_color(func, 'bg_color') pane.basetree.get_basetree().refresh_all()
def on_eyedropper_picked(self, widget, color): new = Gdk.RGBA() rgba = Gdk.RGBA.parse(new, color) self.chooser.set_rgba(new) self.set_val(color)