mirror of
https://github.com/netsurf-browser/netsurf
synced 2024-12-23 20:46:50 +03:00
137 lines
4.3 KiB
C
137 lines
4.3 KiB
C
/*
|
|
* Copyright 2006-2007 Daniel Silverstone <dsilvers@digital-scurf.org>
|
|
*
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
*
|
|
* NetSurf 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; version 2 of the License.
|
|
*
|
|
* NetSurf 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <glib.h>
|
|
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
|
|
#include "utils/errors.h"
|
|
#include "utils/log.h"
|
|
|
|
#include "gtk/schedule.h"
|
|
|
|
|
|
/** Killable callback closure embodiment. */
|
|
typedef struct {
|
|
void (*callback)(void *); /**< The callback function. */
|
|
void *context; /**< The context for the callback. */
|
|
bool callback_killed; /**< Whether or not this was killed. */
|
|
} _nsgtk_callback_t;
|
|
|
|
/** List of callbacks which have occurred and are pending running. */
|
|
static GList *pending_callbacks = NULL;
|
|
/** List of callbacks which are queued to occur in the future. */
|
|
static GList *queued_callbacks = NULL;
|
|
/** List of callbacks which are about to be run in this ::schedule_run. */
|
|
static GList *this_run = NULL;
|
|
|
|
static gboolean
|
|
nsgtk_schedule_generic_callback(gpointer data)
|
|
{
|
|
_nsgtk_callback_t *cb = (_nsgtk_callback_t *)(data);
|
|
if (cb->callback_killed) {
|
|
/* This callback instance has been killed. */
|
|
NSLOG(schedule, DEBUG, "CB at %p already dead.", cb);
|
|
}
|
|
queued_callbacks = g_list_remove(queued_callbacks, cb);
|
|
pending_callbacks = g_list_append(pending_callbacks, cb);
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
nsgtk_schedule_kill_callback(void *_target, void *_match)
|
|
{
|
|
_nsgtk_callback_t *target = (_nsgtk_callback_t *)_target;
|
|
_nsgtk_callback_t *match = (_nsgtk_callback_t *)_match;
|
|
if ((target->callback == match->callback) &&
|
|
(target->context == match->context)) {
|
|
NSLOG(schedule, DEBUG,
|
|
"Found match for %p(%p), killing.",
|
|
target->callback, target->context);
|
|
target->callback = NULL;
|
|
target->context = NULL;
|
|
target->callback_killed = true;
|
|
}
|
|
}
|
|
|
|
static void
|
|
schedule_remove(void (*callback)(void *p), void *p)
|
|
{
|
|
_nsgtk_callback_t cb_match = {
|
|
.callback = callback,
|
|
.context = p,
|
|
};
|
|
|
|
g_list_foreach(queued_callbacks,
|
|
nsgtk_schedule_kill_callback, &cb_match);
|
|
g_list_foreach(pending_callbacks,
|
|
nsgtk_schedule_kill_callback, &cb_match);
|
|
g_list_foreach(this_run,
|
|
nsgtk_schedule_kill_callback, &cb_match);
|
|
}
|
|
|
|
/* exported interface documented in gtk/schedule.h */
|
|
nserror nsgtk_schedule(int t, void (*callback)(void *p), void *p)
|
|
{
|
|
_nsgtk_callback_t *cb;
|
|
|
|
/* Kill any pending schedule of this kind. */
|
|
schedule_remove(callback, p);
|
|
|
|
if (t < 0) {
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
cb = malloc(sizeof(_nsgtk_callback_t));
|
|
cb->callback = callback;
|
|
cb->context = p;
|
|
cb->callback_killed = false;
|
|
/* Prepend is faster right now. */
|
|
queued_callbacks = g_list_prepend(queued_callbacks, cb);
|
|
g_timeout_add(t, nsgtk_schedule_generic_callback, cb);
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
bool
|
|
schedule_run(void)
|
|
{
|
|
/* Capture this run of pending callbacks into the list. */
|
|
this_run = pending_callbacks;
|
|
|
|
if (this_run == NULL)
|
|
return false; /* Nothing to do */
|
|
|
|
/* Clear the pending list. */
|
|
pending_callbacks = NULL;
|
|
|
|
NSLOG(schedule, DEBUG,
|
|
"Captured a run of %d callbacks to fire.",
|
|
g_list_length(this_run));
|
|
|
|
/* Run all the callbacks which made it this far. */
|
|
while (this_run != NULL) {
|
|
_nsgtk_callback_t *cb = (_nsgtk_callback_t *)(this_run->data);
|
|
this_run = g_list_remove(this_run, this_run->data);
|
|
if (!cb->callback_killed)
|
|
cb->callback(cb->context);
|
|
free(cb);
|
|
}
|
|
return true;
|
|
}
|