[glibmm] Move the DBus classes into a Gio::DBus namespace.
- From: Murray Cumming <murrayc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glibmm] Move the DBus classes into a Gio::DBus namespace.
- Date: Wed, 16 Feb 2011 10:31:46 +0000 (UTC)
commit 4e118b927f83290bae27bcae707be8e1c83f47d5
Author: Murray Cumming <murrayc murrayc com>
Date: Wed Feb 16 11:29:19 2011 +0100
Move the DBus classes into a Gio::DBus namespace.
* gio/giomm.h:
* gio/src/dbus*.[hg|ccg]
* gio/src/error.hg: Rename all DBus* classes to remove the prefix, putting
them in a Gio::DBus namespace.
This required the use of the new _GMMPROC_EXTRA_NAMESPACE macro, to avoid
generating a confused wrap_init.cc.
Along the way, I removed unnecessary class predeclarations, instead including
the relevant header, because that is more convenient for users of the API.
* gio/src/dbuserror.[hg|ccg]: Renamed to dbuserrorutils.[hg|ccg] and
renamed the Error namespace to ErrorUtils, to avoid a clash with the
Gio::DBus::Error exception.
* gio/src/filelist.am:
* tools/m4/convert_gio.m4: Changed some conversions.
* examples/dbus/busserver.cc:
* examples/dbus/peer.cc:
* examples/dbus/userbus.cc: Adapted.
This is generally more organized. A prefix, instead of a namespace, looked
generally wrong to C++ coders.
ChangeLog | 24 +++
examples/dbus/busserver.cc | 22 ++--
examples/dbus/peer.cc | 32 ++--
examples/dbus/userbus.cc | 8 +-
gio/giomm.h | 2 +-
gio/src/credentials.hg | 2 +-
gio/src/dbusauthobserver.ccg | 5 +
gio/src/dbusauthobserver.hg | 13 +-
gio/src/dbusconnection.ccg | 365 +++++++++++++++++++-------------------
gio/src/dbusconnection.hg | 355 +++++++++++++++++++------------------
gio/src/dbuserrorutils.ccg | 4 +-
gio/src/dbuserrorutils.hg | 6 +-
gio/src/dbusintrospection.hg | 67 ++++----
gio/src/dbusmessage.ccg | 14 +-
gio/src/dbusmessage.hg | 48 +++---
gio/src/dbusmethodinvocation.ccg | 7 +-
gio/src/dbusmethodinvocation.hg | 31 ++--
gio/src/dbusownname.hg | 16 +-
gio/src/dbusproxy.ccg | 141 ++++++++-------
gio/src/dbusproxy.hg | 157 +++++++++--------
gio/src/dbusserver.ccg | 60 ++++---
gio/src/dbusserver.hg | 68 ++++----
gio/src/dbusutils.hg | 2 +-
gio/src/dbuswatchname.ccg | 2 +-
gio/src/dbuswatchname.hg | 18 +-
gio/src/error.hg | 5 +-
gio/src/filelist.am | 4 +-
tools/m4/convert_gio.m4 | 42 +++---
28 files changed, 808 insertions(+), 712 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 9bdd8a2..8d46344 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,29 @@
2011-02-16 Murray Cumming <murrayc murrayc com>
+ Move the DBus classes into a Gio::DBus namespace.
+
+ * gio/giomm.h:
+ * gio/src/dbus*.[hg|ccg]
+ * gio/src/error.hg: Rename all DBus* classes to remove the prefix, putting
+ them in a Gio::DBus namespace.
+ This required the use of the new _GMMPROC_EXTRA_NAMESPACE macro, to avoid
+ generating a confused wrap_init.cc.
+ Along the way, I removed unnecessary class predeclarations, instead including
+ the relevant header, because that is more convenient for users of the API.
+ * gio/src/dbuserror.[hg|ccg]: Renamed to dbuserrorutils.[hg|ccg] and
+ renamed the Error namespace to ErrorUtils, to avoid a clash with the
+ Gio::DBus::Error exception.
+ * gio/src/filelist.am:
+ * tools/m4/convert_gio.m4: Changed some conversions.
+ * examples/dbus/busserver.cc:
+ * examples/dbus/peer.cc:
+ * examples/dbus/userbus.cc: Adapted.
+
+ This is generally more organized. A prefix, instead of a namespace, looked
+ generally wrong to C++ coders.
+
+2011-02-16 Murray Cumming <murrayc murrayc com>
+
gmmproc: Allow some classes to be in a sub-namespace.
* tools/m4/class_shared.m4:
diff --git a/examples/dbus/busserver.cc b/examples/dbus/busserver.cc
index cac377c..3beeca2 100644
--- a/examples/dbus/busserver.cc
+++ b/examples/dbus/busserver.cc
@@ -23,7 +23,7 @@
* allow per-client alarms, but that is left as an exercise.
*
* Along with the above it provides a method to get its stdout's file
- * descriptor to test the Gio::DBusMessage API.
+ * descriptor to test the Gio::DBus::Message API.
*/
#include <giomm.h>
@@ -33,7 +33,7 @@
namespace
{
-static Glib::RefPtr<Gio::DBusNodeInfo> introspection_data;
+static Glib::RefPtr<Gio::DBus::NodeInfo> introspection_data;
static Glib::ustring introspection_xml =
"<node>"
@@ -57,11 +57,11 @@ static Glib::TimeVal curr_alarm;
} // anonymous namespace
/* TODO: This code does not seem to be used. murrayc.
-static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>& connection,
+static void on_method_call(const Glib::RefPtr<Gio::DBus::Connection>& connection,
const Glib::ustring& sender, const Glib::ustring& object_path,
const Glib::ustring& interface_name, const Glib::ustring& method_name,
const Glib::VariantBase& parameters,
- const Glib::RefPtr<Gio::DBusMethodInvocation>& invocation)
+ const Glib::RefPtr<Gio::DBus::MethodInvocation>& invocation)
{
if(method_name == "GetTime")
{
@@ -100,7 +100,7 @@ static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>& connection,
if(!curr_alarm.assign_from_iso8601(time_str))
{
// If setting alarm was not successful, return an error.
- Gio::DBusError error(Gio::DBusError::INVALID_ARGS,
+ Gio::DBus::Error error(Gio::DBus::Error::INVALID_ARGS,
"Alarm string is not in ISO8601 format.");
invocation->return_gerror(error);
}
@@ -116,8 +116,8 @@ static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>& connection,
{
list->append(STDOUT_FILENO);
- Glib::RefPtr<Gio::DBusMessage> reply =
- Gio::DBusMessage::create_method_reply(invocation->get_message());
+ Glib::RefPtr<Gio::DBus::Message> reply =
+ Gio::DBus::Message::create_method_reply(invocation->get_message());
reply->set_unix_fd_list(list);
@@ -144,7 +144,7 @@ static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>& connection,
else
{
// Non-existent method on the interface.
- Gio::DBusError error(Gio::DBusError::UNKNOWN_METHOD,
+ Gio::DBus::Error error(Gio::DBus::Error::UNKNOWN_METHOD,
"Method does not exist.");
invocation->return_gerror(error);
}
@@ -152,7 +152,7 @@ static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>& connection,
*/
void on_get_property(Glib::VariantBase& property,
- const Glib::RefPtr<Gio::DBusConnection>& /* connection */,
+ const Glib::RefPtr<Gio::DBus::Connection>& /* connection */,
const Glib::ustring& /* sender */, const Glib::ustring& /* object_path */,
const Glib::ustring& /* interface_name */, const Glib::ustring& property_name)
{
@@ -174,12 +174,12 @@ void on_get_property(Glib::VariantBase& property,
}
else
{
- throw Gio::DBusError(Gio::DBusError::FAILED, "Unknown property name.");
+ throw Gio::DBus::Error(Gio::DBus::Error::FAILED, "Unknown property name.");
}
}
/** TODO: This code does not seem to be used. murrayc.
-bool on_set_property(const Glib::RefPtr<Gio::DBusConnection>& connection,
+bool on_set_property(const Glib::RefPtr<Gio::DBus::Connection>& connection,
const Glib::ustring& sender, const Glib::ustring& object_path,
const Glib::ustring& interface_name, const Glib::ustring& property_name,
const Glib::VariantBase& value)
diff --git a/examples/dbus/peer.cc b/examples/dbus/peer.cc
index 1a7a1ca..be32da3 100644
--- a/examples/dbus/peer.cc
+++ b/examples/dbus/peer.cc
@@ -89,7 +89,7 @@ TCP transport on two different hosts without authentication:
#include <glibmm.h>
#include <iostream>
-static Glib::RefPtr<Gio::DBusNodeInfo> introspection_data;
+static Glib::RefPtr<Gio::DBus::NodeInfo> introspection_data;
static Glib::ustring introspection_xml =
"<node>"
@@ -103,14 +103,14 @@ static Glib::ustring introspection_xml =
// This variable is used to keep an incoming connection active until it is
// closed.
-static Glib::RefPtr<Gio::DBusConnection> curr_connection;
+static Glib::RefPtr<Gio::DBus::Connection> curr_connection;
-static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>&,
+static void on_method_call(const Glib::RefPtr<Gio::DBus::Connection>&,
const Glib::ustring& /* sender */, const Glib::ustring& /* object_path */,
const Glib::ustring& /* interface_name */, const Glib::ustring& method_name,
// Since the parameters are generally tuples, get them from the invocation.
const Glib::VariantBase& /* parameters */,
- const Glib::RefPtr<Gio::DBusMethodInvocation>& invocation)
+ const Glib::RefPtr<Gio::DBus::MethodInvocation>& invocation)
{
if(method_name == "HelloWorld")
{
@@ -140,10 +140,10 @@ static void on_method_call(const Glib::RefPtr<Gio::DBusConnection>&,
}
// Create the interface VTable.
-static const Gio::DBusInterfaceVTable
+static const Gio::DBus::InterfaceVTable
interface_vtable(sigc::ptr_fun(&on_method_call));
-bool on_new_connection(const Glib::RefPtr<Gio::DBusConnection>& connection)
+bool on_new_connection(const Glib::RefPtr<Gio::DBus::Connection>& connection)
{
Glib::RefPtr<Gio::Credentials> credentials =
connection->get_peer_credentials();
@@ -158,7 +158,7 @@ bool on_new_connection(const Glib::RefPtr<Gio::DBusConnection>& connection)
std::cout <<
"Client connected." << std::endl <<
"Peer credentials: " << credentials_str << std::endl <<
- "Negotiated capabilities: unix-fd-passing=" << (connection->get_capabilities() & Gio::DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING) << std::endl;
+ "Negotiated capabilities: unix-fd-passing=" << (connection->get_capabilities() & Gio::DBus::CAPABILITY_FLAGS_UNIX_FD_PASSING) << std::endl;
// If there is already an active connection, do not accept this new one.
// There may be a better way to decide how to keep current incoming
@@ -192,16 +192,16 @@ bool on_new_connection(const Glib::RefPtr<Gio::DBusConnection>& connection)
void run_as_server(Glib::ustring address, bool allow_anonymous)
{
Glib::ustring guid = Gio::DBus::generate_guid();
- Gio::DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE;
+ Gio::DBus::ServerFlags flags = Gio::DBus::SERVER_FLAGS_NONE;
if(allow_anonymous)
- flags |= Gio::DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
+ flags |= Gio::DBus::SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
- Glib::RefPtr<Gio::DBusServer> server;
+ Glib::RefPtr<Gio::DBus::Server> server;
try
{
- server = Gio::DBusServer::create_sync(address, guid, flags);
+ server = Gio::DBus::Server::create_sync(address, guid, flags);
}
catch(const Glib::Error& ex)
{
@@ -223,12 +223,12 @@ void run_as_server(Glib::ustring address, bool allow_anonymous)
void run_as_client(Glib::ustring address)
{
- Glib::RefPtr<Gio::DBusConnection> connection;
+ Glib::RefPtr<Gio::DBus::Connection> connection;
try
{
- connection = Gio::DBusConnection::create_for_address_sync(address,
- Gio::DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT);
+ connection = Gio::DBus::Connection::create_for_address_sync(address,
+ Gio::DBus::CONNECTION_FLAGS_AUTHENTICATION_CLIENT);
}
catch(const Glib::Error& ex)
{
@@ -239,7 +239,7 @@ void run_as_client(Glib::ustring address)
std::cout << "Connected. " << std::endl <<
"Negotiated capabilities: unix-fd-passing=" <<
- static_cast<bool>(connection->get_capabilities() & Gio::DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING) << "." << std::endl;
+ static_cast<bool>(connection->get_capabilities() & Gio::DBus::CAPABILITY_FLAGS_UNIX_FD_PASSING) << "." << std::endl;
// Get the current time to send as a greeting when calling a server's method.
Glib::TimeVal time;
@@ -330,7 +330,7 @@ int main(int argc, char** argv)
try
{
- introspection_data = Gio::DBusNodeInfo::create_for_xml(introspection_xml);
+ introspection_data = Gio::DBus::NodeInfo::create_for_xml(introspection_xml);
}
catch(const Glib::Error& ex)
{
diff --git a/examples/dbus/userbus.cc b/examples/dbus/userbus.cc
index 6369854..bd6996d 100644
--- a/examples/dbus/userbus.cc
+++ b/examples/dbus/userbus.cc
@@ -34,7 +34,7 @@ bool main_loop_idle()
// method.
void dbus_proxy_available(Glib::RefPtr<Gio::AsyncResult>& result)
{
- Glib::RefPtr<Gio::DBusProxy> proxy = Gio::DBusProxy::create_finish(result);
+ Glib::RefPtr<Gio::DBus::Proxy> proxy = Gio::DBus::Proxy::create_finish(result);
if(!proxy)
{
@@ -82,8 +82,8 @@ int main(int, char**)
loop = Glib::MainLoop::create();
// Get the user session bus connection.
- Glib::RefPtr<Gio::DBusConnection> connection =
- Gio::DBusConnection::get_sync(Gio::BUS_TYPE_SESSION);
+ Glib::RefPtr<Gio::DBus::Connection> connection =
+ Gio::DBus::Connection::get_sync(Gio::DBus::BUS_TYPE_SESSION);
// Check for an unavailable connection.
if(!connection)
@@ -93,7 +93,7 @@ int main(int, char**)
}
// Create the proxy to the bus asynchronously.
- Gio::DBusProxy::create(connection, "org.freedesktop.DBus",
+ Gio::DBus::Proxy::create(connection, "org.freedesktop.DBus",
"/org/freedesktop/DBus", "org.freedesktop.DBus",
sigc::ptr_fun(&dbus_proxy_available));
diff --git a/gio/giomm.h b/gio/giomm.h
index bb49bf4..12f71c3 100644
--- a/gio/giomm.h
+++ b/gio/giomm.h
@@ -34,7 +34,7 @@
#include <giomm/dbusaddress.h>
#include <giomm/dbusauthobserver.h>
#include <giomm/dbusconnection.h>
-#include <giomm/dbuserror.h>
+#include <giomm/dbuserrorutils.h>
#include <giomm/dbusintrospection.h>
#include <giomm/dbusmessage.h>
#include <giomm/dbusmethodinvocation.h>
diff --git a/gio/src/credentials.hg b/gio/src/credentials.hg
index 71fd962..ee0ca97 100644
--- a/gio/src/credentials.hg
+++ b/gio/src/credentials.hg
@@ -27,7 +27,7 @@ namespace Gio
_WRAP_ENUM(CredentialsType, GCredentialsType, NO_GTYPE)
-/** Credentials - An object containing credentials.
+/** An object containing credentials.
* The Credentials type is a reference-counted wrapper for native credentials.
* This information is typically used for identifying, authenticating and
* authorizing other processes.
diff --git a/gio/src/dbusauthobserver.ccg b/gio/src/dbusauthobserver.ccg
index 555a34b..7e96b87 100644
--- a/gio/src/dbusauthobserver.ccg
+++ b/gio/src/dbusauthobserver.ccg
@@ -18,6 +18,11 @@
*/
#include <gio/gio.h>
+#include <giomm/credentials.h>
+
+//To help the generated code:
+typedef Gio::Credentials Credentials;
+typedef Gio::IOStream IOStream;
namespace Gio
{
diff --git a/gio/src/dbusauthobserver.hg b/gio/src/dbusauthobserver.hg
index 52dba4c..7723e4d 100644
--- a/gio/src/dbusauthobserver.hg
+++ b/gio/src/dbusauthobserver.hg
@@ -27,19 +27,24 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
+namespace DBus
+{
+
+_GMMPROC_EXTRA_NAMESPACE(DBus)
+
//TODO: Add example from the C API docs in class docs.
/** DBusAuthObserver - Object used for authenticating connections.
* The DBusAuthObserver type provides a mechanism for participating in how a
- * DBusServer (or a DBusConnection) authenticates remote peers. Simply
+ * DBusServer (or a DBus::Connection) authenticates remote peers. Simply
* instantiate a DBusAuthObserver and connect to the signals you are
* interested in. Note that new signals may be added in the future.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusAuthObserver : public Glib::Object
+class AuthObserver : public Glib::Object
{
- _CLASS_GOBJECT(DBusAuthObserver, GDBusAuthObserver, G_DBUS_AUTH_OBSERVER, Glib::Object, GObject)
+ _CLASS_GOBJECT(AuthObserver, GDBusAuthObserver, G_DBUS_AUTH_OBSERVER, Glib::Object, GObject)
protected:
_CTOR_DEFAULT
@@ -55,4 +60,6 @@ public:
_WRAP_SIGNAL(bool authorize_authenticated_peer(const Glib::RefPtr<const IOStream>& stream, const Glib::RefPtr<const Credentials>& credentials), "authorize-authenticated-peer", no_default_handler)
};
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusconnection.ccg b/gio/src/dbusconnection.ccg
index 17eb4a8..eae69e0 100644
--- a/gio/src/dbusconnection.ccg
+++ b/gio/src/dbusconnection.ccg
@@ -35,8 +35,8 @@ static void DBusConnection_Signal_giomm_callback(GDBusConnection* connection,
const char* interface_name, const char* signal_name, GVariant* parameters,
void* user_data)
{
- Gio::DBusConnection::SlotSignal* the_slot =
- static_cast<Gio::DBusConnection::SlotSignal*>(user_data);
+ Gio::DBus::Connection::SlotSignal* the_slot =
+ static_cast<Gio::DBus::Connection::SlotSignal*>(user_data);
try
{
@@ -52,19 +52,19 @@ static void DBusConnection_Signal_giomm_callback(GDBusConnection* connection,
static void DBusConnection_Signal_giomm_callback_destroy(void* data)
{
- delete static_cast<Gio::DBusConnection::SlotSignal*>(data);
+ delete static_cast<Gio::DBus::Connection::SlotSignal*>(data);
}
static GDBusMessage* DBusConnection_Message_Filter_giomm_callback(
GDBusConnection* connection, GDBusMessage* message, gboolean incoming,
void* user_data)
{
- Gio::DBusConnection::SlotMessageFilter* the_slot =
- static_cast<Gio::DBusConnection::SlotMessageFilter*>(user_data);
+ Gio::DBus::Connection::SlotMessageFilter* the_slot =
+ static_cast<Gio::DBus::Connection::SlotMessageFilter*>(user_data);
try
{
- Glib::RefPtr<Gio::DBusMessage> result = (*the_slot)(
+ Glib::RefPtr<Gio::DBus::Message> result = (*the_slot)(
Glib::wrap(connection, true), Glib::wrap(message, true),
static_cast<bool>(incoming));
return (result) ? result->gobj_copy() : 0;
@@ -79,7 +79,7 @@ static GDBusMessage* DBusConnection_Message_Filter_giomm_callback(
static void DBusConnection_Message_Filter_giomm_callback_destroy(void* data)
{
- delete static_cast<Gio::DBusConnection::SlotMessageFilter*>(data);
+ delete static_cast<Gio::DBus::Connection::SlotMessageFilter*>(data);
}
static void DBusInterfaceVTable_MethodCall_giomm_callback(
@@ -87,10 +87,10 @@ static void DBusInterfaceVTable_MethodCall_giomm_callback(
const char* interface_name, const char* method_name, GVariant* parameters,
GDBusMethodInvocation* invocation, void* user_data)
{
- Gio::DBusInterfaceVTable* vtable =
- static_cast<Gio::DBusInterfaceVTable*>(user_data);
+ Gio::DBus::InterfaceVTable* vtable =
+ static_cast<Gio::DBus::InterfaceVTable*>(user_data);
- Gio::DBusInterfaceVTable::SlotInterfaceMethodCall* the_slot =
+ Gio::DBus::InterfaceVTable::SlotInterfaceMethodCall* the_slot =
vtable->get_slot_method_call();
try
@@ -110,10 +110,10 @@ static GVariant* DBusInterfaceVTable_GetProperty_giomm_callback(
const char* interface_name, const char* property_name, GError** error,
void* user_data)
{
- Gio::DBusInterfaceVTable* vtable =
- static_cast<Gio::DBusInterfaceVTable*>(user_data);
+ Gio::DBus::InterfaceVTable* vtable =
+ static_cast<Gio::DBus::InterfaceVTable*>(user_data);
- Gio::DBusInterfaceVTable::SlotInterfaceGetProperty* the_slot =
+ Gio::DBus::InterfaceVTable::SlotInterfaceGetProperty* the_slot =
vtable->get_slot_get_property();
try
@@ -142,10 +142,10 @@ static gboolean DBusInterfaceVTable_SetProperty_giomm_callback(
const char* interface_name, const char* property_name, GVariant* value,
GError** error, void* user_data)
{
- Gio::DBusInterfaceVTable* vtable =
- static_cast<Gio::DBusInterfaceVTable*>(user_data);
+ Gio::DBus::InterfaceVTable* vtable =
+ static_cast<Gio::DBus::InterfaceVTable*>(user_data);
- Gio::DBusInterfaceVTable::SlotInterfaceSetProperty* the_slot =
+ Gio::DBus::InterfaceVTable::SlotInterfaceSetProperty* the_slot =
vtable->get_slot_set_property();
try
@@ -171,10 +171,10 @@ static char** DBusSubtreeVTable_Enumerate_giomm_callback(
GDBusConnection* connection, const char* sender, const char* object_path,
void* user_data)
{
- Gio::DBusSubtreeVTable* vtable =
- static_cast<Gio::DBusSubtreeVTable*>(user_data);
+ Gio::DBus::SubtreeVTable* vtable =
+ static_cast<Gio::DBus::SubtreeVTable*>(user_data);
- Gio::DBusSubtreeVTable::SlotSubtreeEnumerate* the_slot =
+ Gio::DBus::SubtreeVTable::SlotSubtreeEnumerate* the_slot =
vtable->get_slot_enumerate();
try
@@ -204,21 +204,21 @@ static GDBusInterfaceInfo** DBusSubtreeVTable_Introspect_giomm_callback(
GDBusConnection* connection, const char* sender, const char* object_path,
const char* node, void* user_data)
{
- Gio::DBusSubtreeVTable* vtable =
- static_cast<Gio::DBusSubtreeVTable*>(user_data);
+ Gio::DBus::SubtreeVTable* vtable =
+ static_cast<Gio::DBus::SubtreeVTable*>(user_data);
- Gio::DBusSubtreeVTable::SlotSubtreeIntrospect* the_slot =
+ Gio::DBus::SubtreeVTable::SlotSubtreeIntrospect* the_slot =
vtable->get_slot_introspect();
try
{
- std::vector< Glib::RefPtr<Gio::DBusInterfaceInfo> > result =
+ std::vector< Glib::RefPtr<Gio::DBus::InterfaceInfo> > result =
(*the_slot)(Glib::wrap(connection, true), sender, object_path, node);
// This will be freed by the caller, along with unreferencing its members.
GDBusInterfaceInfo** info = g_new(GDBusInterfaceInfo*, result.size());
- for(std::vector< Glib::RefPtr<Gio::DBusInterfaceInfo> >::size_type i = 0;
+ for(std::vector< Glib::RefPtr<Gio::DBus::InterfaceInfo> >::size_type i = 0;
i < result.size(); i++)
{
info[i] = static_cast<GDBusInterfaceInfo*>(
@@ -240,19 +240,19 @@ static const GDBusInterfaceVTable* DBusSubtreeVTable_Dispatch_giomm_callback(
const char* interface_name, const char* node, void** out_user_data,
void* user_data)
{
- Gio::DBusSubtreeVTable* vtable =
- static_cast<Gio::DBusSubtreeVTable*>(user_data);
+ Gio::DBus::SubtreeVTable* vtable =
+ static_cast<Gio::DBus::SubtreeVTable*>(user_data);
- Gio::DBusSubtreeVTable::SlotSubtreeDispatch* the_slot =
+ Gio::DBus::SubtreeVTable::SlotSubtreeDispatch* the_slot =
vtable->get_slot_dispatch();
try
{
- const Gio::DBusInterfaceVTable* vtable =
+ const Gio::DBus::InterfaceVTable* vtable =
(*the_slot)(Glib::wrap(connection, true), sender, object_path,
interface_name, (node ? node : ""));
- *out_user_data = const_cast<Gio::DBusInterfaceVTable*>(vtable);
+ *out_user_data = const_cast<Gio::DBus::InterfaceVTable*>(vtable);
return vtable->gobj();
}
@@ -271,12 +271,15 @@ static const GDBusInterfaceVTable* DBusSubtreeVTable_Dispatch_giomm_callback(
namespace Gio
{
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+namespace DBus
+{
+
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -286,11 +289,11 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init_async(slot, cancellable);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -300,11 +303,11 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init_async(slot, cancellable);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -314,10 +317,10 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init_async(slot);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -327,11 +330,11 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init_async(slot);
}
-DBusConnection::DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+Connection::Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -340,10 +343,10 @@ DBusConnection::DBusConnection(const std::string& address,
init_async(slot, cancellable);
}
-DBusConnection::DBusConnection(const std::string& address,
+Connection::Connection(const std::string& address,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -352,10 +355,10 @@ DBusConnection::DBusConnection(const std::string& address,
init_async(slot, cancellable);
}
-DBusConnection::DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+Connection::Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -364,9 +367,9 @@ DBusConnection::DBusConnection(const std::string& address,
init_async(slot);
}
-DBusConnection::DBusConnection(const std::string& address,
+Connection::Connection(const std::string& address,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -375,11 +378,11 @@ DBusConnection::DBusConnection(const std::string& address,
init_async(slot);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -389,10 +392,10 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init(cancellable);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -402,10 +405,10 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init(cancellable);
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags)
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -415,9 +418,9 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init();
}
-DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+Connection::Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("stream", Glib::unwrap(stream),
"guid", (guid.empty() ? 0 : guid.c_str()),
@@ -427,10 +430,10 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
init();
}
-DBusConnection::DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+Connection::Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -439,9 +442,9 @@ DBusConnection::DBusConnection(const std::string& address,
init(cancellable);
}
-DBusConnection::DBusConnection(const std::string& address,
+Connection::Connection(const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -450,9 +453,9 @@ DBusConnection::DBusConnection(const std::string& address,
init(cancellable);
}
-DBusConnection::DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags)
+Connection::Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -461,8 +464,8 @@ DBusConnection::DBusConnection(const std::string& address,
init();
}
-DBusConnection::DBusConnection(const std::string& address,
- DBusConnectionFlags flags)
+Connection::Connection(const std::string& address,
+ ConnectionFlags flags)
:
_CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
"flags", static_cast<GDBusConnectionFlags>(flags),
@@ -472,184 +475,184 @@ DBusConnection::DBusConnection(const std::string& address,
}
//static
-void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
+void Connection::create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(stream, guid, observer, slot, cancellable, flags);
+ Connection(stream, guid, observer, slot, cancellable, flags);
}
//static
-void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
+void Connection::create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(stream, guid, slot, cancellable, flags);
+ Connection(stream, guid, slot, cancellable, flags);
}
//static
-void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
+void Connection::create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(stream, guid, observer, slot, flags);
+ Connection(stream, guid, observer, slot, flags);
}
//static
-void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
+void Connection::create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(stream, guid, slot, flags);
+ Connection(stream, guid, slot, flags);
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+Glib::RefPtr<Connection> Connection::create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
+ return Glib::RefPtr<Connection>(new Connection(stream, guid,
observer, cancellable, flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+Glib::RefPtr<Connection> Connection::create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
+ return Glib::RefPtr<Connection>(new Connection(stream, guid,
cancellable, flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+Glib::RefPtr<Connection> Connection::create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags)
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
+ return Glib::RefPtr<Connection>(new Connection(stream, guid,
observer, flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+Glib::RefPtr<Connection> Connection::create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
+ return Glib::RefPtr<Connection>(new Connection(stream, guid,
flags));
}
//static
-void DBusConnection::create_for_address(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+void Connection::create_for_address(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(address, observer, slot, cancellable, flags);
+ Connection(address, observer, slot, cancellable, flags);
}
//static
-void DBusConnection::create_for_address(const std::string& address,
+void Connection::create_for_address(const std::string& address,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(address, slot, cancellable, flags);
+ Connection(address, slot, cancellable, flags);
}
//static
-void DBusConnection::create_for_address(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+void Connection::create_for_address(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(address, observer, slot, flags);
+ Connection(address, observer, slot, flags);
}
//static
-void DBusConnection::create_for_address(const std::string& address,
+void Connection::create_for_address(const std::string& address,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
// Note that this does not return anything, because it is async - see
// create_finish().
- DBusConnection(address, slot, flags);
+ Connection(address, slot, flags);
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+Glib::RefPtr<Connection> Connection::create_for_address_sync(
const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer,
+ return Glib::RefPtr<Connection>(new Connection(address, observer,
cancellable, flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+Glib::RefPtr<Connection> Connection::create_for_address_sync(
const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(address, cancellable,
+ return Glib::RefPtr<Connection>(new Connection(address, cancellable,
flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+Glib::RefPtr<Connection> Connection::create_for_address_sync(
const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags)
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer,
+ return Glib::RefPtr<Connection>(new Connection(address, observer,
flags));
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+Glib::RefPtr<Connection> Connection::create_for_address_sync(
const std::string& address,
- DBusConnectionFlags flags)
+ ConnectionFlags flags)
{
- return Glib::RefPtr<DBusConnection>(new DBusConnection(address, flags));
+ return Glib::RefPtr<Connection>(new Connection(address, flags));
}
//static
-void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot,
+void Connection::get(BusType bus_type, const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -659,7 +662,7 @@ void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot,
}
//static
-void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot)
+void Connection::get(BusType bus_type, const SlotAsyncReady& slot)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -668,7 +671,7 @@ void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot)
}
//static
-Glib::RefPtr<DBusConnection> DBusConnection::get_sync(BusType bus_type)
+Glib::RefPtr<Connection> Connection::get_sync(BusType bus_type)
{
GError* gerror = 0;
@@ -681,12 +684,12 @@ Glib::RefPtr<DBusConnection> DBusConnection::get_sync(BusType bus_type)
return Glib::wrap(result);
}
-void DBusConnection::close()
+void Connection::close()
{
g_dbus_connection_close(gobj(), 0, 0, 0);
}
-void DBusConnection::close(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+void Connection::close(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -696,7 +699,7 @@ void DBusConnection::close(const SlotAsyncReady& slot, const Glib::RefPtr<Cancel
slot_copy);
}
-void DBusConnection::close(const SlotAsyncReady& slot)
+void Connection::close(const SlotAsyncReady& slot)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -706,7 +709,7 @@ void DBusConnection::close(const SlotAsyncReady& slot)
slot_copy);
}
-void DBusConnection::close_sync()
+void Connection::close_sync()
{
GError* gerror = 0;
g_dbus_connection_close_sync(gobj(), 0, &(gerror));
@@ -714,12 +717,12 @@ void DBusConnection::close_sync()
::Glib::Error::throw_exception(gerror);
}
-void DBusConnection::flush()
+void Connection::flush()
{
g_dbus_connection_flush(gobj(), 0, 0, 0);
}
-void DBusConnection::flush(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+void Connection::flush(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -729,7 +732,7 @@ void DBusConnection::flush(const SlotAsyncReady& slot, const Glib::RefPtr<Cancel
slot_copy);
}
-void DBusConnection::flush(const SlotAsyncReady& slot)
+void Connection::flush(const SlotAsyncReady& slot)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
@@ -739,7 +742,7 @@ void DBusConnection::flush(const SlotAsyncReady& slot)
slot_copy);
}
-void DBusConnection::flush_sync()
+void Connection::flush_sync()
{
GError* gerror = 0;
g_dbus_connection_flush_sync(gobj(), 0, &(gerror));
@@ -747,8 +750,8 @@ void DBusConnection::flush_sync()
::Glib::Error::throw_exception(gerror);
}
-bool DBusConnection::send_message(const Glib::RefPtr<DBusMessage>& message,
- DBusSendMessageFlags flags)
+bool Connection::send_message(const Glib::RefPtr<Message>& message,
+ SendMessageFlags flags)
{
GError* gerror = 0;
@@ -762,7 +765,7 @@ bool DBusConnection::send_message(const Glib::RefPtr<DBusMessage>& message,
return result;
}
-void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& message, int timeout_msec,const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+void Connection::send_message_with_reply(const Glib::RefPtr<Message>& message, int timeout_msec,const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
volatile guint32 out_serial = 0;
@@ -774,7 +777,7 @@ void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& me
message->set_serial(out_serial);
}
-void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& message, int timeout_msec,const SlotAsyncReady& slot)
+void Connection::send_message_with_reply(const Glib::RefPtr<Message>& message, int timeout_msec,const SlotAsyncReady& slot)
{
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
volatile guint32 out_serial = 0;
@@ -786,8 +789,8 @@ void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& me
message->set_serial(out_serial);
}
-Glib::RefPtr<DBusMessage> DBusConnection::send_message_with_reply_sync(
- const Glib::RefPtr<DBusMessage>& message,
+Glib::RefPtr<Message> Connection::send_message_with_reply_sync(
+ const Glib::RefPtr<Message>& message,
const Glib::RefPtr<Cancellable>& cancellable,
gint timeout_msec
)
@@ -807,8 +810,8 @@ Glib::RefPtr<DBusMessage> DBusConnection::send_message_with_reply_sync(
return Glib::wrap(result);
}
-Glib::RefPtr<DBusMessage> DBusConnection::send_message_with_reply_sync(
- const Glib::RefPtr<DBusMessage>& message,
+Glib::RefPtr<Message> Connection::send_message_with_reply_sync(
+ const Glib::RefPtr<Message>& message,
gint timeout_msec
)
{
@@ -827,7 +830,7 @@ Glib::RefPtr<DBusMessage> DBusConnection::send_message_with_reply_sync(
return Glib::wrap(result);
}
-void DBusConnection::call(
+void Connection::call(
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::ustring& method_name,
@@ -836,7 +839,7 @@ void DBusConnection::call(
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::ustring& bus_name,
int timeout_msec,
- DBusCallFlags flags,
+ CallFlags flags,
const Glib::VariantType& reply_type
)
{
@@ -853,7 +856,7 @@ void DBusConnection::call(
}
// Non-cancellable version.
-void DBusConnection::call(
+void Connection::call(
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::ustring& method_name,
@@ -861,7 +864,7 @@ void DBusConnection::call(
const SlotAsyncReady& slot,
const Glib::ustring& bus_name,
int timeout_msec,
- DBusCallFlags flags,
+ CallFlags flags,
const Glib::VariantType& reply_type
)
{
@@ -877,7 +880,7 @@ void DBusConnection::call(
&SignalProxy_async_callback, slot_copy);
}
-void DBusConnection::call_finish(
+void Connection::call_finish(
Glib::VariantBase& output,
const Glib::RefPtr<AsyncResult>& res
)
@@ -890,7 +893,7 @@ void DBusConnection::call_finish(
output.init(gvariant); // No need for extra ref.
}
-void DBusConnection::call_sync(
+void Connection::call_sync(
Glib::VariantBase& output,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
@@ -899,7 +902,7 @@ void DBusConnection::call_sync(
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::ustring& bus_name,
int timeout_msec,
- DBusCallFlags flags,
+ CallFlags flags,
const Glib::VariantType& reply_type
)
{
@@ -919,7 +922,7 @@ void DBusConnection::call_sync(
}
// Non-cancellable version.
-void DBusConnection::call_sync(
+void Connection::call_sync(
Glib::VariantBase& output,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
@@ -927,7 +930,7 @@ void DBusConnection::call_sync(
const Glib::VariantBase& parameters,
const Glib::ustring& bus_name,
int timeout_msec,
- DBusCallFlags flags,
+ CallFlags flags,
const Glib::VariantType& reply_type
)
{
@@ -945,7 +948,7 @@ void DBusConnection::call_sync(
output.init(gvariant); // No need to take extra reference.
}
-void DBusConnection::emit_signal(
+void Connection::emit_signal(
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::ustring& signal_name,
@@ -963,14 +966,14 @@ void DBusConnection::emit_signal(
::Glib::Error::throw_exception(gerror);
}
-guint DBusConnection::signal_subscribe(
+guint Connection::signal_subscribe(
const SlotSignal& slot,
const Glib::ustring& sender,
const Glib::ustring& interface_name,
const Glib::ustring& member,
const Glib::ustring& object_path,
const Glib::ustring& arg0,
- DBusSignalFlags flags
+ SignalFlags flags
)
{
SlotSignal* slot_copy = new SlotSignal(slot);
@@ -982,7 +985,7 @@ guint DBusConnection::signal_subscribe(
&DBusConnection_Signal_giomm_callback_destroy);
}
-guint DBusConnection::add_filter(const SlotMessageFilter& slot)
+guint Connection::add_filter(const SlotMessageFilter& slot)
{
SlotMessageFilter* slot_copy = new SlotMessageFilter(slot);
@@ -991,15 +994,15 @@ guint DBusConnection::add_filter(const SlotMessageFilter& slot)
DBusConnection_Message_Filter_giomm_callback_destroy);
}
-guint DBusConnection::register_object(const Glib::ustring& object_path,
- const Glib::RefPtr<DBusInterfaceInfo>& interface_info,
- const DBusInterfaceVTable* vtable)
+guint Connection::register_object(const Glib::ustring& object_path,
+ const Glib::RefPtr<InterfaceInfo>& interface_info,
+ const InterfaceVTable* vtable)
{
GError* gerror = 0;
const guint result = g_dbus_connection_register_object(gobj(),
object_path.c_str(), Glib::unwrap(interface_info),
- vtable->gobj(), const_cast<DBusInterfaceVTable*>(vtable), 0, &gerror);
+ vtable->gobj(), const_cast<InterfaceVTable*>(vtable), 0, &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
@@ -1007,15 +1010,15 @@ guint DBusConnection::register_object(const Glib::ustring& object_path,
return result;
}
-guint DBusConnection::register_subtree(const Glib::ustring& object_path,
- const DBusSubtreeVTable* vtable, DBusSubtreeFlags flags)
+guint Connection::register_subtree(const Glib::ustring& object_path,
+ const SubtreeVTable* vtable, SubtreeFlags flags)
{
GError* gerror = 0;
const guint result = g_dbus_connection_register_subtree(gobj(),
object_path.c_str(),
vtable->gobj(), static_cast<GDBusSubtreeFlags>(flags),
- const_cast<DBusSubtreeVTable*>(vtable), 0, &gerror);
+ const_cast<SubtreeVTable*>(vtable), 0, &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
@@ -1023,7 +1026,7 @@ guint DBusConnection::register_subtree(const Glib::ustring& object_path,
return result;
}
-DBusInterfaceVTable::DBusInterfaceVTable(
+InterfaceVTable::InterfaceVTable(
const SlotInterfaceMethodCall& slot_method_call,
const SlotInterfaceGetProperty& slot_get_property,
const SlotInterfaceSetProperty& slot_set_property
@@ -1037,32 +1040,32 @@ DBusInterfaceVTable::DBusInterfaceVTable(
gobject_.set_property = &DBusInterfaceVTable_SetProperty_giomm_callback;
}
-DBusInterfaceVTable::~DBusInterfaceVTable()
+InterfaceVTable::~InterfaceVTable()
{
delete slot_method_call_;
delete slot_get_property_;
delete slot_set_property_;
}
-DBusInterfaceVTable::SlotInterfaceMethodCall*
- DBusInterfaceVTable::get_slot_method_call() const
+InterfaceVTable::SlotInterfaceMethodCall*
+ InterfaceVTable::get_slot_method_call() const
{
return slot_method_call_;
}
-DBusInterfaceVTable::SlotInterfaceGetProperty*
- DBusInterfaceVTable::get_slot_get_property() const
+InterfaceVTable::SlotInterfaceGetProperty*
+ InterfaceVTable::get_slot_get_property() const
{
return slot_get_property_;
}
-DBusInterfaceVTable::SlotInterfaceSetProperty*
- DBusInterfaceVTable::get_slot_set_property() const
+InterfaceVTable::SlotInterfaceSetProperty*
+ InterfaceVTable::get_slot_set_property() const
{
return slot_set_property_;
}
-DBusSubtreeVTable::DBusSubtreeVTable(
+SubtreeVTable::SubtreeVTable(
const SlotSubtreeEnumerate& slot_enumerate,
const SlotSubtreeIntrospect& slot_introspect,
const SlotSubtreeDispatch& slot_dispatch
@@ -1076,29 +1079,31 @@ DBusSubtreeVTable::DBusSubtreeVTable(
gobject_.dispatch = &DBusSubtreeVTable_Dispatch_giomm_callback;
}
-DBusSubtreeVTable::~DBusSubtreeVTable()
+SubtreeVTable::~SubtreeVTable()
{
delete slot_enumerate_;
delete slot_introspect_;
delete slot_dispatch_;
}
-DBusSubtreeVTable::SlotSubtreeEnumerate*
- DBusSubtreeVTable::get_slot_enumerate() const
+SubtreeVTable::SlotSubtreeEnumerate*
+ SubtreeVTable::get_slot_enumerate() const
{
return slot_enumerate_;
}
-DBusSubtreeVTable::SlotSubtreeIntrospect*
- DBusSubtreeVTable::get_slot_introspect() const
+SubtreeVTable::SlotSubtreeIntrospect*
+ SubtreeVTable::get_slot_introspect() const
{
return slot_introspect_;
}
-DBusSubtreeVTable::SlotSubtreeDispatch*
- DBusSubtreeVTable::get_slot_dispatch() const
+SubtreeVTable::SlotSubtreeDispatch*
+ SubtreeVTable::get_slot_dispatch() const
{
return slot_dispatch_;
}
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusconnection.hg b/gio/src/dbusconnection.hg
index e6d4f72..9a84d32 100644
--- a/gio/src/dbusconnection.hg
+++ b/gio/src/dbusconnection.hg
@@ -20,6 +20,9 @@
#include <glibmm/object.h>
#include <giomm/initable.h>
#include <giomm/asyncinitable.h>
+#include <giomm/dbusauthobserver.h>
+#include <giomm/dbusmethodinvocation.h>
+#include <giomm/dbusintrospection.h>
#include <giomm/iostream.h>
#include <giomm/asyncresult.h>
#include <giomm/credentials.h>
@@ -33,145 +36,147 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
+namespace DBus
+{
+
_WRAP_ENUM(BusType, GBusType)
-_WRAP_ENUM(DBusCallFlags, GDBusCallFlags, NO_GTYPE)
-_WRAP_ENUM(DBusConnectionFlags, GDBusConnectionFlags, NO_GTYPE)
-_WRAP_ENUM(DBusSendMessageFlags, GDBusSendMessageFlags, NO_GTYPE)
-_WRAP_ENUM(DBusSignalFlags, GDBusSignalFlags, NO_GTYPE)
-_WRAP_ENUM(DBusSubtreeFlags, GDBusSubtreeFlags, NO_GTYPE)
-
-class DBusAuthObserver;
-class DBusInterfaceInfo;
-class DBusInterfaceVTable;
-class DBusMethodInvocation;
-class DBusSubtreeVTable;
+_WRAP_ENUM(CallFlags, GDBusCallFlags, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(ConnectionFlags, GDBusConnectionFlags, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(SendMessageFlags, GDBusSendMessageFlags, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(SignalFlags, GDBusSignalFlags, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(SubtreeFlags, GDBusSubtreeFlags, s#^DBUS_##, NO_GTYPE)
+
+class InterfaceVTable;
+class SubtreeVTable;
+
+_GMMPROC_EXTRA_NAMESPACE(DBus)
/// @defgroup DBus D-Bus API
//TODO: Add example from C API in class docs.
-/** DBusConnection - D-Bus Connections.
- * The DBusConnection type is used for D-Bus connections to remote peers such
+/** A D-Bus Connection.
+ * The Connection type is used for D-Bus connections to remote peers such
* as a message buses. It is a low-level API that offers a lot of flexibility.
* For instance, it lets you establish a connection over any transport that
* can by represented as an IOStream.
*
* This class is rarely used directly in D-Bus clients. If you are writing an
* D-Bus client, it is often easier to use the Gio::DBus::own_name(),
- * Gio::DBus::watch_name() or DBusProxy::create_for_bus() APIs.
+ * Gio::DBus::watch_name() or Gio::DBus::Proxy::create_for_bus() APIs.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusConnection
+class Connection
: public Glib::Object, public Initable, public AsyncInitable
{
protected:
- _CLASS_GOBJECT(DBusConnection, GDBusConnection, G_DBUS_CONNECTION, Glib::Object, GObject)
+ _CLASS_GOBJECT(Connection, GDBusConnection, G_DBUS_CONNECTION, Glib::Object, GObject)
_IMPLEMENTS_INTERFACE(Initable)
_IMPLEMENTS_INTERFACE(AsyncInitable)
protected:
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags);
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags);
- DBusConnection(const Glib::RefPtr<IOStream>& stream,
+ Connection(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
+ Connection(const std::string& address,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
+ Connection(const std::string& address,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
+ Connection(const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags);
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags);
+ Connection(const std::string& address,
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags);
- DBusConnection(const std::string& address,
- DBusConnectionFlags flags);
+ Connection(const std::string& address,
+ ConnectionFlags flags);
public:
/** Signature for slot used in signal_subscribe().
* For example,
* @code
- * void on_signal(const Glib::RefPtr<DBusConnection>& connection, const
+ * void on_signal(const Glib::RefPtr<Connection>& connection, const
* Glib::ustring& sender_name, const Glib::ustring& object_path, const
* Glib::ustring& object_path, const Glib::ustring& interface_name, const
* Glib::ustring& signal_name, const Glib::VariantBase& parameters);.
* @endcode
*/
- typedef sigc::slot<void, const Glib::RefPtr<DBusConnection>&,
+ typedef sigc::slot<void, const Glib::RefPtr<Connection>&,
const Glib::ustring&, const Glib::ustring&, const Glib::ustring&,
const Glib::ustring&, const Glib::VariantBase&> SlotSignal;
/** Signature for slot used in add_filter().
* For example,
* @code
- * Glib::RefPtr<DBusMessage> on_message_filter(const
- * Glib::RefPtr<DBusConnection> connection, const Glib::RefPtr<DBusMessage>&
+ * Glib::RefPtr<Message> on_message_filter(const
+ * Glib::RefPtr<Connection> connection, const Glib::RefPtr<Message>&
* message, bool incoming);.
* @endcode
*
@@ -181,9 +186,9 @@ public:
* drop a message can simply return <tt>0</tt>. And filter function may
* modify a message by copying it and return the copy.
*/
- typedef sigc::slot<Glib::RefPtr<DBusMessage>,
- const Glib::RefPtr<DBusConnection>&,
- const Glib::RefPtr<DBusMessage>&, bool> SlotMessageFilter;
+ typedef sigc::slot<Glib::RefPtr<Message>,
+ const Glib::RefPtr<Connection>&,
+ const Glib::RefPtr<Message>&, bool> SlotMessageFilter;
/** Asynchronously connects to the message bus specified by @a bus_type.
*
@@ -209,128 +214,128 @@ public:
_WRAP_METHOD_DOCS_ONLY( g_bus_get_finish, errthrow)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusConnection> get_finish(const Glib::RefPtr<AsyncResult>& res), g_bus_get_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Connection> get_finish(const Glib::RefPtr<AsyncResult>& res), g_bus_get_finish, errthrow)
- _WRAP_METHOD(static Glib::RefPtr<DBusConnection> get_sync(BusType bus_type, const Glib::RefPtr<Cancellable>& cancellable), g_bus_get_sync, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Connection> get_sync(BusType bus_type, const Glib::RefPtr<Cancellable>& cancellable), g_bus_get_sync, errthrow)
/// A Non-cancellable version of get_sync().
- static Glib::RefPtr<DBusConnection> get_sync(BusType bus_type);
+ static Glib::RefPtr<Connection> get_sync(BusType bus_type);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new)
static void create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new)
static void create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create().
static void create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create().
static void create(const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusConnection> create_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Connection> create_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address)
static void create_for_address(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address)
static void create_for_address(const std::string& address,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_for_address().
static void create_for_address(const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_for_address().
static void create_for_address(const std::string& address,
const SlotAsyncReady& slot,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusConnection> create_for_address_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_for_address_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Connection> create_for_address_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_for_address_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusConnection> create_sync(
+ static Glib::RefPtr<Connection> create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusConnection> create_sync(
+ static Glib::RefPtr<Connection> create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_sync().
- static Glib::RefPtr<DBusConnection> create_sync(
+ static Glib::RefPtr<Connection> create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_sync().
- static Glib::RefPtr<DBusConnection> create_sync(
+ static Glib::RefPtr<Connection> create_sync(
const Glib::RefPtr<IOStream>& stream,
const std::string& guid,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusConnection> create_for_address_sync(
+ static Glib::RefPtr<Connection> create_for_address_sync(
const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusConnection> create_for_address_sync(
+ static Glib::RefPtr<Connection> create_for_address_sync(
const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_for_address_sync().
- static Glib::RefPtr<DBusConnection> create_for_address_sync(
+ static Glib::RefPtr<Connection> create_for_address_sync(
const std::string& address,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ const Glib::RefPtr<AuthObserver>& observer,
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/// Non-cancellable version of create_for_address_sync().
- static Glib::RefPtr<DBusConnection> create_for_address_sync(
+ static Glib::RefPtr<Connection> create_for_address_sync(
const std::string& address,
- DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+ ConnectionFlags flags = Gio::DBus::CONNECTION_FLAGS_NONE);
/** Closes the connection. Note that this never causes the process to exit
* (this might only happen if the other end of a shared message bus
@@ -498,17 +503,17 @@ public:
//TODO: In the C API, out_serial is volatile, but gmmproc can't parse that.
#m4 _CONVERSION(`guint32&',`volatile guint32*',`&($3)')
- _WRAP_METHOD(bool send_message(const Glib::RefPtr<DBusMessage>& message, DBusSendMessageFlags flags, guint32& out_serial), g_dbus_connection_send_message, errthrow)
+ _WRAP_METHOD(bool send_message(const Glib::RefPtr<Message>& message, SendMessageFlags flags, guint32& out_serial), g_dbus_connection_send_message, errthrow)
/// A send_message() without an "out_serial" parameter.
- bool send_message(const Glib::RefPtr<DBusMessage>& message,
- DBusSendMessageFlags flags = Gio::DBUS_SEND_MESSAGE_FLAGS_NONE);
+ bool send_message(const Glib::RefPtr<Message>& message,
+ SendMessageFlags flags = Gio::DBus::SEND_MESSAGE_FLAGS_NONE);
/** Asynchronously sends message to the peer represented by the connection.
*
- * Unless flags contain the Gio::DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
+ * Unless flags contain the Gio::DBus::SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
* flag, the serial number will be assigned by the connection and set on
- * message via Gio::DBusMessage::set_serial().
+ * message via Gio::DBus::Message::set_serial().
*
* If the connection is closed then the operation will fail with
* Gio::IO_ERROR_CLOSED. If @a cancellable is canceled, the operation will
@@ -522,7 +527,7 @@ public:
* send_message_with_reply_sync() for the synchronous version.
*
* Note that message must be unlocked, unless flags contain the
- * Gio::DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+ * Gio::DBus::SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
*
* See the C API docs for examples.
*
@@ -534,7 +539,7 @@ public:
*
* @newin{2,28}
*/
- void send_message_with_reply(const Glib::RefPtr<DBusMessage>& message,
+ void send_message_with_reply(const Glib::RefPtr<Message>& message,
int timeout_msec,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable);
@@ -542,22 +547,22 @@ public:
/** Non-cancellable version of send_message_with_reply().
*/
- void send_message_with_reply(const Glib::RefPtr<DBusMessage>& message,
+ void send_message_with_reply(const Glib::RefPtr<Message>& message,
int timeout_msec,
const SlotAsyncReady& slot);
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_send_message_with_reply_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(Glib::RefPtr<DBusMessage> send_message_with_reply_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_connection_send_message_with_reply_finish, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<Message> send_message_with_reply_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_connection_send_message_with_reply_finish, errthrow)
/** Synchronously sends @a message to the peer represented by the connection
* and blocks the calling thread until a reply is received or the timeout is
* reached. See send_message_with_reply() for the asynchronous version of
* this method.
*
- * Unless flags contain the Gio::DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
+ * Unless flags contain the Gio::DBus::SEND_MESSAGE_FLAGS_PRESERVE_SERIAL
* flag, the serial number will be assigned by the connection and set on
- * message via Gio::DBusMessage::set_serial().
+ * message via Gio::DBus::Message::set_serial().
*
* If the connection is closed then the operation will fail with
* Gio::IO_ERROR_CLOSED. If @a cancellable is canceled, the operation will
@@ -566,13 +571,13 @@ public:
*
* Note that a Glib::Error is thrown if a local in-process error occured.
* That is to say that the returned DBusMessage object may be of type
- * G_DBUS_MESSAGE_TYPE_ERROR. Use Gio::DBusMessage::to_exception() to
+ * G_DBUS_MESSAGE_TYPE_ERROR. Use Gio::DBus::Message::to_exception() to
* transcode this to a Glib::Error.
*
* See the C API docs for examples.
*
* Note that message must be unlocked, unless flags contain the
- * Gio::DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+ * Gio::DBus::SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
*
* @param message A DBusMessage.
* @param cancellable A Cancellable.
@@ -583,16 +588,16 @@ public:
* @throw Glib::Error.
* @newin{2,28}
*/
- Glib::RefPtr<DBusMessage> send_message_with_reply_sync(
- const Glib::RefPtr<DBusMessage>& message,
+ Glib::RefPtr<Message> send_message_with_reply_sync(
+ const Glib::RefPtr<Message>& message,
const Glib::RefPtr<Cancellable>& cancellable,
gint timeout_msec
);
_IGNORE(g_dbus_connection_send_message_with_reply_sync)
/// A non-cancellable version of send_message_with_reply_sync().
- Glib::RefPtr<DBusMessage> send_message_with_reply_sync(
- const Glib::RefPtr<DBusMessage>& message,
+ Glib::RefPtr<Message> send_message_with_reply_sync(
+ const Glib::RefPtr<Message>& message,
gint timeout_msec
);
@@ -605,7 +610,7 @@ public:
_WRAP_METHOD(std::string get_guid() const, g_dbus_connection_get_guid)
_WRAP_METHOD(Glib::ustring get_unique_name() const, g_dbus_connection_get_unique_name)
- _WRAP_METHOD(DBusCapabilityFlags get_capabilities() const, g_dbus_connection_get_capabilities)
+ _WRAP_METHOD(CapabilityFlags get_capabilities() const, g_dbus_connection_get_capabilities)
_WRAP_METHOD(Glib::RefPtr<Credentials> get_peer_credentials(), g_dbus_connection_get_peer_credentials, refreturn)
_WRAP_METHOD(Glib::RefPtr<const Credentials> get_peer_credentials() const, g_dbus_connection_get_peer_credentials, refreturn, constversion)
@@ -642,7 +647,7 @@ public:
* connection is not a message bus connection.
* @param timeout_msec The timeout in milliseconds, -1 to use the default
* timeout or G_MAXINT for no timeout.
- * @param flags Flags from the Gio::DBusCallFlags enumeration.
+ * @param flags Flags from the Gio::DBus::CallFlags enumeration.
* @param reply_type The expected type of the reply, or <tt>0</tt>.
* @newin{2,28}
*/
@@ -655,7 +660,7 @@ public:
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::ustring& bus_name = Glib::ustring(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE,
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType()
);
_IGNORE(g_dbus_connection_call)
@@ -669,7 +674,7 @@ public:
const SlotAsyncReady& slot,
const Glib::ustring& bus_name = Glib::ustring(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE,
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType()
);
@@ -715,7 +720,7 @@ public:
* connection is not a message bus connection.
* @param timeout_msec The timeout in milliseconds, -1 to use the default
* timeout or G_MAXINT for no timeout.
- * @param flags Flags from the Gio::DBusCallFlags enumeration.
+ * @param flags Flags from the Gio::DBus::CallFlags enumeration.
* @param reply_type The expected type of the reply, or <tt>0</tt>.
* @throw Glib::Error.
* @newin{2,28}
@@ -729,7 +734,7 @@ public:
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::ustring& bus_name = Glib::ustring(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE,
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType()
);
_IGNORE(g_dbus_connection_call_sync)
@@ -743,7 +748,7 @@ public:
const Glib::VariantBase& parameters,
const Glib::ustring& bus_name = Glib::ustring(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE,
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType()
);
@@ -809,7 +814,7 @@ public:
const Glib::ustring& member = Glib::ustring(),
const Glib::ustring& object_path = Glib::ustring(),
const Glib::ustring& arg0 = Glib::ustring(),
- DBusSignalFlags flags = Gio::DBUS_SIGNAL_FLAGS_NONE
+ SignalFlags flags = Gio::DBus::SIGNAL_FLAGS_NONE
);
_IGNORE(g_dbus_connection_signal_subscribe)
@@ -874,15 +879,15 @@ public:
*
* @param object_path The object path to register at.
* @param interface_info Introspection data for the interface.
- * @param vtable A GDBusInterfaceVTable to call into or NULL.
+ * @param vtable An InterfaceVTable to call into or NULL.
* @return A registration id (never 0) that can be used with
* unregister_object() if no Glib::Error is thrown.
* @throw Glib::Error.
* @newin{2,28}
*/
guint register_object(const Glib::ustring& object_path,
- const Glib::RefPtr<DBusInterfaceInfo>& interface_info,
- const DBusInterfaceVTable* vtable);
+ const Glib::RefPtr<InterfaceInfo>& interface_info,
+ const InterfaceVTable* vtable);
_IGNORE(g_dbus_connection_register_object)
_WRAP_METHOD(bool unregister_object(guint registration_id), g_dbus_connection_unregister_object)
@@ -895,10 +900,10 @@ public:
*
* When handling remote calls into any node in the subtree, first the
* enumerate slot is used to check if the node exists. If the node
- * exists or the Gio::DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag
+ * exists or the Gio::DBus::SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag
* is set the introspection slot is used to check if the node supports the
* requested method. If so, the dispatch function is used to determine where
- * to dispatch the call. The collected DBusInterfaceVTable will be used to
+ * to dispatch the call. The collected InterfaceVTable will be used to
* call into the interface vtable for processing the request.
*
* All calls into user-provided code will be invoked in the thread-default
@@ -915,7 +920,7 @@ public:
*
*
* @param object_path The object path to register the subtree at.
- * @param vtable A DBusSubtreeVTable to enumerate, introspect and dispatch
+ * @param vtable A SubtreeVTable to enumerate, introspect and dispatch
* nodes in the subtree.
* @param flags Flags used to fine tune the behavior of the subtree.
* @return A subtree registration id (never 0) that can be used with
@@ -924,18 +929,18 @@ public:
* @newin{2,28}
*/
guint register_subtree(const Glib::ustring& object_path,
- const DBusSubtreeVTable* vtable,
- DBusSubtreeFlags flags = Gio::DBUS_SUBTREE_FLAGS_NONE);
+ const SubtreeVTable* vtable,
+ SubtreeFlags flags = Gio::DBus::SUBTREE_FLAGS_NONE);
_IGNORE(g_dbus_connection_register_subtree)
_WRAP_METHOD(bool unregister_subtree(guint registration_id), g_dbus_connection_unregister_subtree)
//_WRAP_PROPERTY("address", std::string) // write-only construct-only
//_WRAP_PROPERTY("authentication-observer", Glib::RefPtr<AuthObserver>) // write-only construct-only
- _WRAP_PROPERTY("capabilities", DBusCapabilityFlags)
+ _WRAP_PROPERTY("capabilities", CapabilityFlags)
_WRAP_PROPERTY("closed", bool)
_WRAP_PROPERTY("exit-on-close", bool)
- //_WRAP_PROPERTY("flags", DBusConnectionFlags) // write-only construct-only
+ //_WRAP_PROPERTY("flags", ConnectionFlags) // write-only construct-only
_WRAP_PROPERTY("guid", std::string)
_WRAP_PROPERTY("stream", Glib::RefPtr<IOStream>)
_WRAP_PROPERTY("unique-name", Glib::ustring)
@@ -944,12 +949,12 @@ public:
_WRAP_SIGNAL(void closed(bool remote_peer_vanished, const Glib::Error& error), "closed", no_default_handler)
};
-/** DBusInterfaceVTable - A class used to represent a virtual table for
+/**This represents a virtual table for
* handling properties and method calls for a D-Bus interface.
*
* If you want to handle getting/setting D-Bus properties asynchronously,
* simply register an object with the org.freedesktop.DBus.Properties D-Bus
- * interface using Gio::DBusConnection::register_object().
+ * interface using Gio::DBus::Connection::register_object().
*
* The only correct use of this class is to declare a global instance of it
* (or an instance local to the main function) and pass pointers to the
@@ -962,30 +967,30 @@ public:
* @newin{2,28}
* @ingroup DBus
*/
-class DBusInterfaceVTable
+class InterfaceVTable
{
- _CLASS_GENERIC(DBusInterfaceVTable, GDBusInterfaceVTable)
+ _CLASS_GENERIC(InterfaceVTable, GDBusInterfaceVTable)
public:
/** The type for a slot which handles a method call for a D-Bus interface.
* for example,
* @code
- * void on_interface_method_call(const Glib::RefPtr<Gio::DBusConnection>&
+ * void on_interface_method_call(const Glib::RefPtr<Gio::DBus::Connection>&
* connection, const Glib::ustring& sender, const Glib::ustring&
* object_path, const Glib::ustring& interface_name, const Glib::ustring&
* method_name, const Glib::VariantBase& parameters, const
- * Glib::RefPtr<Gio::DBusMethodInvocation>& invocation);
+ * Glib::RefPtr<Gio::DBus::MethodInvocation>& invocation);
* @endcode
*/
typedef sigc::slot<
void,
- const Glib::RefPtr<DBusConnection>&,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::VariantBase&,
- const Glib::RefPtr<DBusMethodInvocation>&
+ const Glib::RefPtr<MethodInvocation>&
> SlotInterfaceMethodCall;
/** The type for a slot which handles getting a property for a D-Bus
@@ -993,7 +998,7 @@ public:
* for example,
* @code
* void on_interface_get_property(Glib::VariantBase& property, const
- * Glib::RefPtr<Gio::DBusConnection>& connection, const Glib::ustring&
+ * Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring&
* sender, const Glib::ustring& object_path, const Glib::ustring&
* interface_name, const Glib::ustring& property_name);
* @endcode
@@ -1002,7 +1007,7 @@ public:
typedef sigc::slot<
void,
Glib::VariantBase&,
- const Glib::RefPtr<DBusConnection>&,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&,
@@ -1013,7 +1018,7 @@ public:
* interface.
* for example,
* @code
- * bool on_interface_set_property(const Glib::RefPtr<Gio::DBusConnection>&
+ * bool on_interface_set_property(const Glib::RefPtr<Gio::DBus::Connection>&
* connection, const Glib::ustring& sender, const Glib::ustring&
* object_path, const Glib::ustring& interface_name, const Glib::ustring&
* property_name, const Glib::VariantBase& value);
@@ -1022,7 +1027,7 @@ public:
*/
typedef sigc::slot<
bool,
- const Glib::RefPtr<DBusConnection>&,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&,
@@ -1030,19 +1035,19 @@ public:
const Glib::VariantBase&
> SlotInterfaceSetProperty;
- /** Constructs a new DBusInterfaceVTable using the specified slots.
+ /** Constructs a new InterfaceVTable using the specified slots.
* @param slot_method_call The slot for handling incoming method calls.
* @param slot_get_property The slot for getting a property.
* @param slot_set_property The slot for setting a property.
*/
- explicit DBusInterfaceVTable(
+ explicit InterfaceVTable(
const SlotInterfaceMethodCall& slot_method_call,
const SlotInterfaceGetProperty& slot_get_property = SlotInterfaceGetProperty(),
const SlotInterfaceSetProperty& slot_set_property = SlotInterfaceSetProperty()
);
/// Destructor.
- virtual ~DBusInterfaceVTable();
+ virtual ~InterfaceVTable();
/// Provides access to the underlying C object.
GDBusInterfaceVTable* gobj()
@@ -1055,13 +1060,13 @@ public:
private:
// Non-copyable.
- DBusInterfaceVTable(const DBusInterfaceVTable& other);
- DBusInterfaceVTable& operator=(const DBusInterfaceVTable& other);
+ InterfaceVTable(const InterfaceVTable& other);
+ InterfaceVTable& operator=(const InterfaceVTable& other);
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// These are so the C callbacks and the
- // Gio::DBusConnection::register_object() method can have access to the
+ // Gio::DBus::Connection::register_object() method can have access to the
// copies of the slots used for creation when registering.
SlotInterfaceMethodCall* get_slot_method_call() const;
SlotInterfaceGetProperty* get_slot_get_property() const;
@@ -1078,8 +1083,8 @@ protected:
SlotInterfaceSetProperty* slot_set_property_;
};
-/** DBusSubtreeVTable - A class used to represent a virtual table for
- * subtrees registered with Gio::DBusConnection::register_subtree().
+/** This represents a virtual table for
+ * subtrees registered with Gio::DBus::Connection::register_subtree().
*
* The only correct use of this class is to declare a global instance of it
* (or an instance local to the main function) and pass pointers to the
@@ -1092,16 +1097,16 @@ protected:
* @newin{2,28}
* @ingroup DBus
*/
-class DBusSubtreeVTable
+class SubtreeVTable
{
- _CLASS_GENERIC(DBusSubtreeVTable, GDBusSubtreeVTable)
+ _CLASS_GENERIC(SubtreeVTable, GDBusSubtreeVTable)
public:
/** The type for a slot which handles enumerating child nodes.
*
* This slot is called when generating introspection data and also when
* preparing to dispatch incoming messages in the event that the
- * Gio::DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not
+ * Gio::DBus::SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not
* specified (ie: to verify that the object path is valid).
*
* Hierarchies are not supported; the items that you return should not
@@ -1110,13 +1115,13 @@ public:
* For example,
* @code
* std::vector<Glib::ustring> on_subtree_enumerate(const
- * Glib::RefPtr<Gio::DBusConnection>& connection, const Glib::ustring&
+ * Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring&
* sender, const Glib::ustring& object_path);
* @endcode
*/
typedef sigc::slot<
std::vector<Glib::ustring>,
- const Glib::RefPtr<DBusConnection>&,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&
> SlotSubtreeEnumerate;
@@ -1135,15 +1140,15 @@ public:
*
* for example,
* @code
- * std::vector< Glib::RefPtr<Gio::DBusInterFaceInfo> >
- * on_subtree_introspect(const Glib::RefPtr<Gio::DBusConnection>&
+ * std::vector< Glib::RefPtr<Gio::DBus::InterFaceInfo> >
+ * on_subtree_introspect(const Glib::RefPtr<Gio::DBus::Connection>&
* connection, const Glib::ustring& sender, const Glib::ustring&
* object_path, const Glib::ustring& node);
* @endcode
*/
typedef sigc::slot<
- std::vector< Glib::RefPtr<Gio::DBusInterfaceInfo> >,
- const Glib::RefPtr<DBusConnection>&,
+ std::vector< Glib::RefPtr<Gio::DBus::InterfaceInfo> >,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&
@@ -1157,34 +1162,34 @@ public:
*
* for example,
* @code
- * const Gio::DBusInterfaceVTable* on_subtree_dispatch(const
- * Glib::RefPtr<Gio::DBusConnection>& connection, const Glib::ustring&
+ * const Gio::DBus::InterfaceVTable* on_subtree_dispatch(const
+ * Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring&
* sender, const Glib::ustring& object_path, const Glib::ustring&
* interface_name, const Glib::ustring& node);
* @endcode
*/
typedef sigc::slot<
- const DBusInterfaceVTable*,
- const Glib::RefPtr<DBusConnection>&,
+ const InterfaceVTable*,
+ const Glib::RefPtr<Connection>&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&,
const Glib::ustring&
> SlotSubtreeDispatch;
- /** Constructs a new DBusSubtreeVTable using specified slots.
+ /** Constructs a new SubtreeVTable using specified slots.
* @param slot_enumerate The slot for handling incoming method calls.
* @param slot_introspect The slot for getting a property.
* @param slot_dispatch The slot for setting a property.
*/
- explicit DBusSubtreeVTable(
+ explicit SubtreeVTable(
const SlotSubtreeEnumerate& slot_enumerate,
const SlotSubtreeIntrospect& slot_introspect = SlotSubtreeIntrospect(),
const SlotSubtreeDispatch& slot_dispatch = SlotSubtreeDispatch()
);
/// Destructor.
- virtual ~DBusSubtreeVTable();
+ virtual ~SubtreeVTable();
/// Provides access to the underlying C object.
GDBusSubtreeVTable* gobj()
@@ -1197,13 +1202,13 @@ public:
private:
// Non-copyable.
- DBusSubtreeVTable(const DBusSubtreeVTable& other);
- DBusSubtreeVTable& operator=(const DBusSubtreeVTable& other);
+ SubtreeVTable(const SubtreeVTable& other);
+ SubtreeVTable& operator=(const SubtreeVTable& other);
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// These are so the C callbacks and the
- // Gio::DBusConnection::register_subtreee() method can have access to the
+ // Gio::DBus::Connection::register_subtreee() method can have access to the
// copies of the slots used for creation when registering.
SlotSubtreeEnumerate* get_slot_enumerate() const;
SlotSubtreeIntrospect* get_slot_introspect() const;
@@ -1220,4 +1225,6 @@ protected:
SlotSubtreeDispatch* slot_dispatch_;
};
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbuserrorutils.ccg b/gio/src/dbuserrorutils.ccg
index 796761b..dcf0c2f 100644
--- a/gio/src/dbuserrorutils.ccg
+++ b/gio/src/dbuserrorutils.ccg
@@ -25,7 +25,7 @@ namespace Gio
namespace DBus
{
-namespace Error
+namespace ErrorUtils
{
bool is_remote_error(const Glib::Error& error)
@@ -43,7 +43,7 @@ bool strip_remote_error(Glib::Error& error)
return static_cast<bool>(g_dbus_error_strip_remote_error(error.gobj()));
}
-} // namespace Error
+} // namespace ErrorUtils
} // namespace DBus
diff --git a/gio/src/dbuserrorutils.hg b/gio/src/dbuserrorutils.hg
index f7f8707..7ec998c 100644
--- a/gio/src/dbuserrorutils.hg
+++ b/gio/src/dbuserrorutils.hg
@@ -25,7 +25,7 @@ namespace Gio
namespace DBus
{
-namespace Error
+namespace ErrorUtils
{
/** Checks if @a error represents an error received via D-Bus from a remote
@@ -43,7 +43,7 @@ bool is_remote_error(const Glib::Error& error);
*
* This function is guaranteed to return a D-Bus error name for all
* Glib::Error instances returned from functions handling remote method calls
- * (e.g. Gio::DBusConnection::call_finish()) unless strip_remote_error() has
+ * (e.g. Gio::DBus::Connection::call_finish()) unless strip_remote_error() has
* been used on @a error.
*
* @param error A Glib::Error.
@@ -68,7 +68,7 @@ Glib::ustring get_remote_error(const Glib::Error& error);
*/
bool strip_remote_error(Glib::Error& error);
-} // namespace Error
+} // namespace ErrorUtils
} // namespace DBus
diff --git a/gio/src/dbusintrospection.hg b/gio/src/dbusintrospection.hg
index 757392d..b125fe4 100644
--- a/gio/src/dbusintrospection.hg
+++ b/gio/src/dbusintrospection.hg
@@ -25,43 +25,46 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
-_WRAP_ENUM(DBusPropertyInfoFlags, GDBusPropertyInfoFlags, NO_GTYPE)
+namespace DBus
+{
+
+_WRAP_ENUM(PropertyInfoFlags, GDBusPropertyInfoFlags, s#^DBUS_##, NO_GTYPE)
-/** DBusAnnotationInfo - Stores information about an annotation.
+/** Stores information about an annotation.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusAnnotationInfo
+class AnnotationInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusAnnotationInfo, GDBusAnnotationInfo, NONE, g_dbus_annotation_info_ref, g_dbus_annotation_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(AnnotationInfo, GDBusAnnotationInfo, NONE, g_dbus_annotation_info_ref, g_dbus_annotation_info_unref)
public:
-#m4 _CONVERSION(`const Glib::ArrayHandle< Glib::RefPtr<DBusAnnotationInfo> >&', `GDBusAnnotationInfo**', `const_cast<GDBusAnnotationInfo**>($3.data())')
- _WRAP_METHOD(static Glib::ustring info_lookup(const Glib::ArrayHandle< Glib::RefPtr<DBusAnnotationInfo> >& annotations, const Glib::ustring& name), g_dbus_annotation_info_lookup)
+#m4 _CONVERSION(`const Glib::ArrayHandle< Glib::RefPtr<AnnotationInfo> >&', `GDBusAnnotationInfo**', `const_cast<GDBusAnnotationInfo**>($3.data())')
+ _WRAP_METHOD(static Glib::ustring info_lookup(const Glib::ArrayHandle< Glib::RefPtr<AnnotationInfo> >& annotations, const Glib::ustring& name), g_dbus_annotation_info_lookup)
};
-/** DBusArgInfo - Stores information about an argument for a method or a
+/** ArgInfo - Stores information about an argument for a method or a
* signal.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusArgInfo
+class ArgInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusArgInfo, GDBusArgInfo, NONE, g_dbus_arg_info_ref, g_dbus_arg_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(ArgInfo, GDBusArgInfo, NONE, g_dbus_arg_info_ref, g_dbus_arg_info_unref)
public:
};
-/** DBusMethodInfo - Stores information about a method on an D-Bus interface.
+/** Stores information about a method on an D-Bus interface.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusMethodInfo
+class MethodInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusMethodInfo, GDBusMethodInfo, NONE, g_dbus_method_info_ref, g_dbus_method_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(MethodInfo, GDBusMethodInfo, NONE, g_dbus_method_info_ref, g_dbus_method_info_unref)
public:
};
@@ -71,9 +74,9 @@ public:
* @newin{2,28}
* @ingroup DBus
*/
-class DBusSignalInfo
+class SignalInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusSignalInfo, GDBusSignalInfo, NONE, g_dbus_signal_info_ref, g_dbus_signal_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(SignalInfo, GDBusSignalInfo, NONE, g_dbus_signal_info_ref, g_dbus_signal_info_unref)
public:
};
@@ -83,54 +86,56 @@ public:
* @newin{2,28}
* @ingroup DBus
*/
-class DBusPropertyInfo
+class PropertyInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusPropertyInfo, GDBusPropertyInfo, NONE, g_dbus_property_info_ref, g_dbus_property_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(PropertyInfo, GDBusPropertyInfo, NONE, g_dbus_property_info_ref, g_dbus_property_info_unref)
public:
};
-/** DBusInterfaceInfo - Stores information about a D-Bus interface.
+/** Stores information about a D-Bus interface.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusInterfaceInfo
+class InterfaceInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusInterfaceInfo, GDBusInterfaceInfo, NONE, g_dbus_interface_info_ref, g_dbus_interface_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(InterfaceInfo, GDBusInterfaceInfo, NONE, g_dbus_interface_info_ref, g_dbus_interface_info_unref)
public:
- _WRAP_METHOD(Glib::RefPtr<DBusMethodInfo> lookup_method(const Glib::ustring& name), g_dbus_interface_info_lookup_method, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusMethodInfo> lookup_method(const Glib::ustring& name) const, g_dbus_interface_info_lookup_method, constversion, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<MethodInfo> lookup_method(const Glib::ustring& name), g_dbus_interface_info_lookup_method, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const MethodInfo> lookup_method(const Glib::ustring& name) const, g_dbus_interface_info_lookup_method, constversion, refreturn)
- _WRAP_METHOD(Glib::RefPtr<DBusSignalInfo> lookup_signal(const Glib::ustring& name), g_dbus_interface_info_lookup_signal, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusSignalInfo> lookup_signal(const Glib::ustring& name) const, g_dbus_interface_info_lookup_signal, constversion, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<SignalInfo> lookup_signal(const Glib::ustring& name), g_dbus_interface_info_lookup_signal, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const SignalInfo> lookup_signal(const Glib::ustring& name) const, g_dbus_interface_info_lookup_signal, constversion, refreturn)
- _WRAP_METHOD(Glib::RefPtr<DBusPropertyInfo> lookup_property(const Glib::ustring& name), g_dbus_interface_info_lookup_property, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusPropertyInfo> lookup_property(const Glib::ustring& name) const, g_dbus_interface_info_lookup_property, constversion, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<PropertyInfo> lookup_property(const Glib::ustring& name), g_dbus_interface_info_lookup_property, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const PropertyInfo> lookup_property(const Glib::ustring& name) const, g_dbus_interface_info_lookup_property, constversion, refreturn)
//TODO: _WRAP_METHOD(void generate_xml(guint indent, GString* string_builder), g_dbus_interface_info_generate_xml)
};
-/** DBusNodeInfo - Stores information about nodes in a remote object
+/** NodeInfo - Stores information about nodes in a remote object
* hierarchy.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusNodeInfo
+class NodeInfo
{
- _CLASS_OPAQUE_REFCOUNTED(DBusNodeInfo, GDBusNodeInfo, NONE, g_dbus_node_info_ref, g_dbus_node_info_unref)
+ _CLASS_OPAQUE_REFCOUNTED(NodeInfo, GDBusNodeInfo, NONE, g_dbus_node_info_ref, g_dbus_node_info_unref)
public:
_WRAP_METHOD_DOCS_ONLY(g_dbus_node_info_new_for_xml)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusNodeInfo> create_for_xml(const Glib::ustring& xml_data), g_dbus_node_info_new_for_xml, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<NodeInfo> create_for_xml(const Glib::ustring& xml_data), g_dbus_node_info_new_for_xml, errthrow)
- _WRAP_METHOD(Glib::RefPtr<DBusInterfaceInfo> lookup_interface(const Glib::ustring& name), g_dbus_node_info_lookup_interface, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusInterfaceInfo> lookup_interface(const Glib::ustring& name) const, g_dbus_node_info_lookup_interface, constversion, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<InterfaceInfo> lookup_interface(const Glib::ustring& name), g_dbus_node_info_lookup_interface, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const InterfaceInfo> lookup_interface(const Glib::ustring& name) const, g_dbus_node_info_lookup_interface, constversion, refreturn)
//TODO: _WRAP_METHOD(void generate_xml(guint indent, GString* string_builder), g_dbus_node_info_generate_xml)
};
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusmessage.ccg b/gio/src/dbusmessage.ccg
index b2229f4..8e43a3a 100644
--- a/gio/src/dbusmessage.ccg
+++ b/gio/src/dbusmessage.ccg
@@ -25,9 +25,12 @@
namespace Gio
{
-typedef DBusMessage::ByteOrder ByteOrder;
+namespace DBus
+{
+
+typedef Message::ByteOrder ByteOrder;
-void DBusMessage::get_body(Glib::VariantBase& value) const
+void Message::get_body(Glib::VariantBase& value) const
{
GVariant* const g_value =
g_dbus_message_get_body(const_cast<GDBusMessage*>(gobj()));
@@ -38,8 +41,8 @@ void DBusMessage::get_body(Glib::VariantBase& value) const
value.init(g_value, true /* take a reference */);
}
-void DBusMessage::get_header(Glib::VariantBase& value,
- DBusMessageHeaderField header_field) const
+void Message::get_header(Glib::VariantBase& value,
+ MessageHeaderField header_field) const
{
GVariant* const g_value =
g_dbus_message_get_header(const_cast<GDBusMessage*>(gobj()),
@@ -52,10 +55,11 @@ void DBusMessage::get_header(Glib::VariantBase& value,
}
#ifdef G_OS_UNIX
-void DBusMessage::unset_unix_fd_list()
+void Message::unset_unix_fd_list()
{
g_dbus_message_set_unix_fd_list(gobj(), 0);
}
#endif //G_OS_UNIX
+} //namespace DBus
} // namespace Gio
diff --git a/gio/src/dbusmessage.hg b/gio/src/dbusmessage.hg
index ba11428..48b4d43 100644
--- a/gio/src/dbusmessage.hg
+++ b/gio/src/dbusmessage.hg
@@ -20,6 +20,7 @@
#include <glibmm/object.h>
#include <glibmm/variant.h>
#include <glibmm/utility.h>
+#include <giomm/unixfdlist.h>
_DEFS(giomm,gio)
_PINCLUDE(glibmm/private/object_p.h)
@@ -27,23 +28,26 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
-_WRAP_ENUM(DBusMessageType, GDBusMessageType, NO_GTYPE)
-_WRAP_ENUM(DBusMessageFlags, GDBusMessageFlags, NO_GTYPE)
-_WRAP_ENUM(DBusMessageHeaderField, GDBusMessageHeaderField, NO_GTYPE)
-_WRAP_ENUM(DBusCapabilityFlags, GDBusCapabilityFlags, NO_GTYPE)
+namespace DBus
+{
+
+_WRAP_ENUM(MessageType, GDBusMessageType, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(MessageFlags, GDBusMessageFlags, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(MessageHeaderField, GDBusMessageHeaderField, s#^DBUS_##, NO_GTYPE)
+_WRAP_ENUM(CapabilityFlags, GDBusCapabilityFlags, s#^DBUS_##, NO_GTYPE)
-class UnixFDList;
+_GMMPROC_EXTRA_NAMESPACE(DBus)
/** DBusMessage - D-Bus Message.
* A type for representing D-Bus messages that can be sent or received on a
- * DBusConnection.
+ * Connection.
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusMessage : public Glib::Object
+class Message : public Glib::Object
{
- _CLASS_GOBJECT(DBusMessage, GDBusMessage, G_DBUS_MESSAGE, Glib::Object, GObject)
+ _CLASS_GOBJECT(Message, GDBusMessage, G_DBUS_MESSAGE, Glib::Object, GObject)
protected:
_CTOR_DEFAULT
@@ -56,23 +60,23 @@ public:
// Note that we can't use _WRAP_CTOR() and _WRAP_CREATE() because the C functions do more than just call g_object_new():
// See http://bugzilla.gnome.org/show_bug.cgi?id=624977
// TODO: Should these parameters be ustring or std::string?
- _WRAP_METHOD(static Glib::RefPtr<DBusMessage> create_signal(const Glib::ustring& path, const Glib::ustring& interface, const Glib::ustring& signal), g_dbus_message_new_signal)
- _WRAP_METHOD(static Glib::RefPtr<DBusMessage> create_method_call(const Glib::ustring& name, const Glib::ustring& path, const Glib::ustring& interface, const Glib::ustring& method), g_dbus_message_new_method_call)
- _WRAP_METHOD(static Glib::RefPtr<DBusMessage> create_method_reply(const Glib::RefPtr<DBusMessage>& method_call_message), g_dbus_message_new_method_reply)
- _WRAP_METHOD(static Glib::RefPtr<DBusMessage> create_method_error_literal(const Glib::RefPtr<const DBusMessage>& method_call_message, const Glib::ustring& error_name, const Glib::ustring& error_message), g_dbus_message_new_method_error_literal)
+ _WRAP_METHOD(static Glib::RefPtr<Message> create_signal(const Glib::ustring& path, const Glib::ustring& interface, const Glib::ustring& signal), g_dbus_message_new_signal)
+ _WRAP_METHOD(static Glib::RefPtr<Message> create_method_call(const Glib::ustring& name, const Glib::ustring& path, const Glib::ustring& interface, const Glib::ustring& method), g_dbus_message_new_method_call)
+ _WRAP_METHOD(static Glib::RefPtr<Message> create_method_reply(const Glib::RefPtr<Message>& method_call_message), g_dbus_message_new_method_reply)
+ _WRAP_METHOD(static Glib::RefPtr<Message> create_method_error_literal(const Glib::RefPtr<const Message>& method_call_message, const Glib::ustring& error_name, const Glib::ustring& error_message), g_dbus_message_new_method_error_literal)
- _WRAP_METHOD(static Glib::RefPtr<DBusMessage> create_from_blob(const guchar* blob, gsize blob_len, DBusCapabilityFlags capabilities = DBUS_CAPABILITY_FLAGS_NONE), g_dbus_message_new_from_blob, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Message> create_from_blob(const guchar* blob, gsize blob_len, CapabilityFlags capabilities = CAPABILITY_FLAGS_NONE), g_dbus_message_new_from_blob, errthrow)
_WRAP_METHOD(Glib::ustring print(guint indent), g_dbus_message_print)
_WRAP_METHOD(bool get_locked() const, g_dbus_message_get_locked)
_WRAP_METHOD(void lock() ,g_dbus_message_lock)
- _WRAP_METHOD(Glib::RefPtr<DBusMessage> copy() const, g_dbus_message_copy, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<Message> copy() const, g_dbus_message_copy, errthrow)
- _WRAP_METHOD(DBusMessageType get_message_type() const, g_dbus_message_get_message_type)
- _WRAP_METHOD(void set_message_type(DBusMessageType type), g_dbus_message_set_message_type)
+ _WRAP_METHOD(MessageType get_message_type() const, g_dbus_message_get_message_type)
+ _WRAP_METHOD(void set_message_type(MessageType type), g_dbus_message_set_message_type)
//gmmproc can't handle the character literals, and this won't be expanded in future,
//so we just wrap it by hand.
@@ -91,8 +95,8 @@ public:
_WRAP_METHOD(guint32 get_serial() const, g_dbus_message_get_serial)
_WRAP_METHOD(void set_serial(guint32 serial), g_dbus_message_set_serial)
- _WRAP_METHOD(DBusMessageFlags get_flags() const, g_dbus_message_get_flags)
- _WRAP_METHOD(void set_flags(DBusMessageFlags flags), g_dbus_message_set_flags)
+ _WRAP_METHOD(MessageFlags get_flags() const, g_dbus_message_get_flags)
+ _WRAP_METHOD(void set_flags(MessageFlags flags), g_dbus_message_set_flags)
/** Gets the body of a message. The body is returned in @a value.
* @param value Location in which to store the header.
@@ -121,10 +125,10 @@ public:
* @param value Location in which to store the header.
* @param header_field The header field type.
*/
- void get_header(Glib::VariantBase& value, DBusMessageHeaderField header_field) const;
+ void get_header(Glib::VariantBase& value, MessageHeaderField header_field) const;
_IGNORE(g_dbus_message_get_header)
- _WRAP_METHOD(void set_header(DBusMessageHeaderField header_field, const Glib::VariantBase& value), g_dbus_message_set_header)
+ _WRAP_METHOD(void set_header(MessageHeaderField header_field, const Glib::VariantBase& value), g_dbus_message_set_header)
#m4 _CONVERSION(`guchar*',`Glib::ArrayHandle<guchar>',`Glib::ArrayHandle<guchar>($3)')
_WRAP_METHOD(Glib::ArrayHandle<guchar> get_header_fields() const, g_dbus_message_get_header_fields)
@@ -157,11 +161,13 @@ public:
_WRAP_METHOD(static gssize bytes_needed(const guchar* blob, gsize blob_len), g_dbus_message_bytes_needed, errthrow)
- _WRAP_METHOD(guchar* to_blob(gsize& out_size, DBusCapabilityFlags capabilities = DBUS_CAPABILITY_FLAGS_NONE), g_dbus_message_to_blob, errthrow)
+ _WRAP_METHOD(guchar* to_blob(gsize& out_size, CapabilityFlags capabilities = CAPABILITY_FLAGS_NONE), g_dbus_message_to_blob, errthrow)
_WRAP_METHOD(void to_exception(), g_dbus_message_to_gerror, errthrow)
_WRAP_PROPERTY("locked", bool)
};
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusmethodinvocation.ccg b/gio/src/dbusmethodinvocation.ccg
index 6012307..7d29db4 100644
--- a/gio/src/dbusmethodinvocation.ccg
+++ b/gio/src/dbusmethodinvocation.ccg
@@ -25,7 +25,10 @@
namespace Gio
{
-void DBusMethodInvocation::get_parameters(Glib::VariantBase& value) const
+namespace DBus
+{
+
+void MethodInvocation::get_parameters(Glib::VariantBase& value) const
{
GVariant* const g_value = g_dbus_method_invocation_get_parameters(const_cast<GDBusMethodInvocation*>(gobj()));
@@ -35,4 +38,6 @@ void DBusMethodInvocation::get_parameters(Glib::VariantBase& value) const
value.init(g_value, true /* take a reference */);
}
+} // namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusmethodinvocation.hg b/gio/src/dbusmethodinvocation.hg
index f97e494..bbe84db 100644
--- a/gio/src/dbusmethodinvocation.hg
+++ b/gio/src/dbusmethodinvocation.hg
@@ -17,6 +17,9 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
+//#include <giomm/dbusconnection.h>
+#include <giomm/dbusmessage.h>
+#include <giomm/dbusintrospection.h>
#include <glibmm/object.h>
#include <glibmm/variant.h>
@@ -26,9 +29,12 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
-class DBusConnection;
-class DBusMessage;
-class DBusMethodInfo;
+namespace DBus
+{
+
+class Connection;
+
+_GMMPROC_EXTRA_NAMESPACE(DBus)
/** DBusMethodInvocation - Object for handling remote calls.
* Instances of the DBusMethodInvocation class are used when handling D-Bus
@@ -37,14 +43,14 @@ class DBusMethodInfo;
*
* The normal way to obtain a DBusMethodInvocation object is to receive it as
* an argument to the SlotMethodCall that was passed to
- * Gio::DBusConnection::register_object().
+ * Gio::DBus::Connection::register_object().
*
* @newin{2,28}
* @ingroup DBus
*/
-class DBusMethodInvocation : public Glib::Object
+class MethodInvocation : public Glib::Object
{
- _CLASS_GOBJECT(DBusMethodInvocation, GDBusMethodInvocation, G_DBUS_METHOD_INVOCATION, Glib::Object, GObject)
+ _CLASS_GOBJECT(MethodInvocation, GDBusMethodInvocation, G_DBUS_METHOD_INVOCATION, Glib::Object, GObject)
public:
_WRAP_METHOD(Glib::ustring get_sender() const, g_dbus_method_invocation_get_sender)
@@ -52,15 +58,15 @@ public:
_WRAP_METHOD(Glib::ustring get_interface_name() const, g_dbus_method_invocation_get_interface_name)
_WRAP_METHOD(Glib::ustring get_method_name() const, g_dbus_method_invocation_get_method_name)
-#m4 _CONVERSION(`const GDBusMethodInfo*', `Glib::RefPtr<const DBusMethodInfo>', `Glib::wrap(const_cast<GDBusMethodInfo*>($3))')
+#m4 _CONVERSION(`const GDBusMethodInfo*', `Glib::RefPtr<const MethodInfo>', `Glib::wrap(const_cast<GDBusMethodInfo*>($3))')
// The C API only returns a const GDBusMethodInfo.
- _WRAP_METHOD(Glib::RefPtr<const DBusMethodInfo> get_method_info() const, g_dbus_method_invocation_get_method_info, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const MethodInfo> get_method_info() const, g_dbus_method_invocation_get_method_info, refreturn)
- _WRAP_METHOD(Glib::RefPtr<DBusConnection> get_connection(), g_dbus_method_invocation_get_connection, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusConnection> get_connection() const, g_dbus_method_invocation_get_connection, refreturn, constversion)
+ _WRAP_METHOD(Glib::RefPtr<Connection> get_connection(), g_dbus_method_invocation_get_connection, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const Connection> get_connection() const, g_dbus_method_invocation_get_connection, refreturn, constversion)
- _WRAP_METHOD(Glib::RefPtr<DBusMessage> get_message(), g_dbus_method_invocation_get_message, refreturn)
- _WRAP_METHOD(Glib::RefPtr<const DBusMessage> get_message() const, g_dbus_method_invocation_get_message, refreturn, constversion)
+ _WRAP_METHOD(Glib::RefPtr<Message> get_message(), g_dbus_method_invocation_get_message, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const Message> get_message() const, g_dbus_method_invocation_get_message, refreturn, constversion)
/** Gets the parameters of the method invocation.
*
@@ -88,4 +94,5 @@ public:
};
+} //namespace DBus
} // namespace Gio
diff --git a/gio/src/dbusownname.hg b/gio/src/dbusownname.hg
index e6db230..39132b7 100644
--- a/gio/src/dbusownname.hg
+++ b/gio/src/dbusownname.hg
@@ -27,29 +27,29 @@ namespace Gio
namespace DBus
{
-_WRAP_ENUM(BusNameOwnerFlags, GBusNameOwnerFlags)
+_WRAP_ENUM(BusNameOwnerFlags, GBusNameOwnerFlags, s#^DBUS_##)
/** For example,
- * void on_bus_acquired(const Glib::RefPtr<Gio::DBusConnection>& connection,
+ * void on_bus_acquired(const Glib::RefPtr<Gio::DBus::Connection>& connection,
* const Glib::ustring& name);
* @newin{2,28}
* @ingroup DBus
*/
-typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring> SlotBusAcquired;
+typedef sigc::slot<void, const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring> SlotBusAcquired;
/** For example,
- * void on_name_acquired(const Glib::RefPtr<Gio::DBusConnection>& connection,
+ * void on_name_acquired(const Glib::RefPtr<Gio::DBus::Connection>& connection,
* const Glib::ustring& name);
* @ingroup DBus
*/
-typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring> SlotNameAcquired;
+typedef sigc::slot<void, const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring> SlotNameAcquired;
/** For example,
- * void on_name_lost(const Glib::RefPtr<Gio::DBusConnection>& connection,
+ * void on_name_lost(const Glib::RefPtr<Gio::DBus::Connection>& connection,
* const Glib::ustring& name);
* @ingroup DBus
*/
-typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring> SlotNameLost;
+typedef sigc::slot<void, const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring> SlotNameLost;
//TODO: Add example from C API in class docs.
/** Starts acquiring @a name on the bus specified by @a bus_type and calls @a
@@ -74,7 +74,7 @@ typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring
* If the name is acquired or lost (for example another application could
* acquire the name if you allow replacement or the application currently
* owning the name exits), the slots are also invoked. If the
- * DBusConnection that is used for attempting to own the name closes, then
+ * Connection that is used for attempting to own the name closes, then
* @a name_lost_slot is invoked since it is no longer possible for other
* processes to access the process.
*
diff --git a/gio/src/dbusproxy.ccg b/gio/src/dbusproxy.ccg
index 3df1754..612a77b 100644
--- a/gio/src/dbusproxy.ccg
+++ b/gio/src/dbusproxy.ccg
@@ -26,14 +26,17 @@
namespace Gio
{
-DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+namespace DBus
+{
+
+Proxy::Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-connection", Glib::unwrap(connection),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -45,13 +48,13 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
init_async(slot, cancellable);
}
-DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+Proxy::Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-connection", Glib::unwrap(connection),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -63,13 +66,13 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
init_async(slot);
}
-DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+Proxy::Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-connection", Glib::unwrap(connection),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -81,12 +84,12 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
init(cancellable);
}
-DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+Proxy::Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-connection", Glib::unwrap(connection),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -98,14 +101,14 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
init();
}
-DBusProxy::DBusProxy(BusType bus_type,
+Proxy::Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -117,13 +120,13 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
init_async(slot, cancellable);
}
-DBusProxy::DBusProxy(BusType bus_type,
+Proxy::Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -135,13 +138,13 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
init_async(slot);
}
-DBusProxy::DBusProxy(BusType bus_type,
+Proxy::Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -153,12 +156,12 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
init(cancellable);
}
-DBusProxy::DBusProxy(BusType bus_type,
+Proxy::Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
:
_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
"g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -170,103 +173,103 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
init();
}
-void DBusProxy::create(const Glib::RefPtr<DBusConnection>& connection,
+void Proxy::create(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- DBusProxy(connection, name, object_path, interface_name, slot,
+ Proxy(connection, name, object_path, interface_name, slot,
cancellable, info, flags);
}
-void DBusProxy::create(const Glib::RefPtr<DBusConnection>& connection,
+void Proxy::create(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- DBusProxy(connection, name, object_path, interface_name, slot, info, flags);
+ Proxy(connection, name, object_path, interface_name, slot, info, flags);
}
-Glib::RefPtr<DBusProxy>
-DBusProxy::create_sync(const Glib::RefPtr<DBusConnection>& connection,
+Glib::RefPtr<Proxy>
+Proxy::create_sync(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- return Glib::RefPtr<DBusProxy>(new DBusProxy(connection, name,
+ return Glib::RefPtr<Proxy>(new Proxy(connection, name,
object_path, interface_name, cancellable, info, flags));
}
-Glib::RefPtr<DBusProxy>
-DBusProxy::create_sync(const Glib::RefPtr<DBusConnection>& connection,
+Glib::RefPtr<Proxy>
+Proxy::create_sync(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- return Glib::RefPtr<DBusProxy>(new DBusProxy(connection, name,
+ return Glib::RefPtr<Proxy>(new Proxy(connection, name,
object_path, interface_name, info, flags));
}
-void DBusProxy::create_for_bus(BusType bus_type,
+void Proxy::create_for_bus(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- DBusProxy(bus_type, name, object_path, interface_name, slot, cancellable,
+ Proxy(bus_type, name, object_path, interface_name, slot, cancellable,
info, flags);
}
-void DBusProxy::create_for_bus(BusType bus_type,
+void Proxy::create_for_bus(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- DBusProxy(bus_type, name, object_path, interface_name, slot, info, flags);
+ Proxy(bus_type, name, object_path, interface_name, slot, info, flags);
}
-Glib::RefPtr<DBusProxy> DBusProxy::create_for_bus_sync(BusType bus_type,
+Glib::RefPtr<Proxy> Proxy::create_for_bus_sync(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- return Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name,
+ return Glib::RefPtr<Proxy>(new Proxy(bus_type, name,
object_path, interface_name, cancellable, info, flags));
}
-Glib::RefPtr<DBusProxy> DBusProxy::create_for_bus_sync(BusType bus_type,
+Glib::RefPtr<Proxy> Proxy::create_for_bus_sync(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info,
- DBusProxyFlags flags)
+ const Glib::RefPtr<InterfaceInfo>& info,
+ ProxyFlags flags)
{
- return Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name,
+ return Glib::RefPtr<Proxy>(new Proxy(bus_type, name,
object_path, interface_name, info, flags));
}
-void DBusProxy::get_cached_property(Glib::VariantBase& property,
+void Proxy::get_cached_property(Glib::VariantBase& property,
const Glib::ustring& property_name) const
{
GVariant* const g_variant =
@@ -276,12 +279,12 @@ void DBusProxy::get_cached_property(Glib::VariantBase& property,
property.init(g_variant, false /* no extra reference needed */);
}
-void DBusProxy::call(const Glib::ustring& method_name,
+void Proxy::call(const Glib::ustring& method_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::VariantBase& parameters,
int timeout_msec,
- DBusCallFlags flags
+ CallFlags flags
)
{
// Create a copy of the slot.
@@ -295,11 +298,11 @@ void DBusProxy::call(const Glib::ustring& method_name,
Glib::unwrap(cancellable), &SignalProxy_async_callback, slot_copy);
}
-void DBusProxy::call(const Glib::ustring& method_name,
+void Proxy::call(const Glib::ustring& method_name,
const SlotAsyncReady& slot,
const Glib::VariantBase& parameters,
int timeout_msec,
- DBusCallFlags flags
+ CallFlags flags
)
{
// Create a copy of the slot.
@@ -313,7 +316,7 @@ void DBusProxy::call(const Glib::ustring& method_name,
0, &SignalProxy_async_callback, slot_copy);
}
-void DBusProxy::call_finish(Glib::VariantBase& ret, const Glib::RefPtr<AsyncResult>& res)
+void Proxy::call_finish(Glib::VariantBase& ret, const Glib::RefPtr<AsyncResult>& res)
{
GError* g_error = 0;
@@ -326,12 +329,12 @@ void DBusProxy::call_finish(Glib::VariantBase& ret, const Glib::RefPtr<AsyncResu
ret.init(g_variant, false /* don't take extra reference */);
}
-void DBusProxy::call_sync(Glib::VariantBase& result,
+void Proxy::call_sync(Glib::VariantBase& result,
const Glib::ustring& method_name,
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::VariantBase& parameters,
int timeout_msec,
- DBusCallFlags flags
+ CallFlags flags
)
{
GError* g_error = 0;
@@ -348,12 +351,12 @@ void DBusProxy::call_sync(Glib::VariantBase& result,
result.init(g_variant, false /* don't take extra reference */);
}
-void DBusProxy::call_sync(
+void Proxy::call_sync(
Glib::VariantBase& result,
const Glib::ustring& method_name,
const Glib::VariantBase& parameters,
int timeout_msec,
- DBusCallFlags flags
+ CallFlags flags
)
{
GError* g_error = 0;
@@ -369,4 +372,6 @@ void DBusProxy::call_sync(
result.init(g_variant, false /* don't take extra reference */);
}
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusproxy.hg b/gio/src/dbusproxy.hg
index 0d795bf..673e354 100644
--- a/gio/src/dbusproxy.hg
+++ b/gio/src/dbusproxy.hg
@@ -18,6 +18,8 @@
*/
#include <glibmm/object.h>
+#include <giomm/asyncresult.h>
+#include <giomm/dbusintrospection.h>
#include <giomm/initable.h>
#include <giomm/asyncinitable.h>
#include <giomm/dbusconnection.h>
@@ -28,30 +30,29 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
-_WRAP_ENUM(DBusProxyFlags, GDBusProxyFlags, NO_GTYPE)
+namespace DBus
+{
-class AsyncResult;
-class DBusConnection;
-class DBusInterfaceInfo;
+_WRAP_ENUM(ProxyFlags, GDBusProxyFlags, s#^DBUS_##, NO_GTYPE)
-/** DBusProxy - Client-side proxies.
- * DBusProxy is a base class used for proxies to access a D-Bus interface on
- * a remote object. A DBusProxy can be constructed for both well-known and
+/** A client-side proxy.
+ * This is a base class used for proxies to access a D-Bus interface on
+ * a remote object. It can be constructed for both well-known and
* unique names.
*
- * By default, DBusProxy will cache all properties (and listen to changes) of
+ * By default, Proxy will cache all properties (and listen to changes) of
* the remote object, and proxy all signals that gets emitted. This behaviour
- * can be changed by passing suitable DBusProxyFlags when the proxy is
+ * can be changed by passing suitable ProxyFlags when the proxy is
* created. If the proxy is for a well-known name, the property cache is
* flushed when the name owner vanishes and reloaded when a name owner
* appears.
*
- * If a DBusProxy is used for a well-known name, the owner of the name is
+ * If a Proxy is used for a well-known name, the owner of the name is
* tracked and can be read from property_g_name_owner().
*
* The generic signal_g_properties_changed() and signal_g_signal() signals are
* not very convenient to work with. Therefore, the recommended way of working
- * with proxies is to subclass DBusProxy, and have more natural properties and
+ * with proxies is to subclass Proxy, and have more natural properties and
* signals in your derived class.
*
* This documentation was adapted from the C API documentation. The C API docs
@@ -60,124 +61,124 @@ class DBusInterfaceInfo;
* @newin{2,28}
* @ingroup DBus
*/
-class DBusProxy
+class Proxy
: public Glib::Object,
public Initable,
public AsyncInitable
{
- _CLASS_GOBJECT(DBusProxy, GDBusProxy, G_DBUS_PROXY, Glib::Object, GObject)
+ _CLASS_GOBJECT(Proxy, GDBusProxy, G_DBUS_PROXY, Glib::Object, GObject)
_IMPLEMENTS_INTERFACE(Initable)
_IMPLEMENTS_INTERFACE(AsyncInitable)
protected:
- DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+ Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+ Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+ Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+ Proxy(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(BusType bus_type,
+ Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(BusType bus_type,
+ Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(BusType bus_type,
+ Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- DBusProxy(BusType bus_type,
+ Proxy(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
public:
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new)
- static void create(const Glib::RefPtr<DBusConnection>& connection,
+ static void create(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
/// Non-cancellable version of create().
- static void create(const Glib::RefPtr<DBusConnection>& connection,
+ static void create(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusProxy> create_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Proxy> create_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_sync)
- static Glib::RefPtr<DBusProxy>
- create_sync(const Glib::RefPtr<DBusConnection>& connection,
+ static Glib::RefPtr<Proxy>
+ create_sync(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
/// Non-cancellable version of create_sync().
- static Glib::RefPtr<DBusProxy>
- create_sync(const Glib::RefPtr<DBusConnection>& connection,
+ static Glib::RefPtr<Proxy>
+ create_sync(const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus)
static void create_for_bus(BusType bus_type,
@@ -186,8 +187,8 @@ public:
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
/// Non-cancellable version of create_for_bus().
static void create_for_bus(BusType bus_type,
@@ -195,36 +196,36 @@ public:
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const SlotAsyncReady& slot,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<DBusProxy> create_for_bus_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_for_bus_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Proxy> create_for_bus_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_for_bus_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus_sync)
- static Glib::RefPtr<DBusProxy>
+ static Glib::RefPtr<Proxy>
create_for_bus_sync(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
const Glib::RefPtr<Cancellable>& cancellable,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
/// Non-cancellable version of create_for_bus_sync().
- static Glib::RefPtr<DBusProxy>
+ static Glib::RefPtr<Proxy>
create_for_bus_sync(BusType bus_type,
const Glib::ustring& name,
const Glib::ustring& object_path,
const Glib::ustring& interface_name,
- const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
- DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+ const Glib::RefPtr<InterfaceInfo>& info = Glib::RefPtr<InterfaceInfo>(),
+ ProxyFlags flags = PROXY_FLAGS_NONE);
- _WRAP_METHOD(DBusProxyFlags get_flags() const, g_dbus_proxy_get_flags)
+ _WRAP_METHOD(ProxyFlags get_flags() const, g_dbus_proxy_get_flags)
- _WRAP_METHOD(Glib::RefPtr<DBusConnection> get_connection(), g_dbus_proxy_get_connection)
- _WRAP_METHOD(Glib::RefPtr<const DBusConnection> get_connection() const, g_dbus_proxy_get_connection)
+ _WRAP_METHOD(Glib::RefPtr<Connection> get_connection(), g_dbus_proxy_get_connection)
+ _WRAP_METHOD(Glib::RefPtr<const Connection> get_connection() const, g_dbus_proxy_get_connection)
_WRAP_METHOD(Glib::ustring get_name() const, g_dbus_proxy_get_name)
_WRAP_METHOD(Glib::ustring get_name_owner() const, g_dbus_proxy_get_name_owner)
@@ -255,9 +256,9 @@ public:
#m4 _CONVERSION(`gchar**', `Glib::StringArrayHandle', `Glib::StringArrayHandle($3)')
_WRAP_METHOD(Glib::StringArrayHandle get_cached_property_names() const, g_dbus_proxy_get_cached_property_names)
- _WRAP_METHOD(void set_interface_info(const Glib::RefPtr<DBusInterfaceInfo>& info), g_dbus_proxy_set_interface_info)
- _WRAP_METHOD(Glib::RefPtr<DBusInterfaceInfo> get_interface_info(), g_dbus_proxy_get_interface_info)
- _WRAP_METHOD(Glib::RefPtr<const DBusInterfaceInfo> get_interface_info() const, g_dbus_proxy_get_interface_info, constversion)
+ _WRAP_METHOD(void set_interface_info(const Glib::RefPtr<InterfaceInfo>& info), g_dbus_proxy_set_interface_info)
+ _WRAP_METHOD(Glib::RefPtr<InterfaceInfo> get_interface_info(), g_dbus_proxy_get_interface_info)
+ _WRAP_METHOD(Glib::RefPtr<const InterfaceInfo> get_interface_info() const, g_dbus_proxy_get_interface_info, constversion)
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_call)
void call(
@@ -266,7 +267,7 @@ public:
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::VariantBase& parameters = Glib::VariantBase(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE
);
/// A non-cancellable version of call().
@@ -275,7 +276,7 @@ public:
const SlotAsyncReady& slot,
const Glib::VariantBase& parameters = Glib::VariantBase(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE
);
/** Finishes an operation started with call().
@@ -296,7 +297,7 @@ public:
* @param method_name Name of method to invoke.
* @param timeout_msec The timeout in milliseconds or -1 to use the proxy
* default timeout.
- * @param flags Flags from the DBusCallFlags enumeration.
+ * @param flags Flags from the DBus::CallFlags enumeration.
* @param parameters A Glib::VariantBase tuple with parameters for the
* signal.
* @param cancellable A Cancellable.
@@ -309,7 +310,7 @@ public:
const Glib::RefPtr<Cancellable>& cancellable,
const Glib::VariantBase& parameters = Glib::VariantBase(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE
);
_IGNORE(g_dbus_proxy_call_sync)
@@ -319,14 +320,14 @@ public:
const Glib::ustring& method_name,
const Glib::VariantBase& parameters = Glib::VariantBase(),
int timeout_msec = -1,
- DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE
);
//_WRAP_PROPERTY("g-bus-type", BusType) // write-only construct-only
- _WRAP_PROPERTY("g-connection", Glib::RefPtr<DBusConnection>)
+ _WRAP_PROPERTY("g-connection", Glib::RefPtr<Connection>)
_WRAP_PROPERTY("g-default-timeout", int)
- _WRAP_PROPERTY("g-flags", DBusProxyFlags)
- _WRAP_PROPERTY("g-interface-info", Glib::RefPtr<DBusInterfaceInfo>)
+ _WRAP_PROPERTY("g-flags", ProxyFlags)
+ _WRAP_PROPERTY("g-interface-info", Glib::RefPtr<InterfaceInfo>)
_WRAP_PROPERTY("g-interface-name", Glib::ustring)
_WRAP_PROPERTY("g-name", Glib::ustring)
_WRAP_PROPERTY("g-name-owner", Glib::ustring)
@@ -342,4 +343,6 @@ public:
_WRAP_SIGNAL(void signal(const Glib::ustring& sender_name, const Glib::ustring& signal_name, const Glib::VariantBase& parameters), "g-signal")
};
+} //namespace
+
} // namespace Gio
diff --git a/gio/src/dbusserver.ccg b/gio/src/dbusserver.ccg
index f2bba79..0aea488 100644
--- a/gio/src/dbusserver.ccg
+++ b/gio/src/dbusserver.ccg
@@ -24,13 +24,16 @@
namespace Gio
{
+namespace DBus
+{
+
//TODO: Uncomment when bug #639478 is resolved.
/*
-DBusServer::DBusServer(const std::string& address,
+Server::Server(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags)
+ ServerFlags flags)
: _CONSTRUCT("address",
(address.empty() ? static_cast<char*>(0) : address.c_str()),
"flags", static_cast<GDBusServerFlags>(flags),
@@ -40,10 +43,10 @@ DBusServer::DBusServer(const std::string& address,
init(cancellable);
}
-DBusServer::DBusServer(const std::string& address,
+Server::Server(const std::string& address,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags)
+ ServerFlags flags)
: _CONSTRUCT("address",
(address.empty() ? static_cast<char*>(0) : address.c_str()),
"flags", static_cast<GDBusServerFlags>(flags),
@@ -53,10 +56,10 @@ DBusServer::DBusServer(const std::string& address,
init(cancellable);
}
-DBusServer::DBusServer(const std::string& address,
+Server::Server(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusServerFlags flags)
+ const Glib::RefPtr<AuthObserver>& observer,
+ ServerFlags flags)
: _CONSTRUCT("address",
(address.empty() ? static_cast<char*>(0) : address.c_str()),
"flags", static_cast<GDBusServerFlags>(flags),
@@ -66,9 +69,9 @@ DBusServer::DBusServer(const std::string& address,
init();
}
-DBusServer::DBusServer(const std::string& address,
+Server::Server(const std::string& address,
const std::string& guid,
- DBusServerFlags flags)
+ ServerFlags flags)
: _CONSTRUCT("address",
(address.empty() ? static_cast<char*>(0) : address.c_str()),
"flags", static_cast<GDBusServerFlags>(flags),
@@ -79,21 +82,21 @@ DBusServer::DBusServer(const std::string& address,
}
*/
-Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
+Glib::RefPtr<Server> Server::create_sync(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags)
+ ServerFlags flags)
{
//TODO: Use the constructor instead of the code underneath when
//g_dbus_server_new_sync() does not do more than call g_initable_new().
//https://bugzilla.gnome.org/show_bug.cgi?id=639478
- //return Glib::RefPtr<DBusServer>(new DBusServer(address, guid, observer,
+ //return Glib::RefPtr<Server>(new Server(address, guid, observer,
//cancellable, flags));
GError* gerror = 0;
- Glib::RefPtr<DBusServer> result =
+ Glib::RefPtr<Server> result =
Glib::wrap(g_dbus_server_new_sync(address.c_str(),
static_cast<GDBusServerFlags>(flags),
guid.c_str(),
@@ -107,20 +110,20 @@ Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
return result;
}
-Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
+Glib::RefPtr<Server> Server::create_sync(const std::string& address,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags)
+ ServerFlags flags)
{
//TODO: Use the constructor instead of the code underneath when
//g_dbus_server_new_sync() does not do more than call g_initable_new().
//https://bugzilla.gnome.org/show_bug.cgi?id=639478
- //return Glib::RefPtr<DBusServer>(new DBusServer(address, guid,
+ //return Glib::RefPtr<Server>(new Server(address, guid,
//cancellable, flags));
GError* gerror = 0;
- Glib::RefPtr<DBusServer> result =
+ Glib::RefPtr<Server> result =
Glib::wrap(g_dbus_server_new_sync(address.c_str(),
static_cast<GDBusServerFlags>(flags),
guid.c_str(), 0,
@@ -133,20 +136,20 @@ Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
return result;
}
-Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
+Glib::RefPtr<Server> Server::create_sync(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusServerFlags flags)
+ const Glib::RefPtr<AuthObserver>& observer,
+ ServerFlags flags)
{
//TODO: Use the constructor instead of the code underneath when
//g_dbus_server_new_sync() does not do more than call g_initable_new().
//https://bugzilla.gnome.org/show_bug.cgi?id=639478
- //return Glib::RefPtr<DBusServer>(new DBusServer(address, guid, observer,
+ //return Glib::RefPtr<Server>(new Server(address, guid, observer,
//flags));
GError* gerror = 0;
- Glib::RefPtr<DBusServer> result =
+ Glib::RefPtr<Server> result =
Glib::wrap(g_dbus_server_new_sync(address.c_str(),
static_cast<GDBusServerFlags>(flags),
guid.c_str(),
@@ -160,18 +163,18 @@ Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
return result;
}
-Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
+Glib::RefPtr<Server> Server::create_sync(const std::string& address,
const std::string& guid,
- DBusServerFlags flags)
+ ServerFlags flags)
{
//TODO: Use the constructor instead of the code underneath when
//g_dbus_server_new_sync() does not do more than call g_initable_new().
//https://bugzilla.gnome.org/show_bug.cgi?id=639478
- //return Glib::RefPtr<DBusServer>(new DBusServer(address, guid, flags));
+ //return Glib::RefPtr<Server>(new Server(address, guid, flags));
GError* gerror = 0;
- Glib::RefPtr<DBusServer> result =
+ Glib::RefPtr<Server> result =
Glib::wrap(g_dbus_server_new_sync(address.c_str(),
static_cast<GDBusServerFlags>(flags),
guid.c_str(), 0, 0, &gerror));
@@ -182,4 +185,5 @@ Glib::RefPtr<DBusServer> DBusServer::create_sync(const std::string& address,
return result;
}
+} // namespace DBus
} // namespace Gio
diff --git a/gio/src/dbusserver.hg b/gio/src/dbusserver.hg
index d9e1e9c..fcfc5ba 100644
--- a/gio/src/dbusserver.hg
+++ b/gio/src/dbusserver.hg
@@ -18,6 +18,8 @@
*/
#include <glibmm/object.h>
+#include <giomm/dbusconnection.h>
+#include <giomm/dbusauthobserver.h>
#include <giomm/initable.h>
_DEFS(giomm,gio)
@@ -26,10 +28,12 @@ _PINCLUDE(glibmm/private/object_p.h)
namespace Gio
{
-_WRAP_ENUM(DBusServerFlags, GDBusServerFlags, NO_GTYPE)
+namespace DBus
+{
+
+_WRAP_ENUM(ServerFlags, GDBusServerFlags, s#^DBUS_##, NO_GTYPE)
-class DBusAuthObserver;
-class DBusConnection;
+_GMMPROC_EXTRA_NAMESPACE(DBus)
//TODO: Add example from the C API in class docs.
/** DBusServer - Helper for accepting connections.
@@ -40,9 +44,9 @@ class DBusConnection;
* @newin{2,28}
* @ingroup DBus
*/
-class DBusServer : public Glib::Object, public Initable
+class Server : public Glib::Object, public Initable
{
- _CLASS_GOBJECT(DBusServer, GDBusServer, G_DBUS_SERVER, Glib::Object, GObject)
+ _CLASS_GOBJECT(Server, GDBusServer, G_DBUS_SERVER, Glib::Object, GObject)
_IMPLEMENTS_INTERFACE(Initable)
protected:
@@ -51,90 +55,92 @@ protected:
/*
DBusServer(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags);
+ ServerFlags flags);
DBusServer(const std::string& address,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags);
+ ServerFlags flags);
DBusServer(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusServerFlags flags);
+ const Glib::RefPtr<AuthObserver>& observer,
+ ServerFlags flags);
DBusServer(const std::string& address,
const std::string& guid,
- DBusServerFlags flags);
+ ServerFlags flags);
*/
public:
_WRAP_METHOD_DOCS_ONLY(g_dbus_server_new_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusServer> create_sync(const std::string& address,
+ static Glib::RefPtr<Server> create_sync(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
+ const Glib::RefPtr<AuthObserver>& observer,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
+ ServerFlags flags = Gio::DBus::SERVER_FLAGS_NONE);
_WRAP_METHOD_DOCS_ONLY(g_dbus_server_new_sync)
/// @throw Glib::Error.
- static Glib::RefPtr<DBusServer> create_sync(const std::string& address,
+ static Glib::RefPtr<Server> create_sync(const std::string& address,
const std::string& guid,
const Glib::RefPtr<Cancellable>& cancellable,
- DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
+ ServerFlags flags = Gio::DBus::SERVER_FLAGS_NONE);
/// Non-cancellable version of create_sync().
- static Glib::RefPtr<DBusServer> create_sync(const std::string& address,
+ static Glib::RefPtr<Server> create_sync(const std::string& address,
const std::string& guid,
- const Glib::RefPtr<DBusAuthObserver>& observer,
- DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
+ const Glib::RefPtr<AuthObserver>& observer,
+ ServerFlags flags = Gio::DBus::SERVER_FLAGS_NONE);
/// Non-cancellable version of create_sync().
- static Glib::RefPtr<DBusServer> create_sync(const std::string& address,
+ static Glib::RefPtr<Server> create_sync(const std::string& address,
const std::string& guid,
- DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
+ ServerFlags flags = Gio::DBus::SERVER_FLAGS_NONE);
_WRAP_METHOD(void start(), g_dbus_server_start)
_WRAP_METHOD(void stop(), g_dbus_server_stop)
_WRAP_METHOD(bool is_active() const, g_dbus_server_is_active)
_WRAP_METHOD(std::string get_guid() const, g_dbus_server_get_guid)
- _WRAP_METHOD(DBusServerFlags get_flags() const, g_dbus_server_get_flags)
+ _WRAP_METHOD(ServerFlags get_flags() const, g_dbus_server_get_flags)
_WRAP_METHOD(std::string get_client_address() const, g_dbus_server_get_client_address)
_WRAP_PROPERTY("active", bool)
_WRAP_PROPERTY("address", std::string)
- _WRAP_PROPERTY("authentication-observer", Glib::RefPtr<DBusAuthObserver>)
+ _WRAP_PROPERTY("authentication-observer", Glib::RefPtr<AuthObserver>)
_WRAP_PROPERTY("client-address", std::string)
- _WRAP_PROPERTY("flags", DBusServerFlags)
+ _WRAP_PROPERTY("flags", ServerFlags)
_WRAP_PROPERTY("guid", std::string)
-#m4 _CONVERSION(`GDBusConnection*', `const Glib::RefPtr<DBusConnection>&', `Glib::wrap($3, true)')
+#m4 _CONVERSION(`GDBusConnection*', `const Glib::RefPtr<Connection>&', `Glib::wrap($3, true)')
/** Emitted when a new authenticated connection has been made. Use
- * Gio::DBusConnection::get_peer_credentials() to figure out what identity
+ * Gio::DBus::Connection::get_peer_credentials() to figure out what identity
* (if any), was authenticated.
*
* If you want to accept the connection, keep a global reference to the
* connection (by keeping it in a global RefPtr<>) and return <tt>true</tt>.
- * When you are done with the connection call Gio::DBusConnection::close().
+ * When you are done with the connection call Gio::DBus::Connection::close().
* Note that the other peer may disconnect at any time - a typical thing to
* do when accepting a connection is to listen to the
- * Gio::DBusConnection::signal_closed() signal.
+ * Gio::DBus::Connection::signal_closed() signal.
*
- * If property_flags() contains Gio::DBUS_SERVER_FLAGS_RUN_IN_THREAD then
+ * If property_flags() contains Gio::DBus::SERVER_FLAGS_RUN_IN_THREAD then
* the signal is emitted in a new thread dedicated to the connection.
* Otherwise the signal is emitted in the thread-default main loop of the
* thread that server was constructed in.
*
* You are guaranteed that signal handlers for this signal runs before
* incoming messages on the connection are processed. This means that it's
- * suitable to call Gio::DBusConnection::register_object() or similar from
+ * suitable to call Gio::DBus::Connection::register_object() or similar from
* the signal handler.
*/
- _WRAP_SIGNAL(bool new_connection(const Glib::RefPtr<DBusConnection>& connection), "new-connection", no_default_handler)
+ _WRAP_SIGNAL(bool new_connection(const Glib::RefPtr<Connection>& connection), "new-connection", no_default_handler)
};
+} //namespace DBus
+
} // namespace Gio
diff --git a/gio/src/dbusutils.hg b/gio/src/dbusutils.hg
index 885f9e0..ac2acf9 100644
--- a/gio/src/dbusutils.hg
+++ b/gio/src/dbusutils.hg
@@ -26,7 +26,7 @@ namespace DBus
{
/** Generate a D-Bus GUID that can be used with e.g.
- * Gio::DBusConnection::create().
+ * Gio::DBus::Connection::create().
*
* See the D-Bus specification regarding what strings are valid D-Bus GUID
* (for example, D-Bus GUIDs are not RFC-4122 compliant).
diff --git a/gio/src/dbuswatchname.ccg b/gio/src/dbuswatchname.ccg
index 587d922..972b6cc 100644
--- a/gio/src/dbuswatchname.ccg
+++ b/gio/src/dbuswatchname.ccg
@@ -110,7 +110,7 @@ guint watch_name(
}
guint watch_name(
- const Glib::RefPtr<DBusConnection>& connection,
+ const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const SlotNameAppeared& name_appeared_slot,
const SlotNameVanished& name_vanished_slot,
diff --git a/gio/src/dbuswatchname.hg b/gio/src/dbuswatchname.hg
index 5668cda..d3c2e35 100644
--- a/gio/src/dbuswatchname.hg
+++ b/gio/src/dbuswatchname.hg
@@ -27,21 +27,21 @@ namespace Gio
namespace DBus
{
-_WRAP_ENUM(BusNameWatcherFlags, GBusNameWatcherFlags)
+_WRAP_ENUM(BusNameWatcherFlags, GBusNameWatcherFlags, s#^DBUS_##, NO_GTYPE)
/** For example,
- * void on_name_appeared(const Glib::RefPtr<Gio::DBusConnection>& connection,
+ * void on_name_appeared(const Glib::RefPtr<Gio::DBus::Connection>& connection,
* const Glib::ustring& name, const Glib::ustring& name_owner);
* @ingroup DBus
*/
-typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring, const Glib::ustring&> SlotNameAppeared;
+typedef sigc::slot<void, const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring, const Glib::ustring&> SlotNameAppeared;
/** For example,
- * void on_name_vanished(const Glib::RefPtr<Gio::DBusConnection>& connection,
+ * void on_name_vanished(const Glib::RefPtr<Gio::DBus::Connection>& connection,
* const Glib::ustring& name);
* @ingroup DBus
*/
-typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring> SlotNameVanished;
+typedef sigc::slot<void, const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring> SlotNameVanished;
//TODO: Add example from C API in class docs?
/** Starts watching @a name on the bus specified by @a bus_type and calls
@@ -55,7 +55,7 @@ typedef sigc::slot<void, const Glib::RefPtr<Gio::DBusConnection>&, Glib::ustring
* unwatch_name() with the watcher id this function returns.
*
* If the name vanishes or appears (for example the application owning the
- * name could restart), the slot are also invoked. If the DBusConnection
+ * name could restart), the slot are also invoked. If the Connection
* that is used for watching the name disconnects, then @a
* name_vanished_slot is invoked since it is no longer possible to access
* the name.
@@ -93,9 +93,9 @@ guint watch_name(
);
_IGNORE(g_bus_watch_name)
-/** A watch_name() function that takes a DBusConnection instead of a BusType.
+/** A watch_name() function that takes a Connection instead of a BusType.
*
- * @param connection A DBusConnection.
+ * @param connection A Connection.
* @param name The name (well-known or unique) to watch.
* @param name_appeared_slot Slot to invoke when name is known to exist.
* @param name_vanished_slot Slot to invoke when name is known to not
@@ -108,7 +108,7 @@ _IGNORE(g_bus_watch_name)
* @ingroup DBus
*/
guint watch_name(
- const Glib::RefPtr<DBusConnection>& connection,
+ const Glib::RefPtr<Connection>& connection,
const Glib::ustring& name,
const SlotNameAppeared& name_appeared_slot = SlotNameAppeared(),
const SlotNameVanished& name_vanished_slot = SlotNameVanished(),
diff --git a/gio/src/error.hg b/gio/src/error.hg
index 8bc9b1b..f22b153 100644
--- a/gio/src/error.hg
+++ b/gio/src/error.hg
@@ -40,10 +40,13 @@ namespace Gio
/** Exception class for giomm errors.
*/
-_WRAP_GERROR(DBusError, GDBusError, G_DBUS_ERROR, NO_GTYPE)
_WRAP_GERROR(Error, GIOErrorEnum, G_IO_ERROR, NO_GTYPE)
_WRAP_GERROR(ResolverError, GResolverError, G_RESOLVER_ERROR, NO_GTYPE)
+namespace DBus
+{
+_WRAP_GERROR(Error, GDBusError, G_DBUS_ERROR, NO_GTYPE)
+} //namespace DBus
} // namespace Gio
diff --git a/gio/src/filelist.am b/gio/src/filelist.am
index 6f5a281..cf5f7b1 100644
--- a/gio/src/filelist.am
+++ b/gio/src/filelist.am
@@ -25,10 +25,10 @@ giomm_files_any_hg = \
credentials.hg \
datainputstream.hg \
dataoutputstream.hg \
- dbusaddress.hg \
+ dbusaddress.hg \
dbusauthobserver.hg \
dbusconnection.hg \
- dbuserror.hg \
+ dbuserrorutils.hg \
dbusintrospection.hg \
dbusmessage.hg \
dbusmethodinvocation.hg \
diff --git a/tools/m4/convert_gio.m4 b/tools/m4/convert_gio.m4
index b40c816..54faac8 100644
--- a/tools/m4/convert_gio.m4
+++ b/tools/m4/convert_gio.m4
@@ -5,13 +5,13 @@ _CONV_ENUM(G,BusType)
_CONV_ENUM(G,CredentialsType)
_CONV_ENUM(G,DataStreamByteOrder)
_CONV_ENUM(G,DataStreamNewlineType)
-_CONV_ENUM(G,DBusCapabilityFlags)
-_CONV_ENUM(G,DBusMessageFlags)
-_CONV_ENUM(G,DBusMessageHeaderField)
-_CONV_ENUM(G,DBusMessageType)
-_CONV_ENUM(G,DBusProxyFlags)
-_CONV_ENUM(G,DBusSendMessageFlags)
-_CONV_ENUM(G,DBusServerFlags)
+_CONV_ENUM(GDBus,CapabilityFlags)
+_CONV_ENUM(GDBus,MessageFlags)
+_CONV_ENUM(GDBus,MessageHeaderField)
+_CONV_ENUM(GDBus,MessageType)
+_CONV_ENUM(GDBus,ProxyFlags)
+_CONV_ENUM(GDBus,SendMessageFlags)
+_CONV_ENUM(GDBus,ServerFlags)
_CONV_ENUM(G,DriveStartFlags)
_CONV_ENUM(G,DriveStartFlags)
_CONV_ENUM(G,DriveStartStopType)
@@ -70,26 +70,26 @@ _CONVERSION(`GCredentials*',`Glib::RefPtr<Credentials>',`Glib::wrap($3)')
_CONVERSION(`GCredentials*',`Glib::RefPtr<const Credentials>',`Glib::wrap($3)')
# DBusConnection
-_CONVERSION(`const Glib::RefPtr<DBusConnection>&',`GDBusConnection*',__CONVERT_REFPTR_TO_P)
-_CONVERSION(`GDBusConnection*',`Glib::RefPtr<DBusConnection>',Glib::wrap($3))
-_CONVERSION(`GDBusConnection*',`Glib::RefPtr<const DBusConnection>',Glib::wrap($3))
+_CONVERSION(`const Glib::RefPtr<Connection>&',`GDBusConnection*',__CONVERT_REFPTR_TO_P)
+_CONVERSION(`GDBusConnection*',`Glib::RefPtr<Connection>',Glib::wrap($3))
+_CONVERSION(`GDBusConnection*',`Glib::RefPtr<const Connection>',Glib::wrap($3))
# DBusMessage
-_CONVERSION(`const Glib::RefPtr<DBusMessage>&',`GDBusMessage*',__CONVERT_REFPTR_TO_P)
-_CONVERSION(`GDBusMessage*',`Glib::RefPtr<DBusMessage>',`Glib::wrap($3)')
-_CONVERSION(`const Glib::RefPtr<const DBusMessage>&',`GDBusMessage*',__CONVERT_CONST_REFPTR_TO_P)
+_CONVERSION(`const Glib::RefPtr<Message>&',`GDBusMessage*',__CONVERT_REFPTR_TO_P)
+_CONVERSION(`GDBusMessage*',`Glib::RefPtr<Message>',`Glib::wrap($3)')
+_CONVERSION(`const Glib::RefPtr<const Message>&',`GDBusMessage*',__CONVERT_CONST_REFPTR_TO_P)
# DBus*Info
-_CONVERSION(`GDBusMethodInfo*',`Glib::RefPtr<DBusMethodInfo>',`Glib::wrap($3)')
-_CONVERSION(`GDBusSignalInfo*',`Glib::RefPtr<DBusSignalInfo>',`Glib::wrap($3)')
-_CONVERSION(`GDBusPropertyInfo*',`Glib::RefPtr<DBusPropertyInfo>',`Glib::wrap($3)')
-_CONVERSION(`GDBusNodeInfo*',`Glib::RefPtr<DBusNodeInfo>',`Glib::wrap($3)')
-_CONVERSION(`GDBusInterfaceInfo*',`Glib::RefPtr<DBusInterfaceInfo>',`Glib::wrap($3)')
-_CONVERSION(`const Glib::RefPtr<DBusInterfaceInfo>&',`GDBusInterfaceInfo*',`Glib::unwrap($3)')
-_CONVERSION(`GDBusInterfaceInfo*',`const Glib::RefPtr<DBusInterfaceInfo>',`Glib::wrap($3)')
+_CONVERSION(`GDBusMethodInfo*',`Glib::RefPtr<MethodInfo>',`Glib::wrap($3)')
+_CONVERSION(`GDBusSignalInfo*',`Glib::RefPtr<SignalInfo>',`Glib::wrap($3)')
+_CONVERSION(`GDBusPropertyInfo*',`Glib::RefPtr<PropertyInfo>',`Glib::wrap($3)')
+_CONVERSION(`GDBusNodeInfo*',`Glib::RefPtr<NodeInfo>',`Glib::wrap($3)')
+_CONVERSION(`GDBusInterfaceInfo*',`Glib::RefPtr<InterfaceInfo>',`Glib::wrap($3)')
+_CONVERSION(`const Glib::RefPtr<InterfaceInfo>&',`GDBusInterfaceInfo*',`Glib::unwrap($3)')
+_CONVERSION(`GDBusInterfaceInfo*',`const Glib::RefPtr<InterfaceInfo>',`Glib::wrap($3)')
# DBusProxy
-_CONVERSION(`GDBusProxy*',`Glib::RefPtr<DBusProxy>',`Glib::wrap($3)')
+_CONVERSION(`GDBusProxy*',`Glib::RefPtr<Proxy>',`Glib::wrap($3)')
# DesktopAppInfo
_CONVERSION(`GDesktopAppInfo*', `Glib::RefPtr<DesktopAppInfo>', `Glib::wrap($3)')
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
