kuuko pushed a commit to branch master.
commit e77f558e39b4a5d50be6bd4988d083cdca50fc0f
Author: Kai Huuhko <[email protected]>
Date: Fri Apr 5 20:29:13 2013 +0000
EDBus: More skeletons.
---
efl/edbus/connection.pxi | 156 +++++++++++++++++
efl/edbus/edbus.pxd | 8 +-
efl/edbus/edbus.pyx | 10 +-
efl/edbus/message.pxi | 403 +++++++++++++++++++++++++++++++++++++++++++
efl/edbus/signal_handler.pxi | 130 ++++++++++++++
5 files changed, 697 insertions(+), 10 deletions(-)
diff --git a/efl/edbus/connection.pxi b/efl/edbus/connection.pxi
new file mode 100644
index 0000000..58ac7d8
--- /dev/null
+++ b/efl/edbus/connection.pxi
@@ -0,0 +1,156 @@
+EDBUS_CONNECTION_TYPE_SESSION = enums.EDBUS_CONNECTION_TYPE_SESSION
+EDBUS_CONNECTION_TYPE_SYSTEM = enums.EDBUS_CONNECTION_TYPE_SYSTEM
+EDBUS_CONNECTION_TYPE_STARTER = enums.EDBUS_CONNECTION_TYPE_STARTER
+
+EDBUS_CONNECTION_EVENT_DEL = enums.EDBUS_CONNECTION_EVENT_DEL
+EDBUS_CONNECTION_EVENT_DISCONNECTED = enums.EDBUS_CONNECTION_EVENT_DISCONNECTED
+
+cdef void edbus_connection_event_cb(void *data, EDBus_Connection *conn, void
*event_info):
+ pass
+
+cdef void edbus_connection_free_cb(void *data, const void *deadptr):
+ pass
+
+cdef class Connection(object):
+ """A connection object"""
+
+ cdef EDBus_Connection *conn
+
+ def __init__(self, EDBus_Connection_Type conn_type, private=False):
+ if not private:
+ """
+
+ Establish a connection to bus and integrate it with the ecore main
+ loop. If a connection of given type was already created before, its
+ reference counter is incremented and the connection is returned.
+
+ :param type: type of connection e.g EDBUS_CONNECTION_TYPE_SESSION,
+ EDBUS_CONNECTION_TYPE_SYSTEM or EDBUS_CONNECTION_TYPE_STARTER
+
+ :return: connection with bus
+
+ """
+ self.conn = edbus_connection_get(conn_type)
+ else:
+ """
+
+ Always create and establish a new connection to bus and integrate
it with
+ the ecore main loop. Differently from edbus_connection_get(), this
function
+ guarantees to create a new connection to the D-Bus daemon and the
connection
+ is not shared by any means.
+
+ :param type: type of connection e.g EDBUS_CONNECTION_TYPE_SESSION,
+ EDBUS_CONNECTION_TYPE_SYSTEM or EDBUS_CONNECTION_TYPE_STARTER
+
+ :return: connection with bus
+
+ """
+ self.conn = edbus_private_connection_get(conn_type)
+
+ def ref(self):
+ """
+
+ Increment connection reference count.
+
+
+ """
+ # NOTE: returns EDBus_Connection *
+ edbus_connection_ref(self.conn)
+ return self
+
+ def unref(self):
+ """
+
+ Decrement connection reference count.
+
+ If reference count reaches 0, the connection to bus will be dropped
and all
+ its children will be invalidated.
+
+ """
+ edbus_connection_unref(self.conn)
+
+ def free_cb_add(self):
+ """
+
+ Add a callback function to be called when connection is freed
+
+ :param cb: callback to be called
+ :param data: data passed to callback
+
+ """
+ edbus_connection_free_cb_add(self.conn, EDBus_Free_Cb cb, const void
*data) EINA_ARG_NONNULL(1, 2)
+
+ def free_cb_del(self):
+ """
+
+ Remove callback registered in edbus_connection_free_cb_add().
+
+ """
+ edbus_connection_free_cb_del(self.conn, EDBus_Free_Cb cb, const void
*data) EINA_ARG_NONNULL(1, 2)
+
+ def data_set(self, key, data):
+ """
+
+ Set an attached data pointer to an object with a given string key.
+
+ :param key: to identify data
+ :param data: data that will be stored
+
+ """
+ edbus_connection_data_set(self.conn, const char *key, const void
*data) EINA_ARG_NONNULL(1, 2, 3)
+
+ def data_get(self, key):
+ """
+
+ Get data stored in connection.
+
+ :param key: key that identifies data
+
+ :return: pointer to data if found otherwise NULL
+
+ """
+ void *edbus_connection_data_get(self.conn, const char
*key) EINA_ARG_NONNULL(1, 2)
+
+ def data_del(self, key):
+ """
+
+ Del data stored in connection.
+
+ :param key: that identifies data
+
+ :return: pointer to data if found otherwise NULL
+
+ """
+ void *edbus_connection_data_del(self.conn, const char
*key) EINA_ARG_NONNULL(1, 2)
+
+ def event_callback_add(self, event_type, cb, cb_data):
+ """
+
+ Add a callback function to be called when an event occurs of the
+ type passed.
+
+ """
+ edbus_connection_event_callback_add(self.conn,
EDBus_Connection_Event_Type type, EDBus_Connection_Event_Cb cb, const void
*cb_data) EINA_ARG_NONNULL(1, 3)
+
+ def event_callback_del(self, event_type, cb, cb_data):
+ """
+
+ Remove callback registered in edbus_connection_event_callback_add().
+
+ """
+ edbus_connection_event_callback_del(self.conn,
EDBus_Connection_Event_Type type, EDBus_Connection_Event_Cb cb, const void
*cb_data) EINA_ARG_NONNULL(1, 3)
+
+ def send(self, msg, cb, cb_data, timeout):
+ """
+
+ Send a message.
+
+ :param msg: message that will be sent
+ :param cb: if msg is a method call a callback should be passed
+ to be executed when a response arrives
+ :param cb_data: data passed to callback
+ :param timeout: timeout in milliseconds, -1 to use default internal
value or
+ EDBUS_TIMEOUT_INFINITE for no timeout
+
+ """
+ EDBus_Pending *edbus_connection_send(self.conn, EDBus_Message *msg,
EDBus_Message_Cb cb, const void *cb_data, double timeout) EINA_ARG_NONNULL(1, 2)
diff --git a/efl/edbus/edbus.pxd b/efl/edbus/edbus.pxd
index 2643aef..bcd064b 100644
--- a/efl/edbus/edbus.pxd
+++ b/efl/edbus/edbus.pxd
@@ -13,6 +13,11 @@ cdef extern from "EDBus.h":
#define EDBUS_FDO_INTEFACE_PEER "org.freedesktop.DBus.Peer"
#define EDBUS_ERROR_PENDING_CANCELED "org.enlightenment.DBus.Canceled"
+ int edbus_init()
+ int edbus_shutdown()
+
+ ctypedef void (*EDBus_Free_Cb)(void *data, const
void *deadptr)
+
ctypedef struct _EDBus_Connection EDBus_Connection
ctypedef struct _EDBus_Object EDBus_Object
ctypedef struct _EDBus_Proxy EDBus_Proxy
@@ -24,9 +29,6 @@ cdef extern from "EDBus.h":
ctypedef void (*EDBus_Message_Cb)(void *data, const EDBus_Message *msg,
EDBus_Pending *pending)
ctypedef void (*EDBus_Signal_Cb)(void *data, const EDBus_Message *msg)
- int edbus_init()
- int edbus_shutdown()
-
# edbus_connection.h
#define EDBUS_TIMEOUT_INFINITE ((int) 0x7fffffff)
diff --git a/efl/edbus/edbus.pyx b/efl/edbus/edbus.pyx
index 6b50376..73e7de3 100644
--- a/efl/edbus/edbus.pyx
+++ b/efl/edbus/edbus.pyx
@@ -23,13 +23,6 @@ library, which is a message bus system. It also implements a
set of
specifications using dbus as interprocess communication.
"""
-cimport enums
-
-EDBUS_CONNECTION_TYPE_UNKNOWN = enums.EDBUS_CONNECTION_TYPE_UNKNOWN
-EDBUS_CONNECTION_TYPE_SESSION = enums.EDBUS_CONNECTION_TYPE_SESSION
-EDBUS_CONNECTION_TYPE_SYSTEM = enums.EDBUS_CONNECTION_TYPE_SYSTEM
-EDBUS_CONNECTION_TYPE_STARTER = enums.EDBUS_CONNECTION_TYPE_STARTER
-EDBUS_CONNECTION_TYPE_LAST = enums.EDBUS_CONNECTION_TYPE_LAST
def module_cleanup():
edbus_shutdown()
@@ -37,3 +30,6 @@ def module_cleanup():
edbus_init()
atexit.register(module_cleanup)
+include "connection.pxi"
+include "message.pxi"
+include "signal_handler.pxi"
diff --git a/efl/edbus/message.pxi b/efl/edbus/message.pxi
new file mode 100644
index 0000000..ada4554
--- /dev/null
+++ b/efl/edbus/message.pxi
@@ -0,0 +1,403 @@
+cdef class Message(object):
+
+ cdef EDBus_Message *msg
+
+ def ref(self):
+ """
+
+ Increase message reference.
+
+ """
+ # NOTE: returns EDBus_Message *
+ edbus_message_ref(self.msg)
+ return self
+
+ def unref(self):
+ """
+
+ Decrease message reference.
+
+ When refcount reaches zero the message and all its resources will be
+ freed.
+
+ """
+ edbus_message_unref(self.msg)
+
+ property path:
+ def __get__(self):
+ const char *edbus_message_path_get(self.msg)
+
+ property interface:
+ def __get__(self):
+ const char *edbus_message_interface_get(self.msg)
+
+ property member:
+ def __get__(self):
+ const char *edbus_message_member_get(self.msg)
+
+ property destination:
+ def __get__(self):
+ const char *edbus_message_destination_get(self.msg)
+
+ property sender:
+ def __get__(self):
+ const char *edbus_message_sender_get(self.msg)
+
+ property signature:
+ def __get__(self):
+ const char *edbus_message_signature_get(self.msg)
+
+ @classmethod
+ def method_call_new(cls, dest, path, iface, method):
+ """
+
+ Create a new message to invoke a method on a remote object.
+
+ :param dest: bus name or unique id of the remote application
+ :param path: object path
+ :param iface: interface name
+ :param method: name of the method to be called
+
+ @return a new EDBus_Message, free with edbus_message_unref()
+
+ """
+ EDBus_Message *edbus_message_method_call_new(const char *dest,
const char *path, const char *iface, const char *method) EINA_ARG_NONNULL(1, 2,
3, 4) EINA_WARN_UNUSED_RESULT EINA_MALLOC
+
+ @classmethod
+ def error_new(cls, msg, error_name, error_msg):
+ """
+
+ Create a new message that is an error reply to another message.
+
+ :param msg: the message we're replying to
+ :param error_name: the error name
+ :param error_msg: the error message string
+
+ @return a new EDBus_Message, free with edbus_message_unref()
+
+ """
+ EDBus_Message *edbus_message_error_new( const EDBus_Message
*msg, const char *error_name, const char *error_msg) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
+
+ @classmethod
+ def method_return_new(cls, msg):
+ """
+
+ Create a message that is a reply to a method call.
+
+ :param msg: the message we're replying to
+
+ @return new EDBus_Message, free with edbus_message_unref()
+
+ """
+ EDBus_Message *edbus_message_method_return_new( const
EDBus_Message *msg) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT
+
+
+ def error_get(self, name, text):
+ """
+
+ Get the error text and name from a EDBus_Message.
+
+ If :param msg: is an error message return EINA_TRUE and fill in the
name and
+ text of the error.
+
+ :param name: Variable in which to store the error name or @c NULL if
it's not
+ desired.
+ :param text: Variable in which to store the error text or @c NULL if
it's not
+ desired.
+
+ """
+ Eina_Bool edbus_message_error_get(self.msg, const char
**name, const char **text) EINA_ARG_NONNULL(1)
+
+ def arguments_get(self, signature, *args):
+ """
+
+ Get the arguments from an EDBus_Message
+
+ Get the arguments of an EDBus_Message storing them in the locations
pointed
+ to by the pointer arguments that follow :param signature:. Each pointer
+ argument must be of a type that is appropriate for the correspondent
complete
+ type in :param signature:. For complex types such as arrays, structs,
+ dictionaries or variants, a pointer to EDBus_Message_Iter* must be
provided.
+
+ :param signature: The signature of the arguments user is expecting to
read
+ @param ... The pointers in which to store the message arguments
+
+ @return EINA_TRUE if the arguments were read succesfully and stored in
the
+ respective pointer arguments.
+
+ """
+ Eina_Bool edbus_message_arguments_get(self.msg, const char
*signature, ...)
+
+ def arguments_vget(self, signature):
+ """
+
+ Get the arguments from an EDBus_Message using a va_list.
+
+ :param signature: The signature user is expecting to read from :param
msg:.
+ :param ap: The va_list containing the pointer arguments.
+
+ @see edbus_message_arguments_get()
+
+ @return EINA_TRUE if the arguments were read succesfully and stored in
the
+ respective pointer arguments.
+
+ """
+ Eina_Bool edbus_message_arguments_vget(self.msg, const
char *signature, va_list ap)
+
+ def arguments_append(self, signature, *args):
+ """
+
+ Append arguments into an EDBus_Message
+
+ Append arguments into an EDBus_Message according to the :param
signature:
+ provided. For each complete type in :param signature:, a value of the
+ corresponding type must be provided.
+
+ This function supports only basic types. For complex types use
+ edbus_message_iter_* family of functions.
+
+ :param signature: Signature of the arguments that are being appended.
+ @param ... Values of each argument to append in :param msg:.
+
+ @return EINA_TRUE on success, EINA_FALSE otherwise.
+
+ """
+ Eina_Bool edbus_message_arguments_append(self.msg, const
char *signature, ...)
+
+ def arguments_vappend(self, signature, va_list_ap):
+ """
+
+ Append arguments into an EDBus_Message using a va_list.
+
+ :param signature: Signature of the arguments that are being appended.
+ :param ap: The va_list containing the arguments to append.
+
+ @see edbus_message_arguments_append().
+
+ @return EINA_TRUE on success, EINA_FALSE otherwise.
+
+ """
+ Eina_Bool edbus_message_arguments_vappend(self.msg, const
char *signature, va_list ap)
+
+cdef class MessageIterator(object):
+
+ """
+
+ Create and append a typed iterator to another iterator.
+
+ After append data to returned iterator it must be closed calling
+ edbus_message_iter_container_close().
+
+ Container types are for example struct, variant, and array.
+ For variants, the contained_signature should be the type of the single
+ value inside the variant. For structs and dict entries,
contained_signature
+ should be NULL; it will be set to whatever types you write into the
struct.
+ For arrays, contained_signature should be the type of the array
elements.
+
+ :param iter: parent of the new iterator
+ :param type: of iterator (e.g struct, dict, variant or array)
+ :param contained_signature: signature of what iterator will store
+
+ @return the new iterator
+
+ """
+ EDBus_Message_Iter
*edbus_message_iter_container_new(EDBus_Message_Iter *iter, int type, const
char* contained_signature) EINA_ARG_NONNULL(1, 3) EINA_WARN_UNUSED_RESULT
+
+
+ """
+
+ Append a basic type into an EDBus_Iterator.
+
+ """
+ Eina_Bool
edbus_message_iter_basic_append(EDBus_Message_Iter *iter, int type, ...)
EINA_ARG_NONNULL(1, 3)
+
+
+ """
+
+ Append an argument into an EDBus_Message_Iter. For each complete type
+ you need to provide the correspondent value. In case of complex types
you
+ need to provide an EDBus_Message_Iter** to be allocated and then
filled in.
+
+ It's not possible to open two iterators at same iterator with this
function.
+ For example, to create a message with signature="aiai" you need to
create the
+ first container with edbus_message_iter_container_new(), fill the
array,
+ close it with edbus_message_iter_container_close() and then do the
same for
+ the second array.
+
+ :param iter: iterator in which data will be appended
+ :param signature: signature of the contained data
+ @param ... values for each complete type
+
+ @see edbus_message_iter_container_new()
+ @see edbus_message_iter_container_close()
+
+ @note This function doesn't support variant, use
+ edbus_message_iter_container_new() instead to create the variant, fill
+ with data and close it.
+
+ """
+ Eina_Bool
edbus_message_iter_arguments_append(EDBus_Message_Iter *iter, const char
*signature, ...) EINA_ARG_NONNULL(1, 2)
+
+
+ """
+
+ Set data to EDBus_Message_Iter. For each complete in signature
+ you need pass the value, in case of complex type a pointer to be
allocated a
+ EDBus_Message_Iter that you need fill and close.
+
+ It's not possible open two iterators at same Iterator. Example:
+ "aiai", to set this you need create and put the first array with
+ edbus_message_iter_container_new() fill array with data and close then
+ you could open the second array with
edbus_message_iter_container_new().
+
+ :param iter: iterator
+ :param signature: of data
+ :param ap: va_list with the values
+
+ @note This function don't support variant, use instead
+ edbus_message_iter_container_new() to create the variant fill
+ data and close it.
+
+ """
+ Eina_Bool
edbus_message_iter_arguments_vappend(EDBus_Message_Iter *iter, const char
*signature, va_list ap) EINA_ARG_NONNULL(1, 2, 3)
+
+
+ """
+
+ Closes a container-typed value appended to the message.
+
+ :param iter: parent of the sub-iterator
+ :param sub: the iterator that will be closed
+
+ @return EINA_FALSE if iterator was already close or if not enough
memory
+
+ """
+ Eina_Bool
edbus_message_iter_container_close(EDBus_Message_Iter *iter, EDBus_Message_Iter
*sub) EINA_ARG_NONNULL(1, 2)
+
+
+ """
+
+ Get the main EDBus_Message_Iter from the EDBus_Message.
+
+ """
+ EDBus_Message_Iter *edbus_message_iter_get( const EDBus_Message *msg)
EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT
+
+
+ """
+
+ Get a basic type from EDBus_Iterator.
+
+ """
+ void
edbus_message_iter_basic_get(EDBus_Message_Iter *iter, void *value)
EINA_ARG_NONNULL(1, 2)
+
+
+ """
+
+ Returns the current signature of a message iterator.
+
+ @note The returned string must be freed.
+
+ """
+ char
*edbus_message_iter_signature_get(EDBus_Message_Iter *iter) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
+
+
+ """
+
+ Moves the iterator to the next field, if any.
+ :param iter: iterator
+
+ @return if iterator was reach to end return EINA_FALSE
+
+ """
+ Eina_Bool edbus_message_iter_next(EDBus_Message_Iter
*iter) EINA_ARG_NONNULL(1)
+
+
+ """
+
+ Get a complete type from EDBus_Message_Iter if is not at the end
+ of iterator and move to next field.
+ Useful to iterate over arrays.
+
+ :param iter: iterator
+ :param type: of the next completed type in Iterator
+ @param ... pointer of where data will be stored
+
+ :param if: iterator was reach to end or if type different of the type
that
+ iterator points return EINA_FALSE
+
+
+ """
+ Eina_Bool
edbus_message_iter_get_and_next(EDBus_Message_Iter *iter, char type, ...)
EINA_ARG_NONNULL(1, 2, 3)
+
+
+ """
+
+ Reads a block of fixed-length values from the message iterator.
+
+ Fixed-length values are those basic types that are not string-like,
+ such as integers, bool, double. The returned block will be from the
+ current position in the array until the end of the array.
+
+ There is one exception here: although EDBUS_TYPE_UNIX_FD is considered
a
+ 'fixed' type arrays of this type may not be read with this function.
+
+ The value argument should be the address of a location to store the
returned
+ array. So for int32 it should be a "const dbus_int32_t**" The returned
value
+ is by reference and should not be freed.
+
+ Because the array is not copied, this function runs in constant time
and is
+ fast; it's much preferred over walking the entire array with an
iterator.
+
+ """
+ Eina_Bool edbus_message_iter_fixed_array_get(EDBus_Message_Iter *iter,
int signature, void *value, int *n_elements) EINA_ARG_NONNULL(1, 3, 4)
+
+
+ """
+
+ Get data from EDBus_Message_Iter, for each complete type must have
+ a pointer to store his value, in case of complex type a
+ EDBus_Message_Iter will be need.
+
+ :param iter: iterator
+ :param signature: of the complete data types on interator
+ @param ... pointers of where data will be stored
+
+ @return EINA_FALSE if signature different from signature in iterator
+
+ """
+ Eina_Bool
edbus_message_iter_arguments_get(EDBus_Message_Iter *iter, const char
*signature, ...) EINA_ARG_NONNULL(1, 2)
+
+
+ """
+
+ Get data from EDBus_Message_Iter, for each complete type must have
+ a pointer to store his value, in case of complex type a
+ EDBus_Message_Iter will be need.
+
+ :param iter: iterator
+ :param signature: of the complete data types on interator
+ :param ap: va_list of the pointers of where data will be stored
+
+ @return EINA_FALSE if signature different from signature in iterator
+
+ """
+ Eina_Bool
edbus_message_iter_arguments_vget(EDBus_Message_Iter *iter, const char
*signature, va_list ap) EINA_ARG_NONNULL(1, 2)
+
+
+ """
+
+ Manually delete the iterator.
+
+ Iterators are usually bound to the life of @ref EDBus_Message
+ they were created from, being deleted automatically once the
+ message is deleted.
+
+ However when dealing with huge arrays or dicts it may become a
+ major memory impact to leave the unused iterators alive. By
+ calling this function one states the iterator is not used anymore
+ and can be deleted.
+
+ :param iter: the iterator to be deleted.
+
+ """
+ void edbus_message_iter_del(EDBus_Message_Iter *iter)
EINA_ARG_NONNULL(1)
diff --git a/efl/edbus/signal_handler.pxi b/efl/edbus/signal_handler.pxi
new file mode 100644
index 0000000..3007d2b
--- /dev/null
+++ b/efl/edbus/signal_handler.pxi
@@ -0,0 +1,130 @@
+cdef class SignalHandler(object):
+
+ cdef EDBus_Signal_Handler *handler
+
+ def __init__(self, Connection edbus_conn not None, sender, path,
interface, member, cb, cb_data):
+ """
+
+ Add a signal handler.
+
+ :param conn: connection where the signal is emitted
+ :param sender: bus name or unique id of where the signal is emitted
+ :param path: path of remote object
+ :param interface: that signal belongs
+ :param member: name of the signal
+ :param cb: callback that will be called when this signal is received
+ :param cb_data: data that will be passed to callback
+
+ """
+ self.handler = edbus_signal_handler_add(edbus_conn.conn, const char
*sender, const char *path, const char *interface, const char *member,
EDBus_Signal_Cb cb, const void *cb_data) EINA_ARG_NONNULL(1, 6)
+
+ def ref(self):
+ """
+
+ Increase signal handler reference.
+
+ """
+ # NOTE: Returns EDBus_Signal_Handler *
+ edbus_signal_handler_ref(self.handler)
+ return self
+
+ def unref(self):
+ """
+
+ Decrease signal handler reference.
+ If reference == 0 signal handler will be freed.
+
+ """
+ edbus_signal_handler_unref(self.handler)
+
+ def delete(self):
+ """
+
+ Decrease signal handler reference like edbus_signal_handler_unref()
+ but if reference > 0 this signal handler will stop listening to
signals. In other
+ words it will be canceled but memory will not be freed.
+
+ """
+ edbus_signal_handler_del(self.handler)
+
+ def match_extra_set(self, *args):
+ """
+
+ Add extra argument in match of signal handler to obtain specifics
signals.
+
+ Example:
+ edbus_signal_handler_match_extra_set(sh, "arg0",
"org.bansheeproject.Banshee", "arg1", "", NULL);
+ With this extra arguments this signal handler callback only will be
called
+ when Banshee is started.
+
+ @note For now only argX is supported.
+
+ :param sh: signal handler
+ :param ...: variadic of key and value and must be ended with a NULL
+
+ @note For more information:
+
http://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-routing-match-rules
+
+ """
+ Eina_Bool
edbus_signal_handler_match_extra_set(self.handler, ...) EINA_ARG_NONNULL(1)
EINA_SENTINEL
+
+ def match_extra_vset(self, ap):
+ """
+
+ Add extra argument in match of signal handler to obtain specifics
signals.
+
+ Example:
+ edbus_signal_handler_match_extra_set(sh, "arg0",
"org.bansheeproject.Banshee", "arg1", "", NULL);
+ With this extra arguments this signal handler callback only will be
called
+ when Banshee is started.
+
+ @note For now is only supported argX.
+
+ :param sh: signal handler
+ :param ap: va_list with the keys and values, must be ended with a NULL
+
+ @note To information:
+
http://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-routing-match-rules
+
+ """
+ Eina_Bool
edbus_signal_handler_match_extra_vset(self.handler, va_list ap)
EINA_ARG_NONNULL(1)
+
+ def free_cb_add(self, cb, cb_data):
+ """
+
+ Add a callback function to be called when signal handler will be freed.
+
+ """
+ void edbus_signal_handler_free_cb_add(self.handler,
EDBus_Free_Cb cb, const void *data) EINA_ARG_NONNULL(1, 2)
+
+ def free_cb_del(self, cb, cb_data):
+ """
+
+ Remove callback registered in edbus_signal_handler_free_cb_add().
+
+ """
+ void edbus_signal_handler_free_cb_del(self.handler,
EDBus_Free_Cb cb, const void *data) EINA_ARG_NONNULL(1, 2)
+
+ property sender:
+ def __get__(self):
+ const char
*edbus_signal_handler_sender_get(self.handler) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
+
+ property path:
+ def __get__(self):
+ const char *edbus_signal_handler_path_get(self.handler)
EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT
+
+ property interface:
+ def __get__(self):
+ const char
*edbus_signal_handler_interface_get(self.handler) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
+
+ property member:
+ def __get__(self):
+ const char
*edbus_signal_handler_member_get(self.handler) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
+
+ property match:
+ def __get__(self):
+ const char *edbus_signal_handler_match_get(self.handler)
EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT
+
+ property connection:
+ def __get__(self):
+ EDBus_Connection
*edbus_signal_handler_connection_get(self.handler) EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT
--
------------------------------------------------------------------------------
Minimize network downtime and maximize team effectiveness.
Reduce network management and security costs.Learn how to hire
the most talented Cisco Certified professionals. Visit the
Employer Resources Portal
http://www.cisco.com/web/learning/employer_resources/index.html
