Commit 033b73e2 authored by Michael Albinus's avatar Michael Albinus

* config.in (HAVE_DBUS): Add.

* Makefile.in: (HAVE_DBUS): Add D-Bus definitions if defined.
(ALL_CFLAGS): Add ${DBUS_CFLAGS}.
(obj): Add $(DBUS_OBJ).
(LIBES): Add $(DBUS_LIBS).
(dbusbind.o): New target.

* dbusbind.c: New file.

* emacs.c (main): Call syms_of_dbusbind when HAVE_DBUS is defined.

* keyboard.c: All D-Bus related code is wrapped by "#ifdef HAVE_DBUS".
(Qdbus_event) New Lisp symbol.
(kbd_buffer_get_event, make_lispy_event): Handle DBUS_EVENT.
(gobble_input): Call xd_read_queued_messages, reading D-Bus
messages.
(keys_of_keyboard ): Define dbus-event.

* termhooks.h (event_kind): Add DBUS_EVENT when HAVE_DBUS is defined.
parent 131e4133
2007-12-02 Michael Albinus <michael.albinus@gmx.de>
* config.in (HAVE_DBUS): Add.
* Makefile.in: (HAVE_DBUS): Add D-Bus definitions if defined.
(ALL_CFLAGS): Add ${DBUS_CFLAGS}.
(obj): Add $(DBUS_OBJ).
(LIBES): Add $(DBUS_LIBS).
(dbusbind.o): New target.
* dbusbind.c: New file.
* emacs.c (main): Call syms_of_dbusbind when HAVE_DBUS is defined.
* keyboard.c: All D-Bus related code is wrapped by "#ifdef HAVE_DBUS".
(Qdbus_event) New Lisp symbol.
(kbd_buffer_get_event, make_lispy_event): Handle DBUS_EVENT.
(gobble_input): Call xd_read_queued_messages, reading D-Bus
messages.
(keys_of_keyboard ): Define dbus-event.
* termhooks.h (event_kind): Add DBUS_EVENT when HAVE_DBUS is defined.
2007-12-01 Richard Stallman <rms@gnu.org>
* search.c (syms_of_search) <inhibit-changing-match-data>: Doc fix.
......
......@@ -262,6 +262,12 @@ TOOLKIT_DEFINES =
#endif
#endif
#ifdef HAVE_DBUS
DBUS_CFLAGS = @DBUS_CFLAGS@
DBUS_LIBS = @DBUS_LIBS@
DBUS_OBJ = dbusbind.o
#endif
/* DO NOT use -R. There is a special hack described in lastfile.c
which is used instead. Some initialized data areas are modified
at initial startup, then labeled as part of the text area when
......@@ -275,7 +281,7 @@ TOOLKIT_DEFINES =
/* C_SWITCH_X_SITE must come before C_SWITCH_X_MACHINE and C_SWITCH_X_SYSTEM
since it may have -I options that should override those two. */
ALL_CFLAGS=-Demacs -DHAVE_CONFIG_H $(TOOLKIT_DEFINES) $(MYCPPFLAGS) -I. -I${srcdir} C_SWITCH_MACHINE C_SWITCH_SYSTEM C_SWITCH_SITE C_SWITCH_X_SITE C_SWITCH_X_MACHINE C_SWITCH_X_SYSTEM C_SWITCH_SYSTEM_TEMACS ${CFLAGS_SOUND} ${RSVG_CFLAGS} ${CFLAGS}
ALL_CFLAGS=-Demacs -DHAVE_CONFIG_H $(TOOLKIT_DEFINES) $(MYCPPFLAGS) -I. -I${srcdir} C_SWITCH_MACHINE C_SWITCH_SYSTEM C_SWITCH_SITE C_SWITCH_X_SITE C_SWITCH_X_MACHINE C_SWITCH_X_SYSTEM C_SWITCH_SYSTEM_TEMACS ${CFLAGS_SOUND} ${RSVG_CFLAGS} ${DBUS_CFLAGS} ${CFLAGS}
.c.o:
$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
......@@ -588,7 +594,7 @@ emacsappsrc = ${srcdir}/../mac/Emacs.app/
whose initialized data areas should be dumped as pure by dump-emacs. */
obj= dispnew.o frame.o scroll.o xdisp.o $(XMENU_OBJ) window.o \
charset.o coding.o category.o ccl.o \
cm.o term.o terminal.o xfaces.o $(XOBJ) $(GTK_OBJ)\
cm.o term.o terminal.o xfaces.o $(XOBJ) $(GTK_OBJ) $(DBUS_OBJ) \
emacs.o keyboard.o macros.o keymap.o sysdep.o \
buffer.o filelock.o insdel.o marker.o \
minibuf.o fileio.o dired.o filemode.o \
......@@ -938,8 +944,8 @@ SOME_MACHINE_LISP = ${dotdot}/lisp/mouse.elc \
Note that SunOS needs -lm to come before -lc; otherwise, you get
duplicated symbols. If the standard libraries were compiled
with GCC, we might need gnulib again after them. */
LIBES = $(LOADLIBES) $(LIBS) $(LIBX) $(LIBSOUND) $(RSVG_LIBS) LIBGPM \
LIBRESOLV LIBS_SYSTEM LIBS_MACHINE LIBS_TERMCAP \
LIBES = $(LOADLIBES) $(LIBS) $(LIBX) $(LIBSOUND) $(RSVG_LIBS) $(DBUS_LIBS) \
LIBGPM LIBRESOLV LIBS_SYSTEM LIBS_MACHINE LIBS_TERMCAP \
LIBS_DEBUG $(GETLOADAVG_LIBS) $(GNULIB_VAR) LIB_MATH LIB_STANDARD \
$(GNULIB_VAR)
......@@ -1228,9 +1234,10 @@ xselect.o: xselect.c process.h dispextern.h frame.h xterm.h blockinput.h \
xrdb.o: xrdb.c $(config_h) epaths.h
xsmfns.o: xsmfns.c $(config_h) systime.h sysselect.h termhooks.h xterm.h \
lisp.h termopts.h
gtkutil.o: gtkutil.c gtkutil.h xterm.h lisp.h frame.h $(config_h) \
gtkutil.o: gtkutil.c gtkutil.h xterm.h lisp.h frame.h $(config_h) \
blockinput.h window.h atimer.h systime.h termhooks.h keyboard.h \
charset.h coding.h
dbusbind.o: dbusbind.c termhooks.h $(config_h)
hftctl.o: hftctl.c $(config_h)
sound.o: sound.c dispextern.h $(config_h)
......
......@@ -238,6 +238,9 @@ Boston, MA 02110-1301, USA. */
/* Define to 1 if you have the `grantpt' function. */
#undef HAVE_GRANTPT
/* Define to 1 if using D-BUS. */
#undef HAVE_DBUS
/* Define to 1 if using GTK. */
#undef HAVE_GTK
......
/* Elisp bindings for D-Bus.
Copyright (C) 2007 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
#include "config.h"
#ifdef HAVE_DBUS
#include <stdlib.h>
#include <dbus/dbus.h>
#include "lisp.h"
#include "frame.h"
#include "termhooks.h"
#include "keyboard.h"
/* Subroutines. */
Lisp_Object Qdbus_get_unique_name;
Lisp_Object Qdbus_call_method;
Lisp_Object Qdbus_send_signal;
Lisp_Object Qdbus_register_signal;
Lisp_Object Qdbus_unregister_signal;
/* D-Bus error symbol. */
Lisp_Object Qdbus_error;
/* Lisp symbols of the system and session buses. */
Lisp_Object Qdbus_system_bus, Qdbus_session_bus;
/* Obarray which keeps interned symbols. */
Lisp_Object Vdbus_intern_symbols;
/* Whether to debug D-Bus. */
Lisp_Object Vdbus_debug;
/* We use "xd_" and "XD_" as prefix for all internal symbols, because
we don't want to poison other namespaces with "dbus_". */
/* Create a new interned symbol which represents a function handler.
bus is a Lisp symbol, either :system or :session. interface and
member are both Lisp strings.
D-Bus sends messages, which are captured by Emacs in the main loop,
converted into an event then. Emacs must identify a message from
D-Bus, in order to call the right Lisp function when the event is
handled in the event handler function of dbus.el.
A D-Bus message is determined at least by the D-Bus bus it is
raised from (system bus or session bus), the interface and the
method the message belongs to. There could be even more properties
for determination, but that isn't implemented yet.
The approach is to create a new interned Lisp symbol once there is
a registration request for a given signal, which is a special D-Bus
message. The symbol's name is a concatenation of the bus name,
interface name and method name of the signal; the function cell is
the Lisp function to be called when such a signal arrives. Since
this code runs in the main loop, receiving input, it must be
performant. */
#define XD_SYMBOL_INTERN_SYMBOL(symbol, bus, interface, member) \
{ \
XD_DEBUG_VALID_LISP_OBJECT_P (bus); \
XD_DEBUG_VALID_LISP_OBJECT_P (interface); \
XD_DEBUG_VALID_LISP_OBJECT_P (member); \
char s[1024]; \
strcpy (s, SDATA (SYMBOL_NAME (bus))); \
strcat (s, "."); \
strcat (s, SDATA (interface)); \
strcat (s, "."); \
strcat (s, SDATA (member)); \
symbol = Fintern (build_string (s), Vdbus_intern_symbols); \
}
/* Raise a Lisp error from a D-Bus error. */
#define XD_ERROR(error) \
{ \
char s[1024]; \
strcpy (s, error.message); \
dbus_error_free (&error); \
/* Remove the trailing newline. */ \
if (strchr (s, '\n') != NULL) \
s[strlen (s) - 1] = '\0'; \
xsignal1 (Qdbus_error, build_string (s)); \
}
/* Macros for debugging. In order to enable them, build with
"make MYCPPFLAGS='-DDBUS_DEBUG'". */
#ifdef DBUS_DEBUG
#define XD_DEBUG_MESSAGE(...) \
{ \
char s[1024]; \
sprintf (s, __VA_ARGS__); \
printf ("%s: %s\n", __func__, s); \
message ("%s: %s", __func__, s); \
}
#define XD_DEBUG_VALID_LISP_OBJECT_P(object) \
if (!valid_lisp_object_p (object)) \
{ \
XD_DEBUG_MESSAGE ("%s Assertion failure", __LINE__); \
xsignal1 (Qdbus_error, build_string ("Assertion failure")); \
}
#else /* !DBUS_DEBUG */
#define XD_DEBUG_MESSAGE(...) \
if (!NILP (Vdbus_debug)) \
{ \
char s[1024]; \
sprintf (s, __VA_ARGS__); \
message ("%s: %s", __func__, s); \
}
#define XD_DEBUG_VALID_LISP_OBJECT_P(object)
#endif
/* Determine the DBusType of a given Lisp object. It is used to
convert Lisp objects, being arguments of `dbus-call-method' or
`dbus-send-signal', into corresponding C values appended as
arguments to a D-Bus message. */
#define XD_LISP_OBJECT_TO_DBUS_TYPE(object) \
(EQ (object, Qt) || EQ (object, Qnil)) ? DBUS_TYPE_BOOLEAN : \
(NATNUMP (object)) ? DBUS_TYPE_UINT32 : \
(INTEGERP (object)) ? DBUS_TYPE_INT32 : \
(FLOATP (object)) ? DBUS_TYPE_DOUBLE : \
(STRINGP (object)) ? DBUS_TYPE_STRING : \
DBUS_TYPE_INVALID
/* Extract C value from Lisp OBJECT. DTYPE must be a valid DBusType,
as detected by XD_LISP_OBJECT_TO_DBUS_TYPE. Compound types are not
supported (yet). It is used to convert Lisp objects, being
arguments of `dbus-call-method' or `dbus-send-signal', into
corresponding C values appended as arguments to a D-Bus
message. */
char *
xd_retrieve_value (dtype, object)
uint dtype;
Lisp_Object object;
{
XD_DEBUG_VALID_LISP_OBJECT_P (object);
switch (dtype)
{
case DBUS_TYPE_BOOLEAN:
XD_DEBUG_MESSAGE ("%d %s", dtype, (NILP (object)) ? "false" : "true");
return (NILP (object)) ? (char *) FALSE : (char *) TRUE;
case DBUS_TYPE_UINT32:
XD_DEBUG_MESSAGE ("%d %d", dtype, XUINT (object));
return (char *) XUINT (object);
case DBUS_TYPE_INT32:
XD_DEBUG_MESSAGE ("%d %d", dtype, XINT (object));
return (char *) XINT (object);
case DBUS_TYPE_DOUBLE:
XD_DEBUG_MESSAGE ("%d %d", dtype, XFLOAT (object));
return (char *) XFLOAT (object);
case DBUS_TYPE_STRING:
XD_DEBUG_MESSAGE ("%d %s", dtype, SDATA (object));
return SDATA (object);
default:
XD_DEBUG_MESSAGE ("DBus-Type %d not supported", dtype);
return NULL;
}
}
/* Retrieve C value from a DBusMessageIter structure ITER, and return
a converted Lisp object. The type DTYPE of the argument of the
D-Bus message must be a valid DBusType. Compound D-Bus types are
partly supported; they result always in a Lisp list. */
Lisp_Object
xd_retrieve_arg (dtype, iter)
uint dtype;
DBusMessageIter *iter;
{
switch (dtype)
{
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t val;
dbus_message_iter_get_basic (iter, &val);
XD_DEBUG_MESSAGE ("%d %s", dtype, (val == FALSE) ? "false" : "true");
return (val == FALSE) ? Qnil : Qt;
}
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
{
dbus_uint32_t val;
dbus_message_iter_get_basic (iter, &val);
XD_DEBUG_MESSAGE ("%d %d", dtype, val);
return make_number (val);
}
case DBUS_TYPE_STRING:
case DBUS_TYPE_OBJECT_PATH:
{
char *val;
dbus_message_iter_get_basic (iter, &val);
XD_DEBUG_MESSAGE ("%d %s", dtype, val);
return build_string (val);
}
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_VARIANT:
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_DICT_ENTRY:
{
Lisp_Object result;
struct gcpro gcpro1;
result = Qnil;
GCPRO1 (result);
DBusMessageIter subiter;
int subtype;
dbus_message_iter_recurse (iter, &subiter);
while ((subtype = dbus_message_iter_get_arg_type (&subiter))
!= DBUS_TYPE_INVALID)
{
result = Fcons (xd_retrieve_arg (subtype, &subiter), result);
dbus_message_iter_next (&subiter);
}
RETURN_UNGCPRO (Fnreverse (result));
}
default:
XD_DEBUG_MESSAGE ("DBusType %d not supported", dtype);
return Qnil;
}
}
/* Initialize D-Bus connection. BUS is a Lisp symbol, either :system
or :session. It tells which D-Bus to be initialized. */
DBusConnection *
xd_initialize (bus)
Lisp_Object bus;
{
DBusConnection *connection;
DBusError derror;
/* Parameter check. */
CHECK_SYMBOL (bus);
if (!((EQ (bus, Qdbus_system_bus)) || (EQ (bus, Qdbus_session_bus))))
xsignal2 (Qdbus_error, build_string ("Wrong bus name"), bus);
/* Open a connection to the bus. */
dbus_error_init (&derror);
if (EQ (bus, Qdbus_system_bus))
connection = dbus_bus_get (DBUS_BUS_SYSTEM, &derror);
else
connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
if (dbus_error_is_set (&derror))
XD_ERROR (derror);
if (connection == NULL)
xsignal2 (Qdbus_error, build_string ("No connection"), bus);
/* Return the result. */
return connection;
}
DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
1, 1, 0,
doc: /* Return the unique name of Emacs registered at D-Bus BUS as string. */)
(bus)
Lisp_Object bus;
{
DBusConnection *connection;
char name[1024];
/* Check parameters. */
CHECK_SYMBOL (bus);
/* Open a connection to the bus. */
connection = xd_initialize (bus);
/* Request the name. */
strcpy (name, dbus_bus_get_unique_name (connection));
if (name == NULL)
xsignal1 (Qdbus_error, build_string ("No unique name available"));
/* Return. */
return build_string (name);
}
DEFUN ("dbus-call-method", Fdbus_call_method, Sdbus_call_method, 5, MANY, 0,
doc: /* Call METHOD on the D-Bus BUS.
BUS is either the symbol `:system' or the symbol `:session'.
SERVICE is the D-Bus service name to be used. PATH is the D-Bus
object path SERVICE is registered at. INTERFACE is an interface
offered by SERVICE. It must provide METHOD.
All other arguments ARGS are passed to METHOD as arguments. They are
converted into D-Bus types via the following rules:
t and nil => DBUS_TYPE_BOOLEAN
number => DBUS_TYPE_UINT32
integer => DBUS_TYPE_INT32
float => DBUS_TYPE_DOUBLE
string => DBUS_TYPE_STRING
Other Lisp objects are not supported as input arguments of METHOD.
`dbus-call-method' returns the resulting values of METHOD as a list of
Lisp objects. The type conversion happens the other direction as for
input arguments. Additionally to the types supported for input
arguments, the D-Bus compound types DBUS_TYPE_ARRAY, DBUS_TYPE_VARIANT,
DBUS_TYPE_STRUCT and DBUS_TYPE_DICT_ENTRY are accepted. All of them
are converted into a list of Lisp objects which correspond to the
elements of the D-Bus container. Example:
\(dbus-call-method
:session "GetKeyField" "org.gnome.seahorse"
"/org/gnome/seahorse/keys/openpgp" "org.gnome.seahorse.Keys"
"openpgp:657984B8C7A966DD" "simple-name")
=> (t ("Philip R. Zimmermann"))
If the result of the METHOD call is just one value, the converted Lisp
object is returned instead of a list containing this single Lisp object.
\(dbus-call-method
:system "GetPropertyString" "org.freedesktop.Hal"
"/org/freedesktop/Hal/devices/computer" "org.freedesktop.Hal.Device"
"system.kernel.machine")
=> "i686"
usage: (dbus-call-method BUS METHOD SERVICE PATH INTERFACE &rest ARGS) */)
(nargs, args)
int nargs;
register Lisp_Object *args;
{
Lisp_Object bus, method, service, path, interface;
Lisp_Object result;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
DBusConnection *connection;
DBusMessage *dmessage;
DBusMessage *reply;
DBusMessageIter iter;
DBusError derror;
uint dtype;
int i;
char *value;
/* Check parameters. */
bus = args[0];
method = args[1];
service = args[2];
path = args[3];
interface = args[4];
CHECK_SYMBOL (bus);
CHECK_STRING (method);
CHECK_STRING (service);
CHECK_STRING (path);
CHECK_STRING (interface);
GCPRO5 (bus, method, service, path, interface);
XD_DEBUG_MESSAGE ("%s %s %s %s",
SDATA (method),
SDATA (service),
SDATA (path),
SDATA (interface));
/* Open a connection to the bus. */
connection = xd_initialize (bus);
/* Create the message. */
dmessage = dbus_message_new_method_call (SDATA (service),
SDATA (path),
SDATA (interface),
SDATA (method));
if (dmessage == NULL)
{
UNGCPRO;
xsignal1 (Qdbus_error, build_string ("Unable to create a new message"));
}
UNGCPRO;
/* Append parameters to the message. */
for (i = 5; i < nargs; ++i)
{
XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
XD_DEBUG_MESSAGE ("Parameter%d %s",
i-4,
SDATA (format2 ("%s", args[i], Qnil)));
dtype = XD_LISP_OBJECT_TO_DBUS_TYPE (args[i]);
if (dtype == DBUS_TYPE_INVALID)
xsignal2 (Qdbus_error, build_string ("Not a valid argument"), args[i]);
value = (char *) xd_retrieve_value (dtype, args[i]);
if (!dbus_message_append_args (dmessage,
dtype,
&value,
DBUS_TYPE_INVALID))
xsignal2 (Qdbus_error,
build_string ("Unable to append argument"), args[i]);
}
/* Send the message. */
dbus_error_init (&derror);
reply = dbus_connection_send_with_reply_and_block (connection,
dmessage,
-1,
&derror);
if (dbus_error_is_set (&derror))
XD_ERROR (derror);
if (reply == NULL)
xsignal1 (Qdbus_error, build_string ("No reply"));
XD_DEBUG_MESSAGE ("Message sent");
/* Collect the results. */
result = Qnil;
GCPRO1 (result);
if (!dbus_message_iter_init (reply, &iter))
{
UNGCPRO;
xsignal1 (Qdbus_error, build_string ("Cannot read reply"));
}
/* Loop over the parameters of the D-Bus reply message. Construct a
Lisp list, which is returned by `dbus-call-method'. */
while ((dtype = dbus_message_iter_get_arg_type (&iter)) != DBUS_TYPE_INVALID)
{
result = Fcons (xd_retrieve_arg (dtype, &iter), result);
dbus_message_iter_next (&iter);
}
/* Cleanup. */
dbus_message_unref (dmessage);
dbus_message_unref (reply);
/* Return the result. If there is only one single Lisp object,
return it as-it-is, otherwise return the reversed list. */
if (XUINT (Flength (result)) == 1)
RETURN_UNGCPRO (XCAR (result));
else
RETURN_UNGCPRO (Fnreverse (result));
}
DEFUN ("dbus-send-signal", Fdbus_send_signal, Sdbus_send_signal, 5, MANY, 0,
doc: /* Send signal SIGNAL on the D-Bus BUS.
BUS is either the symbol `:system' or the symbol `:session'.
SERVICE is the D-Bus service name SIGNAL is sent from. PATH is the
D-Bus object path SERVICE is registered at. INTERFACE is an interface
offered by SERVICE. It must provide signal SIGNAL.
All other arguments ARGS are passed to SIGNAL as arguments. They are
converted into D-Bus types via the following rules:
t and nil => DBUS_TYPE_BOOLEAN
number => DBUS_TYPE_UINT32
integer => DBUS_TYPE_INT32
float => DBUS_TYPE_DOUBLE
string => DBUS_TYPE_STRING
Other Lisp objects are not supported as arguments of SIGNAL.
Example:
\(dbus-send-signal
:session "Started" "org.gnu.emacs" "/org/gnu/emacs" "org.gnu.emacs")))
usage: (dbus-send-signal BUS SIGNAL SERVICE PATH INTERFACE &rest ARGS) */)
(nargs, args)
int nargs;
register Lisp_Object *args;
{
Lisp_Object bus, signal, service, path, interface;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
DBusConnection *connection;
DBusMessage *dmessage;
uint dtype;
int i;
char *value;
/* Check parameters. */
bus = args[0];
signal = args[1];
service = args[2];
path = args[3];
interface = args[4];
CHECK_SYMBOL (bus);
CHECK_STRING (signal);
CHECK_STRING (service);
CHECK_STRING (path);
CHECK_STRING (interface);
GCPRO5 (bus, signal, service, path, interface);
XD_DEBUG_MESSAGE ("%s %s %s %s",
SDATA (signal),
SDATA (service),
SDATA (path),
SDATA (interface));
/* Open a connection to the bus. */
connection = xd_initialize (bus);
/* Create the message. */
dmessage = dbus_message_new_signal (SDATA (path),
SDATA (interface),
SDATA (signal));
if (dmessage == NULL)
{
UNGCPRO;
xsignal1 (Qdbus_error, build_string ("Unable to create a new message"));
}
UNGCPRO;
/* Append parameters to the message. */
for (i = 5; i < nargs; ++i)
{
XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
XD_DEBUG_MESSAGE ("Parameter%d %s",
i-4,
SDATA (format2 ("%s", args[i], Qnil)));
dtype = XD_LISP_OBJECT_TO_DBUS_TYPE (args[i]);
if (dtype == DBUS_TYPE_INVALID)
xsignal2 (Qdbus_error, build_string ("Not a valid argument"), args[i]);
value = (char *) xd_retrieve_value (dtype, args[i]);
if (!dbus_message_append_args (dmessage,
dtype,
&value,
DBUS_TYPE_INVALID))
xsignal2 (Qdbus_error,
build_string ("Unable to append argument"), args[i]);
}
/* Send the message. The message is just added to the outgoing
message queue. */
if (!dbus_connection_send (connection, dmessage, NULL))
xsignal1 (Qdbus_error, build_string ("Cannot send message"));
/* Flush connection to ensure the message is handled. */
dbus_connection_flush (connection);
XD_DEBUG_MESSAGE ("Signal sent");
/* Cleanup. */
dbus_message_unref (dmessage);
/* Return. */
return Qt;
}
/* Read queued incoming message of the D-Bus BUS. BUS is a Lisp
symbol, either :system or :session. */
void