fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-05-03 18:18:00 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

2003-08-14 Havoc Pennington <hp@redhat.com>

Browse source 
* dbus/dbus-pending-call.c: start on new object that will replace
	DBusMessageHandler and ReplyHandlerData for tracking outstanding
	replies

	* dbus/dbus-gproxy.c: start on proxy object used to communicate
	with remote interfaces

	* dbus/dbus-gidl.c: do the boring boilerplate in here
This commit is contained in:
Havoc Pennington 2003-08-14 22:49:13 +00:00
parent 9d1c3a0f84
commit a6c8a71b1b
10 changed files with 951 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
ChangeLog
View file

@ -1,3 +1,14 @@
2003-08-14 Havoc Pennington <hp@redhat.com>
* dbus/dbus-pending-call.c: start on new object that will replace
DBusMessageHandler and ReplyHandlerData for tracking outstanding
replies
* dbus/dbus-gproxy.c: start on proxy object used to communicate
with remote interfaces
* dbus/dbus-gidl.c: do the boring boilerplate in here
2003-08-12 Havoc Pennington <hp@pobox.com>
* bus/dispatch.c (bus_dispatch): make this return proper

225
dbus/dbus-pending-call.c Normal file
View file

@ -0,0 +1,225 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-pending-call.c Object representing a call in progress.
*
* Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-internals.h"
#include "dbus-message-pending.h"
#include "dbus-list.h"
#include "dbus-threads.h"
#include "dbus-test.h"
#include "dbus-connection-internal.h"
/**
* @defgroup DBusPendingCallInternals DBusPendingCall implementation details
* @ingroup DBusInternals
* @brief DBusPendingCall private implementation details.
*
* The guts of DBusPendingCall and its methods.
*
* @{
*/
/**
* @brief Internals of DBusPendingCall
*
* Object representing a reply message that we're waiting for.
*/
struct DBusPendingCall
{
DBusAtomic refcount; /**< reference count */
DBusPendingCallNotifyFunction function; /**< Notifier when reply arrives. */
void *user_data; /**< user data for function */
DBusFreeFunction free_user_data; /**< free the user data */
DBusConnection *connection; /**< Connections we're associated with */
DBusMessage *reply; /**< Reply (after we've received it) */
DBusTimeout *timeout; /**< Timeout */
DBusList *timeout_link; /**< Preallocated timeout response */
dbus_uint32_t reply_serial; /**< Expected serial of reply */
unsigned int completed : 1; /**< TRUE if completed */
unsigned int timeout_added : 1; /**< Have added the timeout */
};
/**
* Creates a new pending reply object.
*
* @param connection connection where reply will arrive
* @param reply_serial reply serial of the expected reply
* @returns a new #DBusPendingCall or #NULL if no memory.
*/
DBusPendingCall*
_dbus_pending_call_new (DBusConnection *connection,
dbus_uint32_t reply_serial)
{
DBusPendingCall *pending;
pending = dbus_new (DBusPendingCall, 1);
if (pending == NULL)
return NULL;
pending->refcount.value = 1;
pending->connection = connection;
pending->reply_serial = reply_serial;
return pending;
}
/** @} */
/**
* @defgroup DBusPendingCall DBusPendingCall
* @ingroup DBus
* @brief Pending reply to a method call message
*
* A DBusPendingCall is an object representing an
* expected reply. A #DBusPendingCall can be created
* when you send a message that should have a reply.
*
* @{
*/
/**
* @typedef DBusPendingCall
*
* Opaque data type representing a message pending.
*/
/**
* Increments the reference count on a pending call.
*
* @param pending the pending call object
*/
void
dbus_pending_call_ref (DBusPendingCall *pending)
{
_dbus_return_if_fail (pending != NULL);
_dbus_atomic_inc (&pending->refcount);
}
/**
* Decrements the reference count on a pending call,
* freeing it if the count reaches 0.
*
* @param pending the pending call object
*/
void
dbus_pending_call_unref (DBusPendingCall *pending)
{
dbus_bool_t last_unref;
_dbus_return_if_fail (pending != NULL);
last_unref = (_dbus_atomic_dec (&pending->refcount) == 1);
if (last_unref)
{
if (pending->free_user_data)
(* pending->free_user_data) (pending->user_data);
if (pending->connection != NULL)
{
_dbus_connection_pending_destroyed_locked (connection, pending);
pending->connection = NULL;
}
if (pending->reply)
{
dbus_message_unref (pending->reply);
pending->reply = NULL;
}
dbus_free (pending);
}
}
/**
* Sets a notification function to be called when the reply is
* received or the pending call times out.
*
* @param pending the pending call
* @param function notifier function
* @param user_data data to pass to notifier function
* @param free_user_data function to free the user data
*
*/
void
dbus_pending_call_set_notify (DBusPendingCall *pending,
DBusPendingCallNotifyFunction function,
void *user_data,
DBusFreeFunction free_user_data)
{
DBusFreeFunction old_free_func;
void *old_user_data;
_dbus_return_if_fail (pending != NULL);
_DBUS_LOCK (pending_call);
old_free_func = pending->free_user_data;
old_user_data = pending->user_data;
pending->user_data = user_data;
pending->free_user_data = free_user_data;
pending->function = function;
_DBUS_UNLOCK (pending_call);
if (old_free_func)
(* old_free_func) (old_user_data);
}
/** @} */
#ifdef DBUS_BUILD_TESTS
static DBusPendingResult
test_pending (DBusPendingCall *pending,
DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
return DBUS_PENDING_RESULT_NOT_YET_HANDLED;
}
static void
free_test_data (void *data)
{
/* does nothing */
}
/**
* @ingroup DBusPendingCallInternals
* Unit test for DBusPendingCall.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_pending_call_test (const char *test_data_dir)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */

