Beispiel #1
0
    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)
Beispiel #2
0
    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
Beispiel #3
0
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()
Beispiel #5
0
 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
Beispiel #7
0
    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()
Beispiel #8
0
 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()
Beispiel #9
0
 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()
Beispiel #10
0
def _load_pulse_bar():
    Gdk.threads_enter()
    try: 
        persistance.load_dialog.progress_bar.pulse()
    except:
        pass
    Gdk.threads_leave()
Beispiel #11
0
 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()
Beispiel #12
0
    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
Beispiel #13
0
 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()
Beispiel #14
0
    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
Beispiel #15
0
 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()
Beispiel #16
0
	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
Beispiel #17
0
    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)
Beispiel #18
0
    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()
Beispiel #19
0
    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
Beispiel #20
0
 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()
Beispiel #21
0
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)
Beispiel #22
0
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
Beispiel #23
0
 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()
Beispiel #24
0
 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))
Beispiel #25
0
    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)
Beispiel #26
0
 def pbar_pulse():
     if(not self.should_pulse):
         return False
     Gdk.threads_enter()
     self.progress.pulse()
     Gdk.threads_leave()
     return self.should_pulse
Beispiel #27
0
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
Beispiel #28
0
 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
Beispiel #30
0
    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()
Beispiel #31
0
# 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):
    """
Beispiel #32
0
    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
Beispiel #34
0
 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)
Beispiel #38
0
def make_transparent(widget):
    rgba = Gdk.RGBA()
    rgba.parse('rgba(0, 0, 0, 0)')
    widget.override_background_color(Gtk.StateFlags.NORMAL, rgba)
Beispiel #39
0
	def ungrab_keyboard(*_args):
		v = Gdk.keyboard_ungrab(0)
		action_label.set_text("keyboard_ungrab(0)=%s" % GRAB_STATUS_STRING.get(v, v))
Beispiel #40
0
 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
Beispiel #41
0
	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()
Beispiel #42
0
# 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


#-------------------------------------------------------------------------
Beispiel #43
0
    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
Beispiel #44
0
	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)
Beispiel #45
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()
Beispiel #46
0
	def keyevent_info(event):
		keyval = event.keyval
		keycode = event.hardware_keycode
		keyname = Gdk.keyval_name(keyval)
		return "%i:%s" % (keycode, keyname)
Beispiel #47
0
 def use_stable_pixbuf(self):
     # print('image/384: use_stable_pixbuf')
     self.surface = Gdk.cairo_surface_create_from_pixbuf(
         self.main_pixbuf, 0, None)
Beispiel #48
0
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)
]
Beispiel #49
0
    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()
Beispiel #50
0
 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()
Beispiel #51
0
 def color_activated(dialog):
     color = dialog.get_rgba()
     # deprecated
     self.txtTotaleParziale.override_color(Gtk.StateFlags.NORMAL,
                                           Gdk.RGBA(*color))
Beispiel #52
0
 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
Beispiel #54
0
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)
Beispiel #56
0
 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)
Beispiel #57
0
    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)
Beispiel #58
0
                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)
Beispiel #59
0
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)