def __init__(self, config): self.signals = kaa.Signals('started', 'stopped', 'epg-update') self.config = config self.multiplexes = [] self._schedule_id = 0 self.__initialized = kaa.InProgress() self.schedules = {}
def __init__(self): self.signals = kaa.Signals('locked', 'unlocked') self._clients = [] self._in_progress = None # Precreate a finished InProgress object that we can return when # not locked. self._in_progress_finished = kaa.InProgress().finish(None)
def __init__(self, pos=None, size=None, uri=None, player='gstreamer', context=None): """ Create the video widget. The widget supports gstreamer (default) and mplayer but only gstreamer can be used as real widget for now. When choosing mplayer it will always open a full screen window to play the video. The playback can be configured using the config member dictionary. Please note, that gstreamer tries to figure out most of the stuff itself and AC3 and DTS passthrough only works when using pulseaudio and pulseaudio configured correctly (pavucontrol). Future versions of kaa.candy may have more or changed options. """ super(Video, self).__init__(pos, size, context) self.uri = uri self.signals = kaa.Signals('finished', 'progress', 'streaminfo') self.state = STATE_IDLE # player configuration self.config = { 'mplayer.vdpau': False, 'mplayer.passthrough': False, 'fresh-rate': None } # current streaminfo / audio / subtitle values self.streaminfo = { 'audio': {}, 'subtitle': {}, 'is_menu': False, } self.aspect = ASPECT_ORIGINAL self.player = player or 'gstreamer'
def __init__(self): self.parent = None self.active = False self.enabled = True self.visible = True self.signals = kaa.Signals() self.signals['activated'] = kaa.Signal() self.signals['deactivated'] = kaa.Signal()
def __init__(self): """ Create a new instance with initially no buttons. """ self.buttons = [] self.selected_button = None self.signals = kaa.Signals() self.signals['selection_changed'] = kaa.Signal()
def __init__(self): self._stack = [] self.locked = False if not hasattr(self, 'signals'): # The main menu inherits from appication which already # defines self.signals. ther menus need this because we # want to add a refresh signal self.signals = kaa.Signals() self.signals['refresh'] = kaa.Signal()
def __init__(self, node=None): self.properties = () self.parent = None self.children = None self.has_children = False self.type = '' self.signals = kaa.Signals() self.signals['property-changed'] = kaa.Signal() self.signals['child-added'] = kaa.Signal() self.signals['child-removed'] = kaa.Signal()
def __init__(self, eventmap, capabilities=[]): """ Init the Application object. """ self.signals = kaa.Signals('show', 'hide', 'start', 'stop') self.__status = STATUS_IDLE self.__eventmap = eventmap self.__capabilities = 0 self.context = WidgetContext(self.name) for cap in capabilities: self.__capabilities |= cap
def __init__(self, address, password): self.signals = kaa.Signals('connected', 'disconnected', 'changed') self.recordings = Recordings(self) self.favorites = Favorites(self) self.channel = kaa.rpc.connect(address, password, retry=1) self.channel.register(self) self.channel.signals['open'].connect(self._connected) self.channel.signals['closed'].connect(self._disconnected) # connect kaa.epg database to port + 1 address, port = address.split(':') kaa.epg.connect('%s:%s' % (address, int(port) + 1), password)
def __init__(self, address, secret): self.connected = False self._num_programs = 0 self._channels_by_name = {} self._channels_by_db_id = {} self._channels_by_tuner_id = {} self.rpc = None self.signals = kaa.Signals('connected', 'disconnected') self._server_address = address self._server_secret = secret self.channel = kaa.rpc.connect(self._server_address, auth_secret=self._server_secret, retry=1) self.channel.register(self) self.channel.signals['closed'].connect_weak(self._disconnected)
def __init__(self, window): self._window = window # FIXME: connect to GTK signals self.signals = kaa.Signals( "key_press_event", # key pressed "focus_in_event", # window gets focus "focus_out_event", # window looses focus "expose_event", # expose event "map_event", # ? "unmap_event", # ? "resize_event", # window resized "configure_event") # ? self._display = X11Display(self._window.get_display().get_name())
def __init__(self, client, **query): """ Create a Query object and start the query on the client """ # FIXME: progress and up-to-date seems not used self.signals = kaa.Signals('changed', 'progress', 'up-to-date') self.id = Query.NEXT_ID Query.NEXT_ID += 1 # public variables self.result = [] # internal variables self._query = query self._client = client self._beacon_monitoring = False # some shortcuts from the client self._rpc = self._client.rpc # InProgress object self._async = kaa.InProgress() # start inititial query self._beacon_start_query(query)
def __init__(self): """ """ super(PluginInterface, self).__init__() self.signals = kaa.Signals('update') self.image_cache_images = {None: None} self.image_cache_hashes = {None: None} port = freevo.config.plugin.httpserver.port self.server = HTTPServer(("", port)) self.server.serve_forever() self.server.add_json_handler('/event/', self.event) self.server.add_json_handler('/key/', self.key) self.server.add_json_handler('/view', self.view) self.server.add_json_handler('/select/', self.select) self.server.add_handler('/images/', self.images) self.server.add_static( '/', freevo.FREEVO_SHARE_DIR + '/httpserver/simple.html') self.server.add_static('/jquery', freevo.FREEVO_SHARE_DIR + '/httpserver/jquery') freevo.signals['application-change'].connect(self.application_change) self.post_key = InputPlugin().post_key
def __init__(self, name, duration): """ Create a new instance. @param name: Name of the skin to render. @param duration: Time in seconds the dialog should be shown for by default. """ self.name = name self._skin = None self.display = None self.duration = duration self.priority = Dialog.NORMAL_PRIORITY self.__first_show = True self.signals = kaa.Signals() self.signals['prepared'] = kaa.Signal() self.signals['shown'] = kaa.Signal() self.signals['hidden'] = kaa.Signal() self.signals['finished'] = kaa.Signal() self.updater = None self.__update_interval = 0 self.last_render = 0.0 if DEBUG_PERFORMANCE: self.__render_count = 0 self.__first_render_time = 0.0 self.__hide_time = 0.0
def __init__(self, display=None, window=None, **kwargs): """ Create a new X11 window or wrap an existing X11 window. If display is None, it will use the default display (based on the DISPLAY environment variable). If window is a numeric, it will consider it a window id and can be used to wrap an existing X11 window. The window parameter may also be a lower level _X11.X11Window object. If window is none, then a new window will be created, and the following kwargs apply: size: 2-tuple of width and height for the window (required) title: A string representing the window's title (optional) parent: An existing X11Window object of which the new window will be a subwindow. input_only: A boolean, default False, which indicates whether this window only captures mouse and key events, but doesn't have a graphics surface. proxy_for: An X11Window to which all mouse and key events received by this window will be sent. composite: A boolean to indicate whether the window can make use of the XComposite extension to display translucent areas by drawing to the window using an image with an alpha channel. The following kwargs apply in either case: window_events: A boolean, default True, to indicate whether the client wishes to receive window (un)map/focus/expose events. mouse_events: A boolean, default True, to indicate whether the client wishes to receive mouse button pressed/release events. key_events: A boolean, default True, to indicate whether the client wishes to receive key button pressed/release events. """ display = get_display(display) if window: if isinstance(window, (long, int)): # Create new X11Window object based on existing window id. self._window = _X11.X11Window(display._display, (-1, -1), window=long(window), **kwargs) elif isinstance(window, _X11.X11Window): self._window = window else: raise ValueError, "window parameter must be an integer." else: if "title" in kwargs: assert (type(kwargs["title"]) == str) if "parent" in kwargs: assert (isinstance(kwargs["parent"], X11Window)) kwargs["parent"] = kwargs["parent"]._window if 'composite' in kwargs and kwargs['composite']: kwargs['argb'] = True if "proxy_for" in kwargs: assert (isinstance(kwargs["proxy_for"], X11Window)) self.proxy_for = kwargs["proxy_for"] w, h = kwargs.get('size', (1, 1)) self._window = _X11.X11Window(display._display, (w or 1, h or 1), **kwargs) if 'composite' in kwargs and kwargs['composite']: display.composite_redirect = self._window.wid self._display = display display._windows[self._window.wid] = weakref.ref(self) self._cursor_hide_timeout = 1 self._cursor_hide_timer = kaa.WeakOneShotTimer(self._cursor_hide_cb) self._cursor_visible = True self._fs_size_save = None self._last_configured_size = 0, 0 self.signals = kaa.Signals( "key_press_event", # key pressed "key_release_event", # key release "button_press_event", # Button pressed "button_release_event", # Button released "focus_in_event", # window gets focus "focus_out_event", # window looses focus "expose_event", # expose event "map_event", # shown/mapped on to the screen "unmap_event", # hidden/unmapped from the screen "resize_event", # window resized "delete_event", "configure_event") # ?
import kaa.beacon initialized = False WORKER_THREAD = 'WEBMETADATA' kaa.metadata.enable_feature('VIDEO_SERIES_PARSER') kaa.register_thread_pool(WORKER_THREAD, kaa.ThreadPool()) import tv import movie from tv.core import Series, Season, Episode from movie.core import Movie signals = kaa.Signals('sync', 'changed') def init(base): """ Initialize the kaa.webmetadata databases """ global initialized if initialized: return for module in tv, movie: module.init(base) initialized = True for module in tv.backends.values() + movie.backends.values(): module.signals['changed'].connect(signals['changed'].emit)
import time import os import sys import gc import kaa import kaa.rpc sig = kaa.Signals('one', 'two', 'three') # Named thread pools used later. kaa.register_thread_pool('yield', kaa.ThreadPool()) kaa.register_thread_pool('foo', kaa.ThreadPool()) class Server(object): def __init__(self): self.s = kaa.rpc.Server('test') self.s.register(self) @kaa.rpc.expose('test1') def test1(self, x): return x, kaa.is_mainthread() @kaa.rpc.expose('test2') @kaa.threaded('yield') def test2(self, x): return x, kaa.is_mainthread() @kaa.rpc.expose('test3') @kaa.coroutine() def test3(self, x):
import kaa def myfunc(value): print 'x', value signals = kaa.Signals('foo', 'bar') signals.connect('foo', myfunc) signals['foo'].emit(1) signals.emit('foo', 2) sig2 = kaa.Signals(signals, 'new') print sig2.keys()
def __init__(self): self.signals = kaa.Signals('added', 'removed') self._dict = {}