55
dbus/dbus-pending-call.h Normal file
View file

@ -0,0 +1,55 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-pending-call.h Object representing a call in progress.
*
* Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
#endif
#ifndef DBUS_PENDING_CALL_H
#define DBUS_PENDING_CALL_H
#include <dbus/dbus-macros.h>
#include <dbus/dbus-types.h>
#include <dbus/dbus-connection.h>
DBUS_BEGIN_DECLS;
typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
void *user_data);
DBusPendingCall* _dbus_pending_call_new (DBusConnection *connection,
dbus_uint32_t reply_serial);
void dbus_pending_call_ref (DBusPendingCall *pending);
void dbus_pending_call_unref (DBusPendingCall *pending);
void dbus_pending_call_set_notify (DBusPendingCall *pending,
DBusPendingCallNotifyFunction function,
void *user_data,
DBusFreeFunction free_user_data);
dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall *pending);
DBusMessage* dbus_pending_call_get_reply (DBusPendingCall *pending);
DBUS_END_DECLS;
#endif /* DBUS_PENDING_CALL_H */

15
glib/Makefile.am
View file

@ -1,18 +1,29 @@
INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS)
INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) -DDBUS_COMPILATION=1
dbusincludedir=$(includedir)/dbus-1.0/dbus
lib_LTLIBRARIES=libdbus-glib-1.la
dbusinclude_HEADERS= \
dbus-glib.h
dbus-glib.h \
dbus-gproxy.h
libdbus_glib_1_la_SOURCES = \
dbus-gmain.c \
dbus-gproxy.c \
dbus-gthread.c
libdbus_glib_1_la_LIBADD= $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
bin_PROGRAMS=dbus-glib-compiler
dbus_glib_compiler_SOURCES = \
dbus-gidl.c \
dbus-gidl.h \
dbus-compiler-main.c
dbus_glib_compiler_LDADD= libdbus-glib-1.la $(DBUS_GLIB_LIBS) $(top_builddir)/dbus/libdbus-1.la
if DBUS_BUILD_TESTS
if HAVE_GLIB_THREADS

48
glib/dbus-compiler-main.c Normal file
View file

@ -0,0 +1,48 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-compiler-main.c main() for GLib stubs/skels generator
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-gidl.h"
int
main (int argc, char **argv)
{
return 0;
}
#ifdef DBUS_BUILD_TESTS
/**
* @ingroup DBusGCompiler
* Unit test for GLib stubs/skels compiler
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_gcompiler_test (void)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */

331
glib/dbus-gidl.c Normal file
View file

