def test_custom_getset(self): class C(APTestClass): def __init__(self): APTestClass.__init__(self) self.custom = 10 def do_set_property_readwrite(self, name, value): assert name == "readwrite" self.custom = value def do_get_property_readwrite(self, name): assert name == "readwrite" return self.custom gobject.type_register(C) c = C() assert c.get_property("readwrite") == 10 c.set_property("readwrite", 3) assert c.custom == 3 assert c.get_property("readwrite") == 3 def setit(obj): obj._internal_set_property("readwrite", 12) assert_emits(setit, c, "notify::readwrite") assert c.get_property("readwrite") == 12 c.custom = 15 assert c.get_property("readwrite") == 15
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) gtk.Notebook.__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 register(): gobject.type_register(ResizeSink) gst.element_register (ResizeSink, 'myresize', gst.RANK_MARGINAL) gobject.type_register(CaptureSink) # Register the element into this process' registry. gst.element_register (CaptureSink, 'capturesink', gst.RANK_MARGINAL)
def __init__(self): """Class initialiser""" self.terminator = Terminator() self.terminator.register_window(self) Container.__init__(self) gtk.Window.__init__(self) gobject.type_register(Window) self.register_signals(Window) self.set_property("allow-shrink", True) self.apply_icon() self.register_callbacks() self.apply_config() self.title = WindowTitle(self) self.title.update() options = self.config.options_get() if options: if options.forcedtitle is not None: self.title.force_title(options.forcedtitle) if options.role is not None: self.set_role(options.role) if options.geometry is not None: if not self.parse_geometry(options.geometry): err("Window::__init__: Unable to parse geometry: %s" % options.geometry) self.pending_set_rough_geometry_hint = False
def _add_source_bin(self, pipeline): if gstreamer.element_factory_exists("appsrc") and \ gstreamer.get_plugin_version("app") >= (0, 10, 22, 0): self.source = gst.element_factory_make('appsrc', 'source') self.source.set_property('do-timestamp', True) self.source.connect('need-data', self.push_buffer) else: #FIXME: fluoverlaysrc only needed on gst-plugins-base < 0.10.22 gobject.type_register(OverlayImageSource) gst.element_register(OverlayImageSource, "fluoverlaysrc", gst.RANK_MARGINAL) self.source = gst.element_factory_make('fluoverlaysrc', 'source') # create the source bin self.sourceBin = gst.Bin() # create the alphacolor element alphacolor = gst.element_factory_make('alphacolor') # add the elements to the source bin and link them self.sourceBin.add_many(self.source, alphacolor) self.source.link(alphacolor) pipeline.add(self.sourceBin) # create the source ghost pad self.sourceBin.add_pad(gst.GhostPad('src', alphacolor.get_pad('src'))) # set the locked state and wait until we get the first caps change # and we know the widht and height of the input stream self.sourceBin.set_locked_state(True)
def __init__(self, *args): dbus.service.Object.__init__(self, *args) # State Variables self.playing = False self.audioChan = 0x20; self.selectedAudioChan = self.audioChan self.subChan = 0; #most likely will refere to a tetrode sub-channel self.selectedSubChan = self.subChan self.eio = NetEventIO("10.0.0.2") # AudioControl Event Constants setup on 10/13/08 self.AUDIO_EVENT_CMD = 0x12 self.ENABLE_AUDIO_EVENTS = 1 self.DISABLE_AUDIO_EVENTS = 0 self.AUDIO_REQUEST = 0 self.AUDIO_UPDATE = 1 #Create GST elements - pipeline will not be created gobject.type_register(SomaAudioEventFilter) self.eventSource = gst.element_factory_make('somaeventsource', "SomaEventSource") self.audioEventFilter = SomaAudioEventFilter() self.AUDIO_SINK = "pulsesink" self.audioSink = gst.element_factory_make(self.AUDIO_SINK) self.audioConverter = gst.element_factory_make("audioconvert") self.audioResampler= gst.element_factory_make("audioresample") self.queue = gst.element_factory_make("queue") self.pipeline = None
def __init__(self): gtk.VBox.__init__(self) #register pcalender as widget try: gobject.signal_new("month-changed",pcalendar, gobject.SIGNAL_RUN_LAST , gobject.TYPE_NONE, [gobject.TYPE_INT,gobject.TYPE_INT,gobject.TYPE_INT]) gobject.signal_new("day_selected",pcalendar, gobject.SIGNAL_RUN_LAST , gobject.TYPE_NONE, [gobject.TYPE_INT,gobject.TYPE_INT,gobject.TYPE_INT]) gobject.signal_new("day-selected-double-click",pcalendar, gobject.SIGNAL_RUN_LAST , gobject.TYPE_NONE, [gobject.TYPE_INT,gobject.TYPE_INT,gobject.TYPE_INT]) gobject.type_register(pcalendar) except: pass #get current date current_date =datetime.datetime.now() jdate_= utility.GregorianToJalali(current_date.year,current_date.month,current_date.day) self.year,self.month,self.day = jdate_.jyear,jdate_.jmonth,jdate_.jday self.lastday = self.day self.lastmin = -1 self.box2=gtk.Viewport() self.vbox2=gtk.VBox() self.vbox2.set_spacing(1) self.box2.add(self.vbox2) self.box1=gtk.Viewport() self.box1.set_border_width(5) self.vbox2.pack_start(self.box1,0,0,0) self.add(self.box2) self.connect("destroy",self.quit) self.vbox=gtk.VBox() self.vbox.set_spacing(3) self.box1.add(self.vbox) self.header=wmonth() self.vbox.pack_start(self.header.hbox,0,0,0) self.header.arrow_left2.connect("clicked",self.month_prev) self.header.arrow_right2.connect("clicked",self.month_next) self.header.arrow_left.connect("clicked",self.year_prev) self.header.arrow_right.connect("clicked",self.year_next) #add calendar widget self.cal=pcalendar(self.year,self.month,self.day) self.cal.connect("month-changed",self.monthchange) self.cal.connect("day_selected",self.daychange,'day_selected') self.cal.connect("day-selected-double-click",self.daychange,'day-selected-double-click') self.vbox.pack_start(self.cal ,1 ,1, 0) self.header.yearnum.set_label("<b>"+self.convert_to_str(self.year)+"</b>") self.header.monthname.set_label(' <b>'+mon_name[self.month-1]+'</b> ') self.box2.show_all() self.change_lable(self.day)
def test_assert_emits(self): class C(gobject.GObject): __gsignals__ = { "foo": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT, )), } gobject.type_register(C) def do_emit(obj): obj.emit("foo", "asdf") def dont_emit(obj): pass c = C() assert_emits(do_emit, c, "foo") assert_raises(AssertionError, assert_emits, dont_emit, c, "foo") def slot_wants_asdf(obj, arg): assert isinstance(obj, C) assert arg == "asdf" def slot_wants_hjkl(obj, arg): assert isinstance(obj, C) assert arg == "hjkl" assert_emits(do_emit, c, "foo", slot_wants_asdf) assert_raises(AssertionError, assert_emits, do_emit, c, "foo", slot_wants_hjkl) # Make sure that assert_emits disconnects after itself. self.gotcalled = False def f(*args): self.gotcalled = True assert_emits(do_emit, c, "foo", f) assert self.gotcalled self.gotcalled = False do_emit(c) assert not self.gotcalled # ...even if there was an error. # Errors can come from emission failure... assert_raises(AssertionError, assert_emits, dont_emit, c, "foo", f) # ..and from slots raising errors. def g(*args): assert False self.gotcalled = True assert_raises(AssertionError, assert_emits, do_emit, c, "foo", g) # In neither case should a handler be left around: self.gotcalled = False do_emit(c) assert not self.gotcalled
def ConsoleType(t=gtk.TextView): class console(t, _Console): def __init__(self, *args, **kwargs): t.__init__(self) _Console.__init__(self, *args, **kwargs) def do_key_press_event(self, event): return _Console.do_key_press_event(self, event, t) gobject.type_register(console) return console
def gobject_register(klass): """ Register a given object by calling gobject.type_register. Actually gobject.type_register is only called if the pygtk version in use is not 2.8 at least. """ if gtk_version_minor < 8: gobject.type_register(klass)
def ReadLineType(t=gtk.TextView): class readline(t, _ReadLine): def __init__(self, *args, **kwargs): t.__init__(self) _ReadLine.__init__(self, *args, **kwargs) def do_key_press_event(self, event): return _ReadLine.do_key_press_event(self, event, t) gobject.type_register(readline) return readline
def __init__(self, device_name = "ZynAddSubFX"): self.tempo = 120 self.channels = [] self.control_channel = 1 self.control_channel_cur = 0 self.device = self.MidiDevice(device_name) self.global_pattern = [] gobject.GObject.__init__(self) gobject.type_register(self.Channel) print "Starting Sequencer..."
def test_subclass_menubar(): ''' Ensure that subclassing the ``gtk.MenuBar`` class works as expected. ''' class MyMenuBar(gtk.MenuBar): def __init__(self): gtk.MenuBar.__init__(self) gobject.type_register(MyMenuBar) bar = MyMenuBar()
def test_scrollbars_in_subclass_init(): ''' Ensure that the scrolled windows scrollbars are ``None`` within a subclass __init__ method. ''' class Test124(gtk.ScrolledWindow): def __init__(self): super(Test124, self).__init__() assert not self.get_hscrollbar() assert not self.get_vscrollbar() gobject.type_register(Test124) gobject.new(Test124)
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 main(): # Registro la clase como un widget Gtk gobject.type_register(Velocimetro) win = gtk.Window() win.resize(210, 210) win.connect('delete-event', gtk.main_quit) velocimetro = Velocimetro(0, 100, 50.0) win.add(velocimetro) win.show() win.show_all() gtk.main()
def overrides(self): import gobject import gtk class NullTextView(gtk.TextView): set_tab_width = lambda *args: None set_show_line_numbers = lambda *args: None set_insert_spaces_instead_of_tabs = lambda *args: None set_draw_spaces = lambda *args: None gobject.type_register(NullTextView) self.GtkTextView = NullTextView self.GtkTextBuffer = gtk.TextBuffer
def test_subclass_init_calls_add(): ''' Ensure that adding items to a scrolled window within a subclass __init__ method works. :bug: #438114 ''' class MyScrolledWindow(gtk.ScrolledWindow): def __init__(self): super(MyScrolledWindow, self).__init__() self.add(gtk.TextView()) gobject.type_register(MyScrolledWindow) gobject.new(MyScrolledWindow)
def main(args): dev = int(sys.argv[1]) gobject.type_register(SomaAudioEventFilter) audioSrc = gst.element_factory_make('somaeventsource', 'SomaEventSource') #audioSrc = gst.element_factory_make('audiotestsrc', "test src") gst.info('About to create SomaAudioFilter') #somaAudioEventFilter = PyIdentity() somaAudioEventFilter = SomaAudioEventFilter() print "Created somaAudioEventFilter" somaAudioEventFilter.set_audio_src(dev) pipeline = gst.Pipeline() pipeline.add(audioSrc) pipeline.add(somaAudioEventFilter) finalSink = gst.element_factory_make("pulsesink") #finalSink = gst.element_factory_make("filesink") #finalSink.set_property("location", '/tmp/somaeventsourcetest.dat') pipeline.add(finalSink) ac = gst.element_factory_make("audioconvert") ars = gst.element_factory_make("audioresample") queue = gst.element_factory_make("queue") queue.set_property("max-size-buffers", 10000) pipeline.add(queue) pipeline.add(ac) pipeline.add(ars) ## caps = gst.Caps("audio/x-raw-int,rate=44100") ## filter = gst.element_factory_make("capsfilter", "filter") ## filter.set_property("caps", caps) ## pipeline.add(filter) gst.element_link_many(audioSrc, somaAudioEventFilter, queue, ac, ars, finalSink) #gst.element_link_many(audioSrc,somaAudioEventFilter, ars, filter, finalSink) #gst.element_link_many(audioSrc,somaAudioEventFilter, queue, finalSink) #gst.element_link_many(audioSrc, finalSink) #gst.element_link_many(audioSrc,somaAudioEventFilter, finalSink) print "somaAudioFilter linked to finalSink" print "Pipeline setup, setting STATE to PLAYING" pipeline.set_state(gst.STATE_PLAYING) gobject.MainLoop().run()
def main(): # Registro la clase como un widget Gtk gobject.type_register(StarHScale) win = gtk.Window() win.resize(200, 50) win.connect("delete-event", gtk.main_quit) starScale = StarHScale(3, 2) # starScale.set_property("sensitive", False) win.add(starScale) win.show() win.show_all() gtk.main()
def __new__(cls, name, bases, dct): ret = type.__new__(cls, name, bases, dct) for name in dir(ret.__styles): value = getattr(ret.__styles, name) value_type = type(value) gtk.widget_class_install_style_property(ret, ( name.replace("_", "-"), value_type, name.replace("_", "-"), value.__doc__.strip(), gobject.PARAM_READABLE)) gobject.type_register(ret) return ret
def setup(self, registry): # You will typically only implement one of the following things # in a single extension. # TODO: Edit or remove entirely from .frontend import FoobarFrontend registry.add('frontend', FoobarFrontend) # TODO: Edit or remove entirely from .backend import FoobarBackend registry.add('backend', FoobarBackend) # TODO: Edit or remove entirely from .mixer import FoobarMixer gobject.type_register(FoobarMixer) gst.element_register(FoobarMixer, 'foobarmixer', gst.RANK_MARGINAL)
def __init__(self, *args, **kargs): gtk.ScrolledWindow.__init__(self, *args, **kargs) self.htmlview = HtmlTextView() self.htmlview.set_wrap_mode(gtk.WRAP_WORD) self.htmlview.show() self.set_property("hscrollbar-policy", gtk.POLICY_AUTOMATIC) self.set_property("vscrollbar-policy", gtk.POLICY_AUTOMATIC) self.set_property("border-width", 0) self.add(self.htmlview) self.show() if gobject.pygtk_version < (2, 8): gobject.type_register(HtmlTextView) print 'Registered HtmlTextView'
def __new__(cls, *args, **kwargs): try: newcls = SignalManager.registered_classes[cls] obj = newcls.__new__(newcls, *args, **kwargs) gobject.GObject.__init__(obj) newcls.__init__(obj, *args, **kwargs) return obj except KeyError: pass def make_signal_prop(signal): def inner(self): return BoundedSignal(self, signal) return property(inner) newdict = dict(cls.__dict__) signals = {} for sname, signal in cls.__dict__.iteritems(): if isinstance(signal, Signal): signal.name = sname.replace('_', '-') signals[signal.name] = (signal.signal_type, signal.return_type, signal.arg_types) newdict[sname] = make_signal_prop(signal) if not signals: return super(SignalManager, cls).__new__(cls, *args, **kwargs) newdict['__gsignals__'] = signals newdict['weak_connect'] = SignalManager.weak_connect newdict['connect_signals'] = SignalManager.connect_signals for k, v in newdict.iteritems(): if hasattr(v, 'im_func'): newdict[k] = v.im_func newcls = type(cls.__name__, (gobject.GObject,), newdict) gobject.type_register(newcls) SignalManager.registered_classes[cls] = newcls obj = newcls.__new__(newcls, *args, **kwargs) gobject.GObject.__init__(obj) newcls.__init__(obj, *args, **kwargs) return obj
def main(args): # Need to register our derived widget types for implicit event # handlers to get called. gobject.type_register(ScannerUI) gobject.type_register(VideoWidget) s = Scanner(); if len(args) == 2: if gst.uri_is_valid(args[1]): s.set_uri(args[1]) else: sys.stderr.write("Error: Invalid URI: %s\n" % args[1]) sys.exit(1) gtk.main()
if len(reg): if not first: first = name self.__registries[name] = reg self.__build_list() if first is not None: self.__list.set_selected(first) def cb_list_clicked(self, listview, item): self.__build_page(item.key) def cb_undo_clicked(self, button): self.__reset() def cb_apply_clicked(self, button): self.__apply() def cb_save_clicked(self, button): self.__apply() self.__save() self.close() def cb_cancel_clicked(self, button): self.close() def show_page(self, pagename): self.__list.set_selected(pagename) gobject.type_register(config_view)
lambda self: self.window_widget.masterer.music_list_gateway) def write_files(self): return Application.write_files(self, self.window_widget) # TODO: decouple the window from SerpentineApplication ? def show_window(self): # Starts the window operation self.__window.start() self.operations.append(self.__window) def close_window(self): # Stops the window operation if self.__window.running: self.__window.stop() def stop(self): # Clean window object Application.stop(self) self.__window.destroy() del self.__window gobject.type_register(SerpentineWindow) if __name__ == '__main__': s = Serpentine() s.preferences.simulate = len(sys.argv) == 2 and sys.argv[1] == '--simulate' s.show() gtk.main()
def __init__(self): gtk.VBox.__init__(self) #register pcalender as widget try: gobject.signal_new( "month-changed", pcalendar, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_INT]) gobject.signal_new( "day_selected", pcalendar, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_INT]) gobject.signal_new( "day-selected-double-click", pcalendar, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, [gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_INT]) gobject.type_register(pcalendar) except: pass #get current date current_date = datetime.datetime.now() jdate_ = utility.GregorianToJalali(current_date.year, current_date.month, current_date.day) self.year, self.month, self.day = jdate_.jyear, jdate_.jmonth, jdate_.jday self.lastday = self.day self.lastmin = -1 self.box2 = gtk.Viewport() self.vbox2 = gtk.VBox() self.vbox2.set_spacing(1) self.box2.add(self.vbox2) self.box1 = gtk.Viewport() self.box1.set_border_width(5) self.vbox2.pack_start(self.box1, 0, 0, 0) self.add(self.box2) self.connect("destroy", self.quit) self.vbox = gtk.VBox() self.vbox.set_spacing(3) self.box1.add(self.vbox) self.header = wmonth() self.vbox.pack_start(self.header.hbox, 0, 0, 0) self.header.arrow_left2.connect("clicked", self.month_prev) self.header.arrow_right2.connect("clicked", self.month_next) self.header.arrow_left.connect("clicked", self.year_prev) self.header.arrow_right.connect("clicked", self.year_next) #add calendar widget self.cal = pcalendar(self.year, self.month, self.day) self.cal.connect("month-changed", self.monthchange) self.cal.connect("day_selected", self.daychange, 'day_selected') self.cal.connect("day-selected-double-click", self.daychange, 'day-selected-double-click') self.vbox.pack_start(self.cal, 1, 1, 0) self.header.yearnum.set_label("<b>" + self.convert_to_str(self.year) + "</b>") self.header.monthname.set_label(' <b>' + mon_name[self.month - 1] + '</b> ') self.box2.show_all() self.change_lable(self.day)
self.mute = False def changeValve(self, value): valve1 = self.get_by_name('gc-firewire-valve') valve1.set_property('drop', value) def getVideoSink(self): return self.get_by_name("gc-firewire-preview") def getSource(self): return self.get_by_name("gc-firewire-src") def send_event_to_src(self, event): src1 = self.get_by_name("gc-firewire-src") src1.send_event(event) def mute_preview(self, value): if not self.mute: element = self.get_by_name("gc-firewire-volume") element.set_property("mute", value) def configure(self): ## # v4l2-ctl -d self.options["location"] -s self.options["standard"] # v4l2-ctl -d self.options["location"] -i self.options["input"] pass gobject.type_register(GCfirewire) gst.element_register(GCfirewire, "gc-firewire-bin")
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) if self._own_x11_filter: #only remove the x11 filter if we initialized it (ie: when running in client) try: trap.call_synced(cleanup_x11_filter) except Exception, e: log.error("failed to remove x11 event filter: %s", e) try: trap.call_synced(cleanup_all_event_receivers) except Exception, e: log.error("failed to remove event receivers: %s", e) 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(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)
# gtk.STATE_ACTIVE # gtk.STATE_PRELIGHT # gtk.STATE_SELECTED # gtk.STATE_INSENSITIVE def highlight(self): pass def unhighlight(self): pass def show(self): gtk.EventBox.show_all(self) gobject.type_register(BaseWidget) gobject.signal_new("init", BaseWidget, gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()) class RichTextSep (BaseWidget): """Separator widget for a Horizontal Rule""" # TODO: dynamically resize def __init__(self): BaseWidget.__init__(self) self._sep = gtk.HSeparator() self.add(self._sep) self._size = None
def getValue(self): return self.get_property("value") ## ## Signal-emitting methods ## def emitInputUpdated(self, obj, prop): self.emit("input-updated", self.input) ## ## GObject methods ## def do_get_property(self, property): name = property.name if name in self.__dict__.keys(): return self.__dict__[name] else: raise AttributeError, "No such attribute" def do_set_property(self, property, value): name = property.name if name in self.__dict__.keys(): self.__dict__[name] = value else: raise AttributeError, "Not such attribute" gobject.type_register(TransferSynapse)
self.title_text.pop(position) self.notebook.remove_page(position) def show(self): self.window.show_all() self.current_page = 0 self.notebook.set_current_page(self.current_page) self.update_title() self.set_buttons() self.emit('page-changed', self.notebook.get_current_page()) if self.uistate: ManagedWindow.ManagedWindow.show(self) if gtk.pygtk_version < (2, 8, 0): gobject.type_register(Assistant) if __name__ == "__main__": def complete(): gtk.main_quit() def make_label(table, val, y, x1, x2, x3, x4): label = gtk.Label(val) label.set_alignment(0, 0.5) text = gtk.Entry() table.attach(label, x1, x2, y, y + 1, gtk.SHRINK | gtk.FILL) table.attach(text, x3, x4, y, y + 1, gtk.EXPAND | gtk.FILL) return text a = Assistant(complete)
self.bold_font = self.font.copy() self.bold_font.set_weight(pango.WEIGHT_BOLD) if self.read_only: self.set_font(self.bold_font) else: self.set_font(self.normal_font) self.queue_draw() def set_impossible(self, val): if val: self.set_text('X') else: self.set_text('') gobject.type_register(NumberBox) if __name__ == '__main__': window = gtk.Window() window.connect('delete-event', gtk.main_quit) def test_number_selector(): nselector = NumberSelector(default=3) def tell_me(b): print 'value->', b.get_value() nselector.connect('changed', tell_me) window.add(nselector) def test_number_box():
def gobject_register(klass): if gtk_version_minor < 8: gobject.type_register(klass)
# about this window are the _NET_SUPPORTING_WM_CHECK property, and # 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 = gtk.gdk.Window( self._root, width=1, height=1, window_type=gtk.gdk.WINDOW_TOPLEVEL, event_mask=0, # event mask wclass=gtk.gdk.INPUT_ONLY, title="%s-EWMH" % self._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) # Other global actions: def _make_window_pseudoclient(self, win): "Used by PseudoclientWindow, only." win.set_screen(self._alt_display.get_default_screen()) gobject.type_register(Wm)
widths = self.__compute_column_widths(width - total_column_spacing) heights = self.__compute_row_heights(height - total_row_spacing) # _logger.debug("allocate: widths=%s, heights=%s", widths, heights) x = 0 xs = [] for width in widths: xs.append(x) x += width + self.__column_spacing xs.append(x) y = 0 ys = [] for height in heights: ys.append(y) y += height + self.__row_spacing ys.append(y) for box_child in self.__box.get_layout_children(): x = xs[box_child.left] width = xs[box_child.right] - x - self.__column_spacing y = ys[box_child.top] height = ys[box_child.bottom] - y - self.__row_spacing box_child.allocate(x, y, width, height, origin_changed) gobject.type_register(TableLayout)
menu = gtk.Menu() self.populate_menu_with_notebooks(menu, list) menu.show_all() menu.popup(None, None, gtk.status_icon_position_menu, button, activate_time, self) def do_popup_menu(self, button=3, activate_time=0): #~ print '>>', button, activate_time menu = self.get_trayicon_menu() menu.show_all() menu.popup(None, None, gtk.status_icon_position_menu, button, activate_time, self) # Need to register classes overriding gobject signals gobject.type_register(StatusIconTrayIcon) class StandAloneTrayIcon(StatusIconTrayIcon): '''This class defines the tray icon used for a single stand-alone notebook. ''' def __init__(self, window): StatusIconTrayIcon.__init__(self) self.window = window self.notebook = self.window.ui.notebook # XXX self.set_tooltip(self.notebook.name) if self.notebook.icon: self.set_from_file(self.notebook.icon) def list_open_notebooks(self):
if self.input_mode: return True iter = self.buffer.get_iter_at_mark(self.buffer.get_insert()) if iter.get_line_offset() == PSLEN: self.quit_handler() return True # Ctrl-L elif event.keyval in (gtk.keysyms.L, gtk.keysyms.l): if not self.input_mode: self.clear() return True return False gobject.type_register(Console) # ============================================================================= class ConsoleWindow: """ Interactive GTK console window """ def __init__(self, ns, title='Python', command=None): """ Initialize s console window """ self.win = gtk.Window() self.win.set_default_size(640, 400) self.win.set_border_width(3) self.win.connect("destroy", lambda w: gtk.main_quit()) self.win.connect("delete_event", lambda w, e: gtk.main_quit()) self.win.set_title(title) self.console = Console(namespace=ns)
if self.get_child(): child_width, child_height = self.get_child().size_request() requesition.width = max(child_width, requesition.width) requesition.height = max(child_height, requesition.height) def do_expose_event(self, event): CustomDrawingMixin.do_expose_event(self, event) if self.get_child(): self.propagate_expose(self.get_child(), event) def do_size_allocate(self, allocation): gtk.Bin.do_size_allocate(self, allocation) if self.get_child(): self.get_child().size_allocate(allocation) gobject.type_register(MiroDrawingArea) gobject.type_register(BackgroundWidget) class Drawable: def __init__(self): self.squish_width = self.squish_height = False def set_squish_width(self, setting): self.squish_width = setting def set_squish_height(self, setting): self.squish_height = setting def set_widget(self, drawing_widget): if self.is_opaque() and 0: box = gtk.EventBox()
def bind(self, keybinding): if self.bound: self.unbind() LOGGER.info('Binding Global shortcut %s to focus the deskbar', keybinding) try: self.bound = deskbar.core.keybinder.tomboy_keybinder_bind( keybinding, self.on_keyboard_shortcut) self.prevbinding = keybinding except KeyError: # binding failed self.bound = False return self.bound def unbind(self): LOGGER.info('Unbinding Global shortcut %s to focus the deskbar', self.prevbinding) try: deskbar.core.keybinder.tomboy_keybinder_unbind(self.prevbinding) self.bound = False except KeyError: # if the requested keybinding is not bound, a KeyError will be thrown pass if gtk.pygtk_version < (2, 8, 0): gobject.type_register(Keybinder)
if cond & (gobject.IO_ERR | gobject.IO_HUP): self.close() return False if cond & gobject.IO_OUT: if len(self._outgoing_queue) > 0: # send next item item = self._outgoing_queue[0] try: ret = self._transport.send(item.read()) except (OpenSSL.WantX509LookupError, OpenSSL.WantReadError, OpenSSL.WantWriteError): return True except OpenSSL.Error: self.close() return False item.sent(ret) if item.is_complete(): # sent item self.emit("sent", item.buffer, item.size) item.callback() del self._outgoing_queue[0] del item if len(self._outgoing_queue) == 0: self._watch_remove_cond(gobject.IO_OUT) else: self._watch_remove_cond(gobject.IO_OUT) return True gobject.type_register(SSLSocketClient)
'dict'. Plugins should not modify page! ''' # In theory it would be better to do this without a singleton, but in that # case there would need to be an instance of this object per NotebookInterface # object. Not impossible, but not needed for now. # define signals we want to use - (closure type, return type and arg types) __gsignals__ = { 'process-page': (gobject.SIGNAL_RUN_LAST, None, (object, object, object)), } # Need to register classes defining gobject signals gobject.type_register(_TemplateManager) TemplateManager = _TemplateManager() class GenericTemplate(object): '''Base template class''' def __init__(self, input, name=None): '''Constructor takes a file path or an opened file handle''' if isinstance(input, basestring): input = input.splitlines(True) self.file = name or '<open file>' self.lineno = 0 self.text = None # needs to be set to None for use with TemplateError() self.tokens = TemplateTokenList() self.stack = [self.tokens]
class SearchEntry(InputEntry): def __init__(self, *args, **kwargs): entry_button = ImageButton( app_theme.get_pixbuf("toolbar/search_normal.png"), app_theme.get_pixbuf("toolbar/search_hover.png"), app_theme.get_pixbuf("toolbar/search_press.png")) super(SearchEntry, self).__init__(action_button=entry_button, *args, **kwargs) self.action_button = entry_button self.set_size(250, 24) gobject.type_register(SearchEntry) class ComplexButton(gtk.Button): def __init__(self, bg_group, icon, content, left_padding=20, label_padding=10, font_size=9): super(ComplexButton, self).__init__() # Init. self.normal_bg, self.hover_bg, self.press_bg = bg_group self.button_icon = icon
return True def delete(self,key): """Pops up a dialog. If response is positive, deletes a MP.""" logger.info("Delete: {0}".format(str(key))) package = self.repository.get(key) t1 = _("This action will remove the recording from the hard disk.") t2 = _('Recording: "{0}"').format(package.getTitle()) text = {"title" : _("Media Manager"), "main" : _("Are you sure you want to delete?"), "text" : t1+"\n\n"+t2 } buttons = ( gtk.STOCK_DELETE, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT) warning = message.PopUp(message.WARNING, text, context.get_mainwindow(), buttons) if warning.response in message.POSITIVE: self.repository.delete(package) return True else: return False def network_status(self, signal, status): """Updates the signal status from a received signal""" self.network = status gobject.type_register(ManagerUI)
def __init__(self, name=None): self._name = name self.__gobject_init__() self._stop_time = None self._start_time = time.time() def reset_start_time(self): self._start_time = time.time() self._stop_time = None def set_stop_time(self, stop_time): self._stop_time = stop_time gobject.type_register(TimeredObj) class TimerManager(gobject.GObject): timered_objs = [] active_timered_objs = [] done_timered_objs = [] io_handler_id = 0 def __init__(self): self.__gobject_init__() def add_timerd_obj(self, obj): if not isinstance(obj, TimeredObj): raise TypeError, "obj must be TimeredObj Object"
emsg = _("Error looking up artist %s on jamendo.com") % (artist) Gtk.MessageDialog(None, 0, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, emsg).run() return Gtk.show_uri(self.props.shell.props.window.get_screen(), result + "donate/", Gdk.CURRENT_TIME) def playing_entry_changed(self, entry): if not self.__db or not entry: return if entry.get_entry_type() != self.__db.entry_type_get_by_name( "JamendoEntryType"): return gobject.idle_add(self.emit_cover_art_uri, entry) def emit_cover_art_uri(self, entry): stream = self.__db.entry_get_string(entry, RB.RhythmDBPropType.LOCATION) albumid = self.__db.entry_get_string(entry, RB.RhythmDBPropType.MB_ALBUMID) url = artwork_url % albumid self.__db.emit_entry_extra_metadata_notify(entry, "rb:coverArt-uri", str(url)) return False gobject.type_register(JamendoSource)
if isinstance(value, datetime.datetime): value = value.date() assert isinstance(value, datetime.date), value self.__date = value self.update_label() elif prop.name == 'format': self.__format = value self.update_label() def do_get_property(self, prop): if prop.name == 'value': return self.__date elif prop.name == 'format': return self.__format gobject.type_register(Date) class CellRendererDate(gtk.CellRendererText): __gproperties__ = { 'format': (gobject.TYPE_STRING, _('Format'), _('Display format'), '%x', gobject.PARAM_READABLE | gobject.PARAM_WRITABLE), } def __init__(self): self.__format = '%x' gtk.CellRendererText.__init__(self)
__gsttemplates__ = (gst.PadTemplate("sink", gst.PAD_SINK, gst.PAD_ALWAYS, caps), ) def __init__(self): gst.BaseSink.__init__(self) self.props.sync = False self.rate = 0 self.duration = 0L self.reset() def reset(self): self.samples = array.array('f') def do_set_caps(self, caps): if not caps[0].get_name() == "audio/x-raw-float": return False self.rate = caps[0]["rate"] return True def do_render(self, buf): self.samples.fromstring(buf) self.duration += buf.duration return gst.FLOW_OK def do_preroll(self, buf): return self.do_render(buf) gobject.type_register(ArraySink)
"base-size": (640, 640), "minimum-size": (640, 640), "increment": (128, 128), "minimum-aspect-ratio": (1, 3), "maximum-aspect-ratio": (3, 1), }) else: use_fixed_size() screenlog("size-hints=%s", size_hints) self._updateprop("size-hints", size_hints) def do_xpra_damage_event(self, event): self.emit("client-contents-changed", event) gobject.type_register(DesktopModel) """ A server class for RFB / VNC-like desktop displays, used with the "start-desktop" subcommand. """ class XpraDesktopServer(gobject.GObject, RFBServer, X11ServerBase): __gsignals__ = { "xpra-xkb-event": one_arg_signal, "xpra-cursor-event": one_arg_signal, "xpra-motion-event": one_arg_signal, } def __init__(self): gobject.GObject.__init__(self)
return gst.FLOW_OK if len(self.buffer) < self.buffer_size: # we need to buffer more return gst.FLOW_OK buffer = self.buffer[self.buffer_size:] fake_header = self.get_fake_header() n_buf = gst.Buffer(fake_header + buffer) self.proxy = True self.srcpad.push(n_buf) return gst.FLOW_OK gobject.type_register(FakeTransformer) class DataSink(gst.Element, log.Loggable): logCategory = 'transcoder_datasink' _sinkpadtemplate = gst.PadTemplate("sinkpadtemplate", gst.PAD_SINK, gst.PAD_ALWAYS, gst.caps_new_any()) def __init__(self, destination=None, request=None): gst.Element.__init__(self) self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink") self.add_pad(self.sinkpad) self.sinkpad.set_chain_function(self.chainfunc)
if unparsed in self.normalized_hotkeys: target = self.normalized_hotkeys[unparsed] self.emit("hotkey::%s" % (target, ), target) def add_hotkeys(self, hotkeys): self.hotkeys.update(hotkeys) self._rebind() def del_hotkeys(self, keys): for k in keys: if k in self.hotkeys: del self.hotkeys[k] self._rebind() gobject.type_register(HotkeyManager) DEFAULT_MODIFIER_MEANINGS = { "Shift_L": "shift", "Shift_R": "shift", "Caps_Lock": "lock", "Control_L": "control", "Control_R": "control", "Alt_L": "mod1", "Alt_R": "mod1", "Num_Lock": "mod2", "Meta_L": "mod3", "Meta_R": "mod3", "Super_L": "mod4", "Super_R": "mod4", "Hyper_L": "mod4",
self.ready_handler(self) # get the value of ContactAttributeInterfaces self[DBUS_PROPERTIES].Get(CONNECTION_INTERFACE_CONTACTS, 'ContactAttributeInterfaces', reply_handler=reply, error_handler=error) self.signals.append(self[CONNECTION].connect_to_signal( 'StatusChanged', self._status_changed)) def do_disconnect(self): # required so that we don't transmit this over D-Bus pass gobject.type_register(EConnection) class EChannel(gobject.GObject, telepathy.client.Channel): __gsignals__ = { 'closed': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()), } def __init__(self, account_path, conn, path, properties, ready_handler): self.ready_handler = ready_handler self.account_path = account_path self.conn = conn self.properties = properties self.signals = [] gobject.GObject.__init__(self)
# CZECH THIS SHIT. You *can* set the fg/text on a label, but it # will still emboss the color in the INSENSITIVE state. The way # to avoid embossing is to use pango attributes (e.g. via # <span>), but then in INSENSITIVE you get stipple. Where is # this documented? Grumble. if sensitive: m = '<small>%s</small>' % self.name else: m = ('<small><span foreground="%s">%s</span></small>' % (pc(self.fgi), self.name)) self.label.set_markup(m) gtk.Button.set_sensitive(self, sensitive) gobject.type_register(_SidebarButton) class _SidebarSection(gtk.VBox): gsignal('step-chosen', str) def __init__(self, title, name): gtk.VBox.__init__(self) self.set_name(title) self._buttons = util.OrderedDict() self.title = _SidebarButton(title, 10) self.title.show() self.title.set_sensitive(False) self.pack_start(self.title, False, False)
def __delete_messages_cb(self, messages): for message in messages: try: self._messages.remove(message) except ValueError: pass self.emit('messages-deleted') def __common_callback(self, signal, *args): self.emit(signal, *args) def __common_errback(self, error_code, *args): self.emit('error', error_code) gobject.type_register(OfflineMessagesBox) if __name__ == '__main__': import sys import getpass import signal import gobject import logging from papyon.service.SingleSignOn import * from papyon.service.AddressBook import AddressBook logging.basicConfig(level=logging.DEBUG) if len(sys.argv) < 2: account = raw_input('Account: ') else:
def __init__(cls,*kwds): gobject.GObjectMeta.__init__(cls,*kwds) cls.__gtype_name__ = cls.__name__ gobject.signal_new('cursor-move', cls, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_DOUBLE,gobject.TYPE_DOUBLE)) gobject.type_register(cls)
def set_up(): gobject.type_register(CommandText) gobject.type_register(IconSelector) gobject.signal_new("text-changed", CommandText, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,)) gobject.signal_new("mode-changed", CommandText, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,)) gobject.signal_new("image-changed", IconSelector, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,)) gobject.signal_new("text-changed", IconSelector, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,)) gobject.signal_new("mode-changed", IconSelector, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,))
def __init__(self): self.tempo = 120 self.channels = [] self.control_channel = 1 self.control_channel_cur = 0 self.device = self.MidiDevice() self.global_pattern = [] gobject.GObject.__init__(self) gobject.type_register(self.Channel) gobject.signal_new("bar-end", self.Channel, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()) print "Starting Sequencer..."
def __init__(self): print "Inicio" gobject.type_register(Sender) gobject.signal_new("z_signal", Sender, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()) sender = Sender() receiver = Reciever(sender) sender.connect('z_signal', self.user_callback) sender.emit('z_signal')
def __init__(cls,*kwds): gobject.GObjectMeta.__init__(cls,*kwds) cls.__gtype_name__ = cls.__name__ gobject.signal_new('time_changed', cls, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,)) gobject.signal_new('date_changed', cls, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,)) gobject.type_register(cls)