def destroy(self): """Destroy the global object""" if self._ptr is not None: # run and remove destructor on c data _global_destroy(self._display, self._ptr) ffi.gc(self._ptr, None) self._ptr = None self._display = None
def destroy(self): """Destroy the event loop""" if self._ptr is not None: for event_source in self.event_sources: event_source.remove() # destroy the pointer and remove the destructor lib.wl_event_loop_destroy(self._ptr) ffi.gc(self._ptr, None) self._ptr = None
def connect(self) -> None: """Connect to a Wayland display Connect to the Wayland display by name of fd. An `int` parameter opens the connection using the file descriptor. The :class:`Display` takes ownership of the fd and will close it when the display is destroyed. The fd will also be closed in case of failure. A string will open the display of the given name. If name is ``None``, its value will be replaced with the ``WAYLAND_DISPLAY`` environment variable if it is set, otherwise display ``"wayland-0"`` will be used. """ if isinstance(self._name_or_fd, int): # argument passed is a file descriptor self._ptr = lib.wl_display_connect_to_fd(self._name_or_fd) else: # connect using string by name, or use default if self._name_or_fd is None: name: Union["NullCdata", bytes] = ffi.NULL else: name = self._name_or_fd.encode() self._ptr = lib.wl_display_connect(name) if self._ptr == ffi.NULL: raise ValueError("Unable to connect to display") self._ptr = ffi.gc(self._ptr, lib.wl_display_disconnect)
def __init__(self, ptr=None) -> None: if ptr is None: ptr = lib.wl_display_create() if ptr == ffi.NULL: raise MemoryError("Unable to create wl_display object") self._ptr = ffi.gc(ptr, lib.wl_display_destroy)
def __init__(self, display, version=None): if display._ptr is None or display._ptr == ffi.NULL: raise ValueError( "Display has been destroyed or couldn't initialize") if version is None: version = self.interface.version # we can't keep alive a handle to self without creating a reference # loop, so use this dict as the handle to pass to the global_bind_func # callback self._callback_info = {"interface": self.interface, "bind_func": None} self._handle = ffi.new_handle(self._callback_info) ptr = lib.wl_global_create( display._ptr, self.interface._ptr, version, self._handle, lib.global_bind_func, ) destructor = functools.partial(_global_destroy, display) self._ptr = ffi.gc(ptr, destructor) self._display = display # this c data should keep the display alive weakkeydict[self._ptr] = display
def _destroy(self): """Frees the pointer associated with the Proxy""" if self._ptr is not None: if self._display._ptr is not None: ffi.release(self._ptr) else: self._ptr = ffi.gc(self._ptr, None) self._ptr = None
def __init__(self, display: Display, fd: int) -> None: if display.destroyed: raise ValueError("Display has been destroyed") ptr = lib.wl_client_create(display._ptr, fd) destructor = functools.partial(_client_destroy, display) self._ptr = ffi.gc(ptr, destructor) self._display = display
def __init__(self, display=None): if display: self._ptr = lib.wl_display_get_event_loop(display._ptr) else: # if we are creating an eventloop. we need to destroy it later ptr = lib.wl_event_loop_create() self._ptr = ffi.gc(ptr, lib.wl_event_loop_destroy) self.event_sources = WeakSet() self.callbacks = []
def __init__(self, display: Optional["Display"] = None) -> None: if display: self._ptr: Optional[ "EventLoopCdata"] = lib.wl_display_get_event_loop(display._ptr) else: # if we are creating an eventloop. we need to destroy it later ptr = lib.wl_event_loop_create() self._ptr = ffi.gc(ptr, lib.wl_event_loop_destroy) self.event_sources: WeakSet[EventSource] = WeakSet() self._callback_handles: List = []
def __init__(self, display: "Display") -> None: """Constructor for the EventQueue object""" # check that we attach to a valid display if display._ptr is None or display._ptr == ffi.NULL: raise ValueError("Display object not connected") ptr = lib.wl_display_create_queue(display._ptr) # create a destructor, save data and display destructor = functools.partial(_event_queue_destroy, display) self._ptr: Optional["QueueCdata"] = ffi.gc(ptr, destructor) self._display: Optional["Display"] = display display._children.add(self) weakkeydict[self._ptr] = display
def __init__(self, ptr, display=None): """Represents a protocol object on the client side. A :class:`Proxy` acts as a client side proxy to an object existing in the compositor. Events coming from the compositor are also handled by the proxy, which will in turn call the handler set with :func:`Proxy.add_listener`. """ self.user_data = None self.dispatcher = Dispatcher(self.interface.events) # This should only be true for wl_display proxies, as they will # initialize its pointer on a `.connect()` call if ptr is None: self._ptr = ptr self._display = self return self._display = display # parent display is the root-most client Display object, all proxies # should keep the display alive if display is None: raise ValueError( "Non-Display Proxy objects must be associated to a Display") display._children.add(self) if ptr == ffi.NULL: raise RuntimeError("Got a null pointer for the proxy") # note that even though we cast to a proxy here, the ptr may be a # wl_display, so the methods must still cast to 'struct wl_proxy *' ptr = ffi.cast('struct wl_proxy *', ptr) self._ptr = ffi.gc(ptr, lib.wl_proxy_destroy) self._handle = ffi.new_handle(self) lib.wl_proxy_add_dispatcher(self._ptr, lib.dispatcher_func, self._handle, ffi.NULL) self.interface.registry[self._ptr] = self