@ -0,0 +1,331 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-gidl.c data structure describing an interface, to be generated from IDL
* or something
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-gidl.h"
struct InterfaceInfo
{
int refcount;
char *name;
GSList *methods;
GSList *signals;
};
struct MethodInfo
{
int refcount;
GSList *args;
char *name;
MethodStyle style;
};
struct SignalInfo
{
int refcount;
GSList *args;
char *name;
};
struct ArgInfo
{
int refcount;
char *name;
int type;
ArgDirection direction;
};
static void
free_method_list (GSList **methods_p)
{
GSList *tmp;
tmp = *methods_p;
while (tmp != NULL)
{
method_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*methods_p);
*methods_p = NULL;
}
static void
free_signal_list (GSList **signals_p)
{
GSList *tmp;
tmp = *signals_p;
while (tmp != NULL)
{
signal_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*signals_p);
*signals_p = NULL;
}
InterfaceInfo*
interface_info_new (const char *name)
{
InterfaceInfo *info;
info = g_new0 (InterfaceInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
return info;
}
void
interface_info_ref (InterfaceInfo *info)
{
info->refcount += 1;
}
void
interface_info_unref (InterfaceInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_method_list (&info->methods);
free_signal_list (&info->signals);
g_free (info->name);
g_free (info);
}
}
GSList*
interface_info_get_methods (InterfaceInfo *info)
{
return info->methods;
}
GSList*
interface_info_get_signals (InterfaceInfo *info)
{
return info->signals;
}
void
interface_info_add_method (InterfaceInfo *info,
MethodInfo *method)
{
method_info_ref (method);
info->methods = g_slist_append (info->methods, method);
}
void
interface_info_add_signal (InterfaceInfo *info,
SignalInfo *signal)
{
signal_info_ref (signal);
info->signals = g_slist_append (info->signals, signal);
}
static void
free_arg_list (GSList **args_p)
{
GSList *tmp;
tmp = *args_p;
while (tmp != NULL)
{
arg_info_unref (tmp->data);
tmp = tmp->next;
}
g_slist_free (*args_p);
*args_p = NULL;
}
MethodInfo*
method_info_new (const char *name,
MethodStyle style)
{
MethodInfo *info;
info = g_new0 (MethodInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
info->style = style;
return info;
}
void
method_info_ref (MethodInfo *info)
{
info->refcount += 1;
}
void
method_info_unref (MethodInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_arg_list (&info->args);
g_free (info->name);
g_free (info);
}
}
const char*
method_info_get_name (MethodInfo *info)
{
return info->name;
}
GSList*
method_info_get_args (MethodInfo *info)
{
return info->args;
}
MethodStyle
method_info_get_style (MethodInfo *info)
{
return info->style;
}
void
method_info_add_arg (MethodInfo *info,
ArgInfo *arg)
{
arg_info_ref (arg);
info->args = g_slist_append (info->args, arg);
}
SignalInfo*
signal_info_new (const char *name)
{
SignalInfo *info;
info = g_new0 (SignalInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
return info;
}
void
signal_info_ref (SignalInfo *info)
{
info->refcount += 1;
}
void
signal_info_unref (SignalInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
free_arg_list (&info->args);
g_free (info->name);
g_free (info);
}
}
const char*
signal_info_get_name (SignalInfo *info)
{
return info->name;
}
GSList*
signal_info_get_args (SignalInfo *info)
{
return info->args;
}
void
signal_info_add_arg (SignalInfo *info,
ArgInfo *arg)
{
arg_info_ref (arg);
info->args = g_slist_append (info->args, arg);
}
ArgInfo*
arg_info_new (const char *name,
ArgDirection direction,
int type)
{
ArgInfo *info;
info = g_new0 (ArgInfo, 1);
info->refcount = 1;
info->name = g_strdup (name);
info->direction = direction;
info->type = type;
return info;
}
void
arg_info_ref (ArgInfo *info)
{
info->refcount += 1;
}
void
arg_info_unref (ArgInfo *info)
{
info->refcount -= 1;
if (info->refcount == 0)
{
g_free (info->name);
g_free (info);
}
}
const char*
arg_info_get_name (ArgInfo *info)
{
return info->name;
}
int
arg_info_get_type (ArgInfo *info)
{
return info->type;
}
ArgDirection
arg_info_get_direction (ArgInfo *info)
{
return info->direction;
}
#ifdef DBUS_BUILD_TESTS
/**
* @ingroup DBusGIDL
* Unit test for GLib IDL internals
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_gidl_test (void)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */

