diff -r 000000000000 -r 1918ee327afb src/dbus/qdbus_symbols_p.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/dbus/qdbus_symbols_p.h Mon Jan 11 14:00:40 2010 +0000 @@ -0,0 +1,365 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtDBus module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the public API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QDBUS_SYMBOLS_P_H +#define QDBUS_SYMBOLS_P_H + +#include +#include + +QT_BEGIN_NAMESPACE + +#if !defined QT_LINKED_LIBDBUS + +void *qdbus_resolve_conditionally(const char *name); // doesn't print a warning +void *qdbus_resolve_me(const char *name); // prints a warning +bool qdbus_loadLibDBus(); + +# define DEFINEFUNC(ret, func, args, argcall, funcret) \ + typedef ret (* _q_PTR_##func) args; \ + static inline ret q_##func args \ + { \ + static _q_PTR_##func ptr; \ + if (!ptr) \ + ptr = (_q_PTR_##func) qdbus_resolve_me(#func); \ + funcret ptr argcall; \ + } + +#else // defined QT_LINKED_LIBDBUS + +inline bool qdbus_loadLibDBus() { return true; } + +# define DEFINEFUNC(ret, func, args, argcall, funcret) \ + static inline ret q_##func args { funcret func argcall; } + +#endif // defined QT_LINKED_LIBDBUS + +/* dbus-bus.h */ +DEFINEFUNC(void, dbus_bus_add_match, (DBusConnection *connection, + const char *rule, + DBusError *error), + (connection, rule, error), ) +DEFINEFUNC(void, dbus_bus_remove_match, (DBusConnection *connection, + const char *rule, + DBusError *error), + (connection, rule, error), ) +DEFINEFUNC(dbus_bool_t, dbus_bus_register,(DBusConnection *connection, + DBusError *error), + (connection, error), return) +DEFINEFUNC(DBusConnection *, dbus_bus_get_private, (DBusBusType type, + DBusError *error), + (type, error), return) +DEFINEFUNC(const char*, dbus_bus_get_unique_name, (DBusConnection *connection), + (connection), return) + +/* dbus-connection.h */ +DEFINEFUNC(dbus_bool_t , dbus_connection_add_filter, (DBusConnection *connection, + DBusHandleMessageFunction function, + void *user_data, + DBusFreeFunction free_data_function), + (connection, function, user_data, free_data_function), return) +DEFINEFUNC(void , dbus_connection_close, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusDispatchStatus , dbus_connection_dispatch, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusDispatchStatus , dbus_connection_get_dispatch_status, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_get_is_connected, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(DBusConnection* , dbus_connection_open_private, (const char *address, + DBusError *error), + (address, error), return) +DEFINEFUNC(DBusConnection* , dbus_connection_ref, (DBusConnection *connection), + (connection), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_send, (DBusConnection *connection, + DBusMessage *message, + dbus_uint32_t *client_serial), + (connection, message, client_serial), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_send_with_reply, (DBusConnection *connection, + DBusMessage *message, + DBusPendingCall **pending_return, + int timeout_milliseconds), + (connection, message, pending_return, timeout_milliseconds), return) +DEFINEFUNC(DBusMessage * , dbus_connection_send_with_reply_and_block, (DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error), + (connection, message, timeout_milliseconds, error), return) +DEFINEFUNC(void , dbus_connection_set_exit_on_disconnect, (DBusConnection *connection, + dbus_bool_t exit_on_disconnect), + (connection, exit_on_disconnect), ) +DEFINEFUNC(dbus_bool_t , dbus_connection_set_timeout_functions, (DBusConnection *connection, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (connection, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(dbus_bool_t , dbus_connection_set_watch_functions, (DBusConnection *connection, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (connection, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(void , dbus_connection_set_wakeup_main_function, (DBusConnection *connection, + DBusWakeupMainFunction wakeup_main_function, + void *data, + DBusFreeFunction free_data_function), + (connection, wakeup_main_function, data, free_data_function), ) +DEFINEFUNC(void , dbus_connection_set_dispatch_status_function, (DBusConnection *connection, + DBusDispatchStatusFunction function, + void *data, + DBusFreeFunction free_data_function), + (connection, function, data, free_data_function), ) + +DEFINEFUNC(void , dbus_connection_unref, (DBusConnection *connection), + (connection), ) +DEFINEFUNC(dbus_bool_t , dbus_timeout_get_enabled, (DBusTimeout *timeout), + (timeout), return) +DEFINEFUNC(int , dbus_timeout_get_interval, (DBusTimeout *timeout), + (timeout), return) +DEFINEFUNC(dbus_bool_t , dbus_timeout_handle, (DBusTimeout *timeout), + (timeout), return) + +DEFINEFUNC(dbus_bool_t , dbus_watch_get_enabled, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(int , dbus_watch_get_fd, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(unsigned int , dbus_watch_get_flags, (DBusWatch *watch), + (watch), return) +DEFINEFUNC(dbus_bool_t , dbus_watch_handle, (DBusWatch *watch, + unsigned int flags), + (watch, flags), return) + +/* dbus-errors.h */ +DEFINEFUNC(void , dbus_error_free, (DBusError *error), + (error), ) +DEFINEFUNC(void , dbus_error_init, (DBusError *error), + (error), ) +DEFINEFUNC(dbus_bool_t , dbus_error_is_set, (const DBusError *error), + (error), return) + +/* dbus-memory.h */ +DEFINEFUNC(void , dbus_free, (void *memory), (memory), ) + +/* dbus-message.h */ +DEFINEFUNC(DBusMessage* , dbus_message_copy, (const DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_error_name, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_interface, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_member, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_get_no_reply, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_path, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_sender, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_uint32_t , dbus_message_get_serial, (DBusMessage *message), + (message), return) +DEFINEFUNC(const char* , dbus_message_get_signature, (DBusMessage *message), + (message), return) +DEFINEFUNC(int , dbus_message_get_type, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_basic, (DBusMessageIter *iter, + int type, + const void *value), + (iter, type, value), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_append_fixed_array, (DBusMessageIter *iter, + int element_type, + const void *value, + int n_elements), + (iter, element_type, value, n_elements), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_close_container, (DBusMessageIter *iter, + DBusMessageIter *sub), + (iter, sub), return) +DEFINEFUNC(int , dbus_message_iter_get_arg_type, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(void , dbus_message_iter_get_basic, (DBusMessageIter *iter, + void *value), + (iter, value), ) +DEFINEFUNC(int , dbus_message_iter_get_element_type, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(void , dbus_message_iter_get_fixed_array, (DBusMessageIter *iter, + void *value, + int *n_elements), + (iter, value, n_elements), return) +DEFINEFUNC(char* , dbus_message_iter_get_signature, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_init, (DBusMessage *message, + DBusMessageIter *iter), + (message, iter), return) +DEFINEFUNC(void , dbus_message_iter_init_append, (DBusMessage *message, + DBusMessageIter *iter), + (message, iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_next, (DBusMessageIter *iter), + (iter), return) +DEFINEFUNC(dbus_bool_t , dbus_message_iter_open_container, (DBusMessageIter *iter, + int type, + const char *contained_signature, + DBusMessageIter *sub), + (iter, type, contained_signature, sub), return) +DEFINEFUNC(void , dbus_message_iter_recurse, (DBusMessageIter *iter, + DBusMessageIter *sub), + (iter, sub), ) +DEFINEFUNC(DBusMessage* , dbus_message_new, (int message_type), + (message_type), return) +DEFINEFUNC(DBusMessage* , dbus_message_new_method_call, (const char *bus_name, + const char *path, + const char *interface, + const char *method), + (bus_name, path, interface, method), return) +DEFINEFUNC(DBusMessage* , dbus_message_new_signal, (const char *path, + const char *interface, + const char *name), + (path, interface, name), return) +DEFINEFUNC(DBusMessage* , dbus_message_ref, (DBusMessage *message), + (message), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_destination, (DBusMessage *message, + const char *destination), + (message, destination), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_error_name, (DBusMessage *message, + const char *name), + (message, name), return) +DEFINEFUNC(void , dbus_message_set_no_reply, (DBusMessage *message, + dbus_bool_t no_reply), + (message, no_reply), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_path, (DBusMessage *message, + const char *object_path), + (message, object_path), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_reply_serial, (DBusMessage *message, + dbus_uint32_t reply_serial), + (message, reply_serial), return) +DEFINEFUNC(dbus_bool_t , dbus_message_set_sender, (DBusMessage *message, + const char *sender), + (message, sender), return) +DEFINEFUNC(void , dbus_message_unref, (DBusMessage *message), + (message), ) + +/* dbus-pending-call.h */ +DEFINEFUNC(dbus_bool_t , dbus_pending_call_set_notify, (DBusPendingCall *pending, + DBusPendingCallNotifyFunction function, + void *user_data, + DBusFreeFunction free_user_data), + (pending, function, user_data, free_user_data), return) +DEFINEFUNC(void , dbus_pending_call_block, (DBusPendingCall *pending), + (pending), ) +DEFINEFUNC(void , dbus_pending_call_cancel, (DBusPendingCall *pending), + (pending), ) +DEFINEFUNC(dbus_bool_t , dbus_pending_call_get_completed, (DBusPendingCall *pending), + (pending), return) +DEFINEFUNC(DBusMessage* , dbus_pending_call_steal_reply, (DBusPendingCall *pending), + (pending), return) +DEFINEFUNC(void , dbus_pending_call_unref, (DBusPendingCall *pending), + (pending), return) + +/* dbus-server.h */ +DEFINEFUNC(dbus_bool_t , dbus_server_allocate_data_slot, (dbus_int32_t *slot_p), + (slot_p), return) +DEFINEFUNC(void , dbus_server_disconnect, (DBusServer *server), + (server), ) +DEFINEFUNC(char* , dbus_server_get_address, (DBusServer *server), + (server), return) +DEFINEFUNC(dbus_bool_t , dbus_server_get_is_connected, (DBusServer *server), + (server), return) +DEFINEFUNC(DBusServer* , dbus_server_listen, (const char *address, + DBusError *error), + (address, error), return) +DEFINEFUNC(dbus_bool_t , dbus_server_set_data, (DBusServer *server, + int slot, + void *data, + DBusFreeFunction free_data_func), + (server, slot, data, free_data_func), return) +DEFINEFUNC(void , dbus_server_set_new_connection_function, (DBusServer *server, + DBusNewConnectionFunction function, + void *data, + DBusFreeFunction free_data_function), + (server, function, data, free_data_function), ) +DEFINEFUNC(dbus_bool_t , dbus_server_set_timeout_functions, (DBusServer *server, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + DBusTimeoutToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (server, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(dbus_bool_t , dbus_server_set_watch_functions, (DBusServer *server, + DBusAddWatchFunction add_function, + DBusRemoveWatchFunction remove_function, + DBusWatchToggledFunction toggled_function, + void *data, + DBusFreeFunction free_data_function), + (server, add_function, remove_function, toggled_function, data, free_data_function), return) +DEFINEFUNC(void , dbus_server_unref, (DBusServer *server), + (server), ) + +/* dbus-signature.h */ +DEFINEFUNC(dbus_bool_t , dbus_signature_validate, (const char *signature, + DBusError *error), + (signature, error), return) +DEFINEFUNC(dbus_bool_t , dbus_signature_validate_single, (const char *signature, + DBusError *error), + (signature, error), return) +DEFINEFUNC(dbus_bool_t , dbus_type_is_basic, (int typecode), + (typecode), return) +DEFINEFUNC(dbus_bool_t , dbus_type_is_fixed, (int typecode), + (typecode), return) + +/* dbus-thread.h */ +DEFINEFUNC(dbus_bool_t , dbus_threads_init_default, (), (), return) + +QT_END_NAMESPACE + +#endif