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

7 files changed, 660 insertions, 6 deletions

diff --git a/glib/Makefile.am b/glib/Makefile.am
index ebdb932f..8cc09eb7 100644
--- a/glib/Makefile.am
+++ b/glib/Makefile.am
@@ -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
diff --git a/glib/dbus-compiler-main.c b/glib/dbus-compiler-main.c
new file mode 100644
index 00000000..d8bf7bde
--- /dev/null
+++ b/glib/dbus-compiler-main.c
@@ -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 */
diff --git a/glib/dbus-gidl.c b/glib/dbus-gidl.c
new file mode 100644
index 00000000..b6e0fb8c
--- /dev/null
+++ b/glib/dbus-gidl.c
@@ -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 */
diff --git a/glib/dbus-gidl.h b/glib/dbus-gidl.h
index a5dc6cb0..c3c72d61 100644
--- a/glib/dbus-gidl.h
+++ b/glib/dbus-gidl.h
@@ -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);
diff --git a/glib/dbus-glib.h b/glib/dbus-glib.h
index c6116c52..7ca22417 100644
--- a/glib/dbus-glib.h
+++ b/glib/dbus-glib.h
@@ -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 */
diff --git a/glib/dbus-gproxy.c b/glib/dbus-gproxy.c
new file mode 100644
index 00000000..4326057a
--- /dev/null
+++ b/glib/dbus-gproxy.c
@@ -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 */
diff --git a/glib/dbus-gproxy.h b/glib/dbus-gproxy.h
new file mode 100644
index 00000000..bebcd1ce
--- /dev/null
+++ b/glib/dbus-gproxy.h
@@ -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 */