19
glib/dbus-gidl.h
View file

@ -47,28 +47,39 @@ typedef enum
METHOD_CANCELLABLE
} MethodStyle;
InterfaceInfo* interface_info_new (void);
InterfaceInfo* interface_info_new (const char *name);
void interface_info_ref (InterfaceInfo *info);
void interface_info_unref (InterfaceInfo *info);
GSList* interface_info_get_methods (InterfaceInfo *info);
GSList* interface_info_get_signals (InterfaceInfo *info);
void interface_info_add_method (InterfaceInfo *info,
MethodInfo *method);
void interface_info_add_signal (InterfaceInfo *info,
SignalInfo *signal);
MethodInfo* method_info_new (void);
MethodInfo* method_info_new (const char *name,
MethodStyle style);
void method_info_ref (MethodInfo *info);
void method_info_unref (MethodInfo *info);
const char* method_info_get_name (MethodInfo *info);
GSList* method_info_get_args (MethodInfo *info);
MethodStyle method_info_get_style (MethodInfo *info);
void method_info_add_arg (MethodInfo *info,
ArgInfo *arg);
SignalInfo* signal_info_new (void);
SignalInfo* signal_info_new (const char *name);
void signal_info_ref (SignalInfo *info);
void signal_info_unref (SignalInfo *info);
const char* signal_info_get_name (SignalInfo *info);
GSList* signal_info_get_args (SignalInfo *info);
void signal_info_add_arg (SignalInfo *info,
ArgInfo *arg);
ArgInfo* arg_info_new (void);
ArgInfo* arg_info_new (const char *name,
ArgDirection direction,
int type);
void arg_info_ref (ArgInfo *info);
void arg_info_unref (ArgInfo *info);
const char* arg_info_get_name (ArgInfo *info);

4
glib/dbus-glib.h
View file

@ -28,12 +28,16 @@
G_BEGIN_DECLS
#define DBUS_INSIDE_DBUS_GLIB_H 1
void dbus_gthread_init (void);
void dbus_connection_setup_with_g_main (DBusConnection *connection,
GMainContext *context);
void dbus_server_setup_with_g_main (DBusServer *server,
GMainContext *context);
#undef DBUS_INSIDE_DBUS_GLIB_H
G_END_DECLS
#endif /* DBUS_GLIB_H */

170
glib/dbus-gproxy.c Normal file
View file

