From 84f2a1ad2f867f9397de449365f80c5c003296fa Mon Sep 17 00:00:00 2001 From: Anders Carlsson Date: Sun, 19 Jan 2003 22:29:52 +0000 Subject: Add these. --- dbus/dbus-timeout.c | 342 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 dbus/dbus-timeout.c (limited to 'dbus/dbus-timeout.c') diff --git a/dbus/dbus-timeout.c b/dbus/dbus-timeout.c new file mode 100644 index 00000000..9aefbb40 --- /dev/null +++ b/dbus/dbus-timeout.c @@ -0,0 +1,342 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-timeout.c DBusTimeout implementation + * + * Copyright (C) 2003 CodeFactory AB + * + * Licensed under the Academic Free License version 1.2 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "dbus-internals.h" +#include "dbus-timeout.h" +#include "dbus-list.h" + +/** + * @defgroup DBusTimeoutInternals DBusTimeout implementation details + * @ingroup DBusInternals + * @brief implementation details for DBusTimeout + * + * @{ + */ + +struct DBusTimeout +{ + int refcount; /**< Reference count */ + int interval; /**< Timeout interval in milliseconds. */ + + DBusTimeoutHandler handler; /**< Timeout handler. */ + void *handler_data; /**< Timeout handler data. */ + DBusFreeFunction free_handler_data_function; /**< Free the timeout handler data. */ + + void *data; /**< Application data. */ + DBusFreeFunction free_data_function; /**< Free the application data. */ +}; + +/** + * Creates a new DBusTimeout. + * @param interval the timeout interval in milliseconds. + * @param handler function to call when the timeout occurs. + * @param data data to pass to the handler + * @param free_data_function function to be called to free the data. + * @returns the new DBusTimeout object, + */ +DBusTimeout* +_dbus_timeout_new (int interval, + DBusTimeoutHandler handler, + void *data, + DBusFreeFunction free_data_function) +{ + DBusTimeout *timeout; + + timeout = dbus_new0 (DBusTimeout, 1); + timeout->refcount = 1; + timeout->interval = interval; + + timeout->handler_data = data; + timeout->free_handler_data_function = free_data_function; + + return timeout; +} + +/** + * Increments the reference count of a DBusTimeout object. + * + * @param timeout the timeout object. + */ +void +_dbus_timeout_ref (DBusTimeout *timeout) +{ + timeout->refcount += 1; +} + +/** + * Decrements the reference count of a DBusTimeout object + * and finalizes the object if the count reaches zero. + * + * @param timeout the timeout object. + */ +void +_dbus_timeout_unref (DBusTimeout *timeout) +{ + _dbus_assert (timeout != NULL); + _dbus_assert (timeout->refcount > 0); + + timeout->refcount -= 1; + if (timeout->refcount == 0) + { + dbus_timeout_set_data (timeout, NULL, NULL); /* call free_data_function */ + + if (timeout->free_handler_data_function) + (* timeout->free_handler_data_function) (timeout->handler_data); + + dbus_free (timeout); + } +} + +/** + * @typedef DBusTimeoutList + * + * Opaque data type representing a list of timeouts + * and a set of DBusAddTimeoutFunction/DBusRemoveTimeoutFunction. + * Automatically handles removing/re-adding timeouts + * when the DBusAddTimeoutFunction is updated or changed. + * Holds a reference count to each timeout. + * + */ + +/** + * DBusTimeoutList implementation details. All fields + * are private. + * + */ +struct DBusTimeoutList +{ + DBusList *timeouts; /**< Timeout objects. */ + + DBusAddTimeoutFunction add_timeout_function; /**< Callback for adding a timeout. */ + DBusRemoveTimeoutFunction remove_timeout_function; /**< Callback for removing a timeout. */ + void *timeout_data; /**< Data for timeout callbacks */ + DBusFreeFunction timeout_free_data_function; /**< Free function for timeout callback data */ +}; + +/** + * Creates a new timeout list. Returns #NULL if insufficient + * memory exists. + * + * @returns the new timeout list, or #NULL on failure. + */ +DBusTimeoutList* +_dbus_timeout_list_new (void) +{ + DBusTimeoutList *timeout_list; + + timeout_list = dbus_new0 (DBusTimeoutList, 1); + if (timeout_list == NULL) + return NULL; + + return timeout_list; +} + +/** + * Frees a DBusTimeoutList. + * + * @param timeout_list the timeout list. + */ +void +_dbus_timeout_list_free (DBusTimeoutList *timeout_list) +{ + /* free timeout_data and remove timeouts as a side effect */ + _dbus_timeout_list_set_functions (timeout_list, + NULL, NULL, NULL, NULL); + + _dbus_list_foreach (&timeout_list->timeouts, + (DBusForeachFunction) _dbus_timeout_unref, + NULL); + _dbus_list_clear (&timeout_list->timeouts); + + dbus_free (timeout_list); +} + +/** + * Sets the timeout functions. This function is the "backend" + * for dbus_connection_set_timeout_functions(). + * + * @param timeout_list the timeout list + * @param add_function the add timeout function. + * @param remove_function the remove timeout function. + * @param data the data for those functions. + * @param free_data_function the function to free the data. + * + */ +void +_dbus_timeout_list_set_functions (DBusTimeoutList *timeout_list, + DBusAddTimeoutFunction add_function, + DBusRemoveTimeoutFunction remove_function, + void *data, + DBusFreeFunction free_data_function) +{ + /* Remove all current timeouts from previous timeout handlers */ + + if (timeout_list->remove_timeout_function != NULL) + { + _dbus_list_foreach (&timeout_list->timeouts, + (DBusForeachFunction) timeout_list->remove_timeout_function, + timeout_list->timeout_data); + } + + if (timeout_list->timeout_free_data_function != NULL) + (* timeout_list->timeout_free_data_function) (timeout_list->timeout_data); + + timeout_list->add_timeout_function = add_function; + timeout_list->remove_timeout_function = remove_function; + timeout_list->timeout_data = data; + timeout_list->timeout_free_data_function = free_data_function; + + /* Re-add all pending timeouts */ + if (timeout_list->add_timeout_function != NULL) + { + _dbus_list_foreach (&timeout_list->timeouts, + (DBusForeachFunction) timeout_list->add_timeout_function, + timeout_list->timeout_data); + } +} + +/** + * Adds a new timeout to the timeout list, invoking the + * application DBusAddTimeoutFunction if appropriate. + * + * @param timeout_list the timeout list. + * @param timeout the timeout to add. + * @returns #TRUE on success, #FALSE If no memory. + */ +dbus_bool_t +_dbus_timeout_list_add_timeout (DBusTimeoutList *timeout_list, + DBusTimeout *timeout) +{ + if (!_dbus_list_append (&timeout_list->timeouts, timeout)) + return FALSE; + + _dbus_timeout_ref (timeout); + + if (timeout_list->add_timeout_function != NULL) + (* timeout_list->add_timeout_function) (timeout, + timeout_list->timeout_data); + + return TRUE; +} + +/** + * Removes a timeout from the watch list, invoking the + * application's DBusRemoveTimeoutFunction if appropriate. + * + * @param timeout_list the timeout list. + * @param timeout the timeout to remove. + */ +void +_dbus_timeout_list_remove_timeout (DBusTimeoutList *timeout_list, + DBusTimeout *timeout) +{ + if (!_dbus_list_remove (&timeout_list->timeouts, timeout)) + _dbus_assert_not_reached ("Nonexistent timeout was removed"); + + if (timeout_list->remove_timeout_function != NULL) + (* timeout_list->remove_timeout_function) (timeout, + timeout_list->timeout_data); + + _dbus_timeout_unref (timeout); +} + +/** @} */ + +/** + * @defgroup DBusTimeout DBusTimeout + * @ingroup DBus + * @brief Object representing a timeout + * + * Types and functions related to DBusTimeout. A timeout + * represents a timeout that the main loop needs to monitor, + * as in Qt's QTimer or GLib's g_timeout_add(). + * + * @{ + */ + + +/** + * @typedef DBusTimeout + * + * Opaque object representing a timeout. + */ + +/** + * Gets the timeout interval. + * @param timeout the DBusTimeout object. + * @returns the interval in milliseconds. + */ +int +dbus_timeout_get_interval (DBusTimeout *timeout) +{ + return timeout->interval; +} + +/** + * Gets data previously set with dbus_timeout_set_data() + * or #NULL if none. + * + * @param timeout the DBusTimeout object. + * @returns previously-set data. + */ +void* +dbus_timeout_get_data (DBusTimeout *timeout) +{ + return timeout->data; +} + +/** + * Sets data which can be retrieved with dbus_timeout_get_data(). + * Intended for use by the DBusAddTimeoutFunction and + * DBusRemoveTimeoutFunction to store their own data. For example with + * Qt you might store the QTimer for this timeout and with GLib + * you might store a g_timeout_add result id. + * + * @param timeout the DBusTimeout object. + * @param data the data. + * @param free_data_function function to be called to free the data. + */ +void +dbus_timeout_set_data (DBusTimeout *timeout, + void *data, + DBusFreeFunction free_data_function) +{ + if (timeout->free_data_function != NULL) + (* timeout->free_data_function) (timeout->data); + + timeout->data = data; + timeout->free_data_function = free_data_function; +} + +/** + * Calls the timeout handler for this timeout. + * This function should be called when the timeout + * occurs. + * + * @param timeout the DBusTimeout object. + */ +void +dbus_timeout_handle (DBusTimeout *timeout) +{ + (* timeout->handler) (timeout->handler_data); +} -- cgit