@ -0,0 +1,170 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-gcall.c convenience routines for calling methods, etc.
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "dbus-gproxy.h"
/**
* @addtogroup DBusGLibInternals
*
* @{
*/
struct DBusGProxy
{
int refcount;
DBusConnection *connection;
char *service;
char *interface;
DBusObjectID object_id;
};
static DBusGProxy*
_dbus_gproxy_new (DBusConnection *connection)
{
DBusGProxy *proxy;
proxy = g_new0 (DBusGProxy, 1);
proxy->refcount = 1;
proxy->connection = connection;
dbus_connection_ref (connection);
return proxy;
}
/** @} End of DBusGLibInternals */
/** @addtogroup DBusGLib
* @{
*/
/**
* Creates a new proxy for a remote interface. Method calls and signal
* connections over this proxy will go to the service owner; the
* service owner is expected to support the given interface name. THE
* SERVICE OWNER MAY CHANGE OVER TIME, for example between two
* different method calls. If you need a fixed owner, you need to
* request the current owner and bind a proxy to that rather than to
* the generic service name; see dbus_gproxy_new_for_service_owner().
*
* A service-associated proxy only makes sense with a message bus,
* not for app-to-app direct dbus connections.
*
* @param connection the connection to the remote bus or app
* @param service_name name of the service on the message bus
* @param interface_name name of the interface to call methods on
* @returns new proxy object
*/
DBusGProxy*
dbus_gproxy_new_for_service (DBusConnection *connection,
const char *service_name,
const char *interface_name)
{
DBusGProxy *proxy;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (service_name != NULL, NULL);
g_return_val_if_fail (interface_name != NULL, NULL);
proxy = _dbus_gproxy_new (connection);
proxy->service = g_strdup (service_name);
proxy->interface = g_strdup (interface_name);
return proxy;
}
/**
* Increment reference count on proxy object.
*
* @param proxy the proxy
*/
void
dbus_gproxy_ref (DBusGProxy *proxy)
{
g_return_if_fail (proxy != NULL);
proxy->refcount += 1;
}
/**
* Decrement reference count on proxy object.
*
* @param proxy the proxy
*/
void
dbus_gproxy_unref (DBusGProxy *proxy)
{
g_return_if_fail (proxy != NULL);
proxy->refcount -= 1;
if (proxy->refcount == 0)
{
dbus_connection_unref (proxy->connection);
g_free (proxy->interface);
g_free (proxy->service);
g_free (proxy);
}
}
/**
* Invokes a method on a remote interface. This function does not
* block; instead it returns an opaque #DBusGPendingCall object that
* tracks the pending call. The method call will not be sent over the
* wire until the application returns to the main loop, or blocks in
* dbus_connection_flush() to write out pending data. The call will
* be completed after a timeout, or when a reply is received.
*
* @param proxy a proxy for a remote interface
* @param method the name of the method to invoke
* @param first_arg_type type of the first argument
*
* @returns opaque pending call object
*
*/
DBusGPendingCall*
dbus_gproxy_begin_call (DBusGProxy *proxy,
const char *method,
int first_arg_type,
...)
{
}
/** @} End of DBusGLib public */
#ifdef DBUS_BUILD_TESTS
/**
* @ingroup DBusGLibInternals
* Unit test for GLib proxy functions
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_gproxy_test (void)
{
return TRUE;
}
#endif /* DBUS_BUILD_TESTS */

79
glib/dbus-gproxy.h Normal file
View file

@ -0,0 +1,79 @@
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-gproxy.h convenience routines for calling methods, etc.
*
* Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef DBUS_GPROXY_H
#define DBUS_GPROXY_H
#if !defined (DBUS_INSIDE_DBUS_GLIB_H) && !defined (DBUS_COMPILATION)
#error "Only <dbus/dbus-glib.h> can be included directly, this file may disappear or change contents."
#endif
#include <dbus/dbus.h>
#include <glib.h>
#include <glib-object.h> /* for GCallback at the moment, we don't link to it */
G_BEGIN_DECLS
typedef struct DBusGProxy DBusGProxy;
typedef struct DBusGPendingCall DBusGPendingCall;
DBusGProxy* dbus_gproxy_new_for_service (DBusConnection *connection,
const char *service_name,
const char *interface_name);
DBusGProxy* dbus_gproxy_new_for_service_owner (DBusConnection *connection,
const char *service_name,
const char *interface_name,
GError **error);
DBusGProxy* dbus_gproxy_new_for_object_id (DBusConnection *connection,
const DBusObjectID *object_id,
const char *interface_name);
DBusGProxy* dbus_gproxy_new_for_interface (DBusConnection *connection,
const char *interface_name);
void dbus_gproxy_ref (DBusGProxy *proxy);
void dbus_gproxy_unref (DBusGProxy *proxy);
gboolean dbus_gproxy_connect_signal (DBusGProxy *proxy,
const char *signal_name,
GCallback callback,
void *data,
GFreeFunc free_data_func,
GError **error);
DBusGPendingCall* dbus_gproxy_begin_call (DBusGProxy *proxy,
const char *method,
int first_arg_type,
...);
void dbus_gproxy_oneway_call (DBusGProxy *proxy,
const char *method,
int first_arg_type,
...);
gboolean dbus_gpending_call_is_complete (DBusGPendingCall *call);
void dbus_gpending_call_cancel_and_free (DBusGPendingCall *call);
gboolean dbus_gpending_call_block_and_free (DBusGPendingCall *call,
GError **error,
int first_arg_type,
...);
G_END_DECLS
#endif /* DBUS_GPROXY_H */