yan/archived-lcd4linux
1
0
Fork 0
mirror of https://github.com/netfun2000/lcd4linux.git synced 2026-02-27 09:44:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

commented, corrected and beautified both timer and timer group code

Browse Source 
git-svn-id: https://ssl.bulix.org/svn/lcd4linux/trunk@1136 3ae390bd-cb1e-0410-b409-cd5a39f66f1f
This commit is contained in:
mzuther
2010-11-28 16:07:16 +00:00
parent 00db296b07
commit 475fdb4397
11 changed files with 546 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drv_T6963.c
+2 -2
View File
@@ -279,7 +279,7 @@ static void drv_T6_clear(const unsigned short addr, const int len)
drv_T6_write_auto(0x0);
if (bug) {
bug = 0;
debug("bug occured at byte %d of %d", i, len);
debug("bug occurred at byte %d of %d", i, len);
}
}
drv_T6_status2();
@@ -297,7 +297,7 @@ static void drv_T6_copy(const unsigned short addr, const unsigned char *data, co
drv_T6_write_auto(*(data++));
if (bug) {
bug = 0;
debug("bug occured at byte %d of %d, addr=%d", i, len, addr);
debug("bug occurred at byte %d of %d, addr=%d", i, len, addr);
}
}
drv_T6_status2();
indent.sh
+1 -1
View File
@@ -8,7 +8,7 @@
# -l120 Set maximum line length for non-comment lines to 150.
# -npro Do not read ‘.indent.pro’ files.
rm *.c~ *.h~
rm *.c~ *.h~ 2>/dev/null # trash "no such file or directory" warning messages
indent -kr -l120 -npro *.c *.h
for i in *.c *.h; do
plugin_button_exec.c
+1 -1
View File
@@ -85,7 +85,7 @@ static void my_button_exec(RESULT * result, int argc, RESULT * argv[])
info(strerror(errsv));
exit(0);
} else if (pid == -1) {
info("weird error has occured. couldn't fork.");
info("weird error has occurred. couldn't fork.");
} else {
SetResult(&result, R_STRING, "0");
}
plugin_gps.c
+1 -1
View File
@@ -572,7 +572,7 @@ static void parse(RESULT * result, RESULT * theOptions, RESULT * displayOptions)
status = nmeap_parseBuffer(&nmea, (const char *) &bufferTmp, &rem); //parse it
if (status == -1) {
errCounter++;
error("parser error occured! (cnt: %i)\n", errCounter);
error("parser error occurred! (cnt: %i)\n", errCounter);
} else if (status == 0) {
incomplCounter++;
} else if (status > 0)
plugin_iconv.c
+1 -1
View File
@@ -104,7 +104,7 @@ static void my_iconv(RESULT * result, RESULT * charset_from, RESULT * charset_to
source_left = 0;
break;
default:
error("plugin_iconv: strange errno state (%d) occured", errno);
error("plugin_iconv: strange errno state (%d) occurred", errno);
source_left = 0;
}
}
plugin_seti.c
+1 -1
View File
@@ -63,7 +63,7 @@ static int parse_seti(void)
FILE *stream;
int age;
/* if a fatal error occured, do nothing */
/* if a fatal error occurred, do nothing */
if (fatal != 0)
return -1;
plugin_wireless.c
+1 -1
View File
@@ -490,7 +490,7 @@ static int get_stats(const char *dev, const char *key)
} else {
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.level, range.max_qual.level);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);;
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.noise, range.max_qual.noise);
timer.c
+76 -60
View File
@@ -1,7 +1,7 @@
/* $Id$
* $URL$
*
* generic timer handling
* Generic timer handling.
*
* Copyright (C) 2003, 2004 Michael Reinelt <michael@reinelt.co.at>
* Copyright (C) 2004 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
@@ -72,19 +72,21 @@
#include <dmalloc.h>
#endif
/* FIXME: CLOCK_SKEW_DETECT_TIME_IN_S should have a higher value */
/* delay in seconds between timer events that is considered as being
induced by clock skew */
#define CLOCK_SKEW_DETECT_TIME_IN_S 1
/* structure for storing all relevant data of a single timer */
typedef struct TIMER {
/* function of type callback(void *data) that will be called when
the timer is processed; it will also be used to identify a
specific timer */
/* pointer to function of type void func(void *data) that will be
called when the timer is processed; it will also be used to
identify a specific timer */
void (*callback) (void *data);
/* data which will be passed to the callback function; it will
also be used to identify a specific timer */
/* pointer to data which will be passed to the callback function;
it will also be used to identify a specific timer */
void *data;
/* struct to hold the time (in seconds and milliseconds since the
@@ -98,17 +100,16 @@ typedef struct TIMER {
it is deleted (value of 0) or only once (all other values) */
int one_shot;
/* marks timers as being active (so it will get processed) or
/* marks timer as being active (so it will get processed) or
inactive (which means the timer has been deleted and its
allocated memory may be re-used) */
int active;
} TIMER;
/* number of allocated timer slots */
int nTimers = 0;
/* pointer to memory used for storing the timer slots */
/* pointer to memory allocated for storing the timer slots */
TIMER *Timers = NULL;
@@ -137,7 +138,7 @@ static void timer_inc(struct timeval *tv, const int interval)
int timer_remove(void (*callback) (void *data), void *data)
/* Remove a new timer with given callback and data.
/* Remove a timer with given callback and data.
callback (void pointer): function of type void func(void *data);
here, it will be used to identify the timer
@@ -146,24 +147,29 @@ int timer_remove(void (*callback) (void *data), void *data)
function; here, it will be used to identify the timer
return value (integer): returns a value of 0 on successful timer
deletion; otherwise returns a value of -1
removal; otherwise returns a value of -1
*/
{
int i; /* current timer's ID */
int timer; /* current timer's ID */
/* loop through the timer slots and try to find the specified
timer slot by looking for its settings */
for (i = 0; i < nTimers; i++) {
if (Timers[i].callback == callback && Timers[i].data == data && Timers[i].active) {
for (timer = 0; timer < nTimers; timer++) {
/* skip inactive (i.e. deleted) timers */
if (Timers[timer].active == 0)
continue;
if (Timers[timer].callback == callback && Timers[timer].data == data) {
/* we have found the timer slot, so mark it as being inactive;
we will not actually delete the timer, so its allocated
we will not actually delete the slot, so its allocated
memory may be re-used */
Timers[i].active = 0;
Timers[timer].active = 0;
/* signal successful timer removal */
return 0;
}
}
/* we have NOT found the timer slot, so signal failure by
returning a value of -1 */
return -1;
@@ -192,26 +198,30 @@ int timer_add(void (*callback) (void *data), void *data, const int interval, con
creation; otherwise returns a value of -1
*/
{
int i; /* current timer's ID */
int timer; /* current timer's ID */
struct timeval now; /* struct to hold current time */
/* try to minimize memory usage by looping through the timer slots
and looking for an inactive timer */
for (i = 0; i < nTimers; i++) {
if (Timers[i].active == 0)
/* we've just found one, so let's reuse it ("i" holds its ID)
by breaking the loop */
for (timer = 0; timer < nTimers; timer++) {
if (Timers[timer].active == 0) {
/* we've just found one, so let's reuse it ("timer" holds its
ID) by breaking the loop */
break;
}
}
/* no inactive timers (or none at all) found, so we have to add a
new timer slot */
if (i >= nTimers) {
if (timer >= nTimers) {
/* increment number of timers and (re-)allocate memory used for
storing the timer slots */
nTimers++;
Timers = realloc(Timers, nTimers * sizeof(*Timers));
/* make sure "timer" points to valid memory */
timer = nTimers - 1;
/* realloc() has failed */
if (Timers == NULL) {
/* restore old number of timers */
@@ -225,21 +235,21 @@ int timer_add(void (*callback) (void *data), void *data, const int interval, con
/* get current time so the timer triggers immediately */
gettimeofday(&now, NULL);
/* fill in timer data */
Timers[i].callback = callback;
Timers[i].data = data;
Timers[i].when = now;
Timers[i].interval = interval;
Timers[i].one_shot = one_shot;
/* initialize timer data */
Timers[timer].callback = callback;
Timers[timer].data = data;
Timers[timer].when = now;
Timers[timer].interval = interval;
Timers[timer].one_shot = one_shot;
/* set timer to active so that it is processed and not overwritten
by the memory optimisation routine above */
Timers[i].active = 1;
by the memory optimization routine above */
Timers[timer].active = 1;
/* one-shot timers should NOT fire immediately, so delay them by a
single timer interval */
if (one_shot) {
timer_inc(&Timers[i].when, interval);
timer_inc(&Timers[timer].when, interval);
}
/* signal successful timer creation */
@@ -279,17 +289,20 @@ int timer_add_late(void (*callback) (void *data), void *data, const int interval
return -1;
}
int i; /* current timer's ID */
int timer; /* current timer's ID */
/* loop through the timer slots and try to find the new timer slot
by looking for its settings */
for (i = 0; i < nTimers; i++) {
if (Timers[i].callback == callback && Timers[i].data == data && Timers[i].active
&& Timers[i].interval == interval) {
for (timer = 0; timer < nTimers; timer++) {
/* skip inactive (i.e. deleted) timers */
if (Timers[timer].active == 0)
continue;
if (Timers[timer].callback == callback && Timers[timer].data == data && Timers[timer].interval == interval) {
/* we have found the new timer slot, so unmask it by setting
its "one_shot" variable to the REAL value; then signal
successful timer creation */
Timers[i].one_shot = one_shot;
Timers[timer].one_shot = one_shot;
/* signal successful timer creation */
return 0;
@@ -317,73 +330,76 @@ int timer_process(struct timespec *delay)
/* get current time to check which timers need processing */
gettimeofday(&now, NULL);
/* sanity check; at least one timer should need processing */
if (nTimers == 0) {
/* sanity check; by now, at least one timer should be
instantiated */
if (nTimers <= 0) {
/* otherwise, print an error and return a value of -1 to
signal an error */
error("Huh? Not one single timer to process? Dazed and confused...");
error("Huh? Not even a single timer to process? Dazed and confused...");
return -1;
}
int i; /* current timer's ID */
int timer; /* current timer's ID */
/* process all expired timers */
for (i = 0; i < nTimers; i++) {
for (timer = 0; timer < nTimers; timer++) {
/* skip inactive (i.e. deleted) timers */
if (Timers[i].active == 0)
if (Timers[timer].active == 0)
continue;
/* check whether current timer needs to be processed, i.e. the
timer's triggering time is less than or equal to the current
time; according to the man page of timercmp(), this avoids
using the operators ">=", "<=" and "==" which might be broken
on some systems */
if (!timercmp(&Timers[i].when, &now, >)) {
if (!timercmp(&Timers[timer].when, &now, >)) {
/* if the timer's callback function has been set, call it and
pass the corresponding data */
if (Timers[i].callback != NULL) {
Timers[i].callback(Timers[i].data);
if (Timers[timer].callback != NULL) {
Timers[timer].callback(Timers[timer].data);
}
/* check for one-shot timers */
if (Timers[i].one_shot) {
if (Timers[timer].one_shot) {
/* mark one-shot timer as inactive (which means the timer has
been deleted and its allocated memory may be re-used) */
Timers[i].active = 0;
Timers[timer].active = 0;
} else {
/* otherwise, respawn timer by adding one triggering interval
to its triggering time */
timer_inc(&Timers[i].when, Timers[i].interval);
timer_inc(&Timers[timer].when, Timers[timer].interval);
}
}
}
int min = -1; /* ID of the next upcoming timer */
int next_timer = -1; /* ID of the next upcoming timer */
/* loop through the timer slots and try to find the next upcoming
timer */
for (i = 0; i < nTimers; i++) {
for (timer = 0; timer < nTimers; timer++) {
/* skip inactive (i.e. deleted) timers */
if (Timers[i].active == 0)
if (Timers[timer].active == 0)
continue;
/* if this is the first timer that we check, mark it as the next
upcoming timer; otherwise, we'll have nothing to compare
against in this loop */
if (min < 0)
min = i;
if (next_timer < 0)
next_timer = timer;
/* check whether current timer needs processing prior to the one
selected */
else if (timercmp(&Timers[i].when, &Timers[min].when, <))
else if (timercmp(&Timers[timer].when, &Timers[next_timer].when, <)) {
/* if so, mark it as the next upcoming timer */
min = i;
next_timer = timer;
}
}
/* sanity check; we should by now have found the next upcoming
timer */
if (min < 0) {
if (next_timer < 0) {
/* otherwise, print an error and return a value of -1 to signal an
error */
error("Huh? Not one single timer left? Dazed and confused...");
error("Huh? Not even a single timer left? Dazed and confused...");
return -1;
}
@@ -397,7 +413,7 @@ int timer_process(struct timespec *delay)
/* calculate delay to the next upcoming timer event and store it
in "diff" */
timersub(&Timers[min].when, &now, &diff);
timersub(&Timers[next_timer].when, &now, &diff);
/* for negative delays, set "diff" to the Epoch so the next update
is triggered immediately */
@@ -417,7 +433,7 @@ int timer_process(struct timespec *delay)
/* update time stamp and timer */
/* FIXME: shouldn't we update *all* timers? */
gettimeofday(&now, NULL);
Timers[min].when = now;
Timers[next_timer].when = now;
}
/* finally, set passed timespec "delay" to "diff" ... */
@@ -439,8 +455,8 @@ void timer_exit(void)
/* reset number of allocated timer slots */
nTimers = 0;
if (Timers != NULL) {
/* free memory used for storing the timer slots */
if (Timers != NULL) {
free(Timers);
Timers = NULL;
}
timer.h
+1
View File
@@ -28,6 +28,7 @@
#ifndef _TIMER_H_
#define _TIMER_H_
int timer_add(void (*callback) (void *data), void *data, const int interval, const int one_shot);
int timer_add_late(void (*callback) (void *data), void *data, const int interval, const int one_shot);
timer_group.c
+458 -162
View File
@@ -1,10 +1,11 @@
/* $Id$
* $URL$
*
* generic grouping of widget timers that have been set to the same
* update interval, thus allowing synchronized updates
* Generic grouping of widgets that have been set to the same update
* interval, thus allowing synchronized updates.
*
* Copyright (C) 2010 Martin Zuther <code@mzuther.de>
* Copyright (C) 2010 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
*
* Based on "timer.c" which is
* Copyright (C) 2003, 2004 Michael Reinelt <michael@reinelt.co.at>
@@ -26,28 +27,32 @@
*
*/
/*
* exported functions:
*
* int timer_add_group(void (*callback) (void *data), const int interval)
* make sure that generic timer exists for given update interval
*
* int timer_remove_group(void (*callback) (void *data), const int interval)
* remove generic timer for given update interval
/*
* Exported functions:
*
* void timer_process_group(void *data)
* process all widgets of a given update interval (*data)
*
* Process all widgets of a timer group; if the timer group only
* contains one-shot timers, it will be deleted after processing.
*
*
* void timer_exit_group(void)
* release all timers and free reserved memory
*
* int timer_add_widget(void (*callback) (void *data), void *data, const int interval, const int one_shot)
* add widget to group of the given update interval (creates a new group if
* necessary)
* Release all timer groups and widgets and free the associated
* memory blocks.
*
*
* int timer_add_widget(void (*callback) (void *data), void *data,
* const int interval, const int one_shot)
*
* Add widget to timer group of the specified update interval
* (also creates a new timer group if necessary).
*
*
* int timer_remove_widget(void (*callback) (void *data), void *data)
* remove widget from group of the given update interval (als removes emtpy
* groups)
*
* Remove widget from the timer group with the specified update
* interval (also removes corresponding timer group if empty).
*
*/
@@ -68,194 +73,485 @@
#endif
/* contains the actual timers, one for each update interval */
/* structure for storing all relevant data of a single timer group */
typedef struct TIMER_GROUP {
void (*callback) (void *data);
/* pointer to the group's triggering interval in milliseconds;
this will be used to identify a specific timer group and also
as callback data for the underlying generic timer */
int *interval;
/* marks timer group as being active (so it will get processed) or
inactive (which means the timer group has been deleted and its
allocated memory may be re-used) */
int active;
} TIMER_GROUP;
TIMER_GROUP *GroupTimers = NULL;
int nGroupTimers = 0;
/* number of allocated timer group slots */
int nTimerGroups = 0;
/* contains callback and data for each widget */
typedef struct SINGLE_TIMER {
/* pointer to memory allocated for storing the timer group slots */
TIMER_GROUP *TimerGroups = NULL;
/* structure for storing all relevant timer data of a single widget */
typedef struct TIMER_GROUP_WIDGET {
/* pointer to function of type void func(void *data) that will be
called when the timer is processed; it will also be used to
identify a specific widget */
void (*callback) (void *data);
/* pointer to data which will be passed to the callback function;
it will also be used to identify a specific widget */
void *data;
/* specifies the timer's triggering interval in milliseconds; it
will also be used to identify a specific widget */
int interval;
/* specifies whether the timer should trigger indefinitely until
it is deleted (value of 0) or only once (all other values) */
int one_shot;
/* marks timer as being active (so it will get processed) or
inactive (which means the timer has been deleted and its
allocated memory may be re-used) */
int active;
} SINGLE_TIMER;
} TIMER_GROUP_WIDGET;
SINGLE_TIMER *SingleTimers = NULL;
int nSingleTimers = 0;
/* number of allocated widget slots */
int nTimerGroupWidgets = 0;
int timer_add_group(void (*callback) (void *data), const int interval)
/* pointer to memory allocated for storing the widget slots */
TIMER_GROUP_WIDGET *TimerGroupWidgets = NULL;
int timer_group_exists(const int interval)
/* Check whether a timer group for the specified interval exists.
interval (integer): the sought-after triggering interval in
milliseconds
return value (integer): returns a value of 1 if timer group
exists; otherwise returns a value of 0
*/
{
int group;
int group; /* current timer group's ID */
/* check whether timer exists for given update interval */
for (group = 0; group < nGroupTimers; group++) {
if (*GroupTimers[group].interval == interval)
return 0;
}
/* otherwise look for a free group */
for (group = 0; group < nGroupTimers; group++) {
if (GroupTimers[group].active == 0)
break;
}
/* none found, allocate a new group */
if (group >= nGroupTimers) {
nGroupTimers++;
GroupTimers = realloc(GroupTimers, nGroupTimers * sizeof(*GroupTimers));
/* also allocate memory for callback data */
GroupTimers[group].interval = malloc(sizeof(int));
}
/* initialize group */
info("Creating new timer group (%d ms)", interval);
GroupTimers[group].callback = callback;
*GroupTimers[group].interval = interval;
GroupTimers[group].active = 1;
/* finally, request a generic timer */
return timer_add(GroupTimers[group].callback, GroupTimers[group].interval, interval, 0);
}
int timer_remove_group(void (*callback) (void *data), const int interval)
{
int group;
/* look for group with given callback function and update interval */
for (group = 0; group < nGroupTimers; group++) {
if (GroupTimers[group].callback == callback && *GroupTimers[group].interval == interval
&& GroupTimers[group].active) {
/* inactivate group */
GroupTimers[group].active = 0;
/* remove generic timer */
return timer_remove(GroupTimers[group].callback, GroupTimers[group].interval);
}
}
return -1;
}
void timer_process_group(void *data)
{
int slot;
int *interval = (int *) data;
/* sanity check */
if (nSingleTimers == 0) {
error("huh? not even a single widget timer to process? dazed and confused...");
return;
}
/* process every (active) widget associated with given update interval */
for (slot = 0; slot < nSingleTimers; slot++) {
if (SingleTimers[slot].active == 0)
/* loop through the timer group slots to search for one that
matches the specified interval */
for (group = 0; group < nTimerGroups; group++) {
/* skip inactive (i.e. deleted) timer groups */
if (TimerGroups[group].active == 0)
continue;
if (SingleTimers[slot].interval == *interval) {
/* call one-shot timers only once */
if (SingleTimers[slot].one_shot)
SingleTimers[slot].active = 0;
/* execute callback function */
if (SingleTimers[slot].callback != NULL)
SingleTimers[slot].callback(SingleTimers[slot].data);
if (*TimerGroups[group].interval == interval) {
/* matching timer group found, so signal success by returning
a value of 1 */
return 1;
}
}
}
int timer_add_widget(void (*callback) (void *data), void *data, const int interval, const int one_shot)
{
int slot;
/* make sure that group for update interval exists or can be created */
if (timer_add_group(timer_process_group, interval) != 0)
return -1;
/* find a free slot for callback data */
for (slot = 0; slot < nSingleTimers; slot++) {
if (SingleTimers[slot].active == 0)
break;
}
/* none found, allocate a new slot */
if (slot >= nSingleTimers) {
nSingleTimers++;
SingleTimers = realloc(SingleTimers, nSingleTimers * sizeof(*SingleTimers));
}
/* fill slot with callback data */
SingleTimers[slot].callback = callback;
SingleTimers[slot].data = data;
SingleTimers[slot].interval = interval;
SingleTimers[slot].one_shot = one_shot;
SingleTimers[slot].active = 1;
/* matching timer group not found, so signal failure by returning
a value of 0 */
return 0;
}
int timer_remove_widget(void (*callback) (void *data), void *data)
{
int slot, interval;
interval = 0;
/* look for (active) widget with given callback function and data */
for (slot = 0; slot < nSingleTimers; slot++) {
if (SingleTimers[slot].callback == callback && SingleTimers[slot].data == data && SingleTimers[slot].active) {
/* deactivate widget */
SingleTimers[slot].active = 0;
interval = SingleTimers[slot].interval;
int timer_add_group(const int interval)
/* Create a new timer group (unless it already exists) and link it to
the timer queue.
interval (integer): the new timer group's triggering interval in
milliseconds
return value (integer): returns a value of 0 on successful timer
group creation; otherwise returns a value of -1
*/
{
/* if timer group for update interval already exists, signal
success by returning a value of 0 */
if (timer_group_exists(interval))
return 0;
/* display an info message to inform the user that a new timer
group is being created */
info("Creating new timer group (%d ms)", interval);
int group; /* current timer group's ID */
/* try to minimize memory usage by looping through timer group
slots and looking for an inactive timer group */
for (group = 0; group < nTimerGroups; group++) {
if (TimerGroups[group].active == 0) {
/* we've just found one, so let's reuse it ("group" holds its
ID) by breaking the loop */
break;
}
}
/* signal an error if no matching widget was found */
if (interval == 0)
return -1;
/* no inactive timer groups (or none at all) found, so we have to
add a new timer group slot */
if (group >= nTimerGroups) {
/* increment number of timer groups and (re-)allocate memory used
for storing the timer group slots */
nTimerGroups++;
TimerGroups = realloc(TimerGroups, nTimerGroups * sizeof(*TimerGroups));
/* look for other widgets with given update interval */
for (slot = 0; slot < nSingleTimers; slot++) {
if (SingleTimers[slot].active == 0)
/* make sure "group" points to valid memory */
group = nTimerGroups - 1;
/* realloc() has failed */
if (TimerGroups == NULL) {
/* restore old number of timer groups */
nTimerGroups--;
/* signal unsuccessful timer group creation */
return -1;
}
/* allocate memory for the underlying generic timer's callback
data (i.e. the group's triggering interval in milliseconds) */
TimerGroups[group].interval = malloc(sizeof(int));
/* malloc() has failed */
if (TimerGroups[group].interval == NULL) {
/* signal unsuccessful timer group creation */
return -1;
}
}
/* initialize timer group's interval */
*TimerGroups[group].interval = interval;
/* set timer group to active so that it is processed and not
overwritten by the memory optimization routine above */
TimerGroups[group].active = 1;
/* finally, request a generic timer that calls this group and
signal success or failure */
return timer_add(timer_process_group, TimerGroups[group].interval, interval, 0);
}
int timer_remove_group(const int interval)
/* Remove a timer group and unlink it from the timer queue (also
removes all remaining widget slots in this timer group).
interval (integer): triggering interval in milliseconds; here, it
will be used to identify the timer group
return value (integer): returns a value of 0 on successful timer
group removal; otherwise returns a value of -1
*/
{
/* display an info message to inform the user that a timer group
is being removed */
info("Removing timer group (%d ms)", interval);
int group; /* current timer group's ID */
int widget; /* current widget's ID */
/* loop through the widget slots to look for remaining widgets
with the specified update interval */
for (widget = 0; widget < nTimerGroupWidgets; widget++) {
/* skip inactive (i.e. deleted) widget slots */
if (TimerGroupWidgets[widget].active == 0)
continue;
/* at least one other widget with given update interval exists */
if (SingleTimers[slot].interval == interval)
if (TimerGroupWidgets[widget].interval == interval) {
/* we have found a matching widget slot, so mark it as being
inactive; we will not actually delete the slot, so its
allocated memory may be re-used */
TimerGroupWidgets[widget].active = 0;
}
}
/* loop through timer group slots and try to find the specified
timer group slot by looking for its settings */
for (group = 0; group < nTimerGroups; group++) {
/* skip inactive (i.e. deleted) timer groups */
if (TimerGroups[group].active == 0)
continue;
if (*TimerGroups[group].interval == interval) {
/* we have found the timer group slot, so mark it as being
inactive; we will not actually delete the slot, so its
allocated memory may be re-used */
TimerGroups[group].active = 0;
/* remove the generic timer that calls this group */
if (timer_remove(timer_process_group, TimerGroups[group].interval)) {
/* signal successful removal of timer group */
return 0;
} else {
/* an error occurred on generic timer removal, so signal
failure by returning a value of -1 */
return -1;
}
}
}
/* we have NOT found the timer group slot, so signal failure by
returning a value of -1 */
return -1;
}
int timer_remove_empty_group(const int interval)
/* Remove timer group *only* if it contains no more widget slots.
interval (integer): triggering interval in milliseconds; here, it
will be used to identify the timer group
return value (integer): returns a value of 0 on successful
processing; otherwise returns a value of -1
*/
{
int widget; /* current widget's ID */
/* loop through the widget slots to look for widgets with the
specified update interval */
for (widget = 0; widget < nTimerGroupWidgets; widget++) {
/* skip inactive (i.e. deleted) widget slots */
if (TimerGroupWidgets[widget].active == 0)
continue;
/* at least one other widget with specified update interval
exists, so signal success by returning a value of 0 */
if (TimerGroupWidgets[widget].interval == interval)
return 0;
}
/* remove group with given update interval */
return timer_remove_group(timer_process_group, interval);
/* no other widgets with specified update interval exist, so
remove corresponding timer group and signal success or
failure */
return timer_remove_group(interval);
}
void timer_process_group(void *data)
/* Process all widgets of a timer group; if the timer group only
contains one-shot timers, it will be deleted after processing.
data (void pointer): points to an integer holding the triggering
interval in milliseconds; here, it will be used to identify the
timer group
return value: void
*/
{
int widget; /* current widget's ID */
/* convert callback data to integer (triggering interval in
milliseconds) */
int interval = *((int *) data);
/* sanity check; by now, at least one timer group should be
instantiated */
if (nTimerGroups <= 0) {
/* otherwise, print an error and return early */
error("Huh? Not even a single timer group to process? Dazed and confused...");
return;
}
/* sanity check; by now, at least one widget slot should be
instantiated */
if (nTimerGroupWidgets <= 0) {
/* otherwise, print an error and return early */
error("Huh? Not even a single widget slot to process? Dazed and confused...");
return;
}
/* loop through widgets and search for those matching the timer
group's update interval */
for (widget = 0; widget < nTimerGroupWidgets; widget++) {
/* skip inactive (i.e. deleted) widgets */
if (TimerGroupWidgets[widget].active == 0)
continue;
/* the current widget belongs to the specified timer group */
if (TimerGroupWidgets[widget].interval == interval) {
/* if the widget's callback function has been set, call it and
pass the corresponding data */
if (TimerGroupWidgets[widget].callback != NULL)
TimerGroupWidgets[widget].callback(TimerGroupWidgets[widget].data);
/* mark one-shot widget as inactive (which means the it has
been deleted and its allocated memory may be re-used) */
if (TimerGroupWidgets[widget].one_shot) {
TimerGroupWidgets[widget].active = 0;
/* also remove the corresponding timer group if it is empty */
timer_remove_empty_group(interval);
}
}
}
}
int timer_add_widget(void (*callback) (void *data), void *data, const int interval, const int one_shot)
/* Add widget to timer group of the specified update interval
(also creates a new timer group if necessary).
callback (void pointer): function of type void func(void *data)
which will be called whenever the timer group triggers; this
pointer will also be used to identify a specific widget
data (void pointer): data which will be passed to the callback
function; this pointer will also be used to identify a specific
widget
interval (integer): specifies the timer's triggering interval in
milliseconds
one_shot (integer): specifies whether the timer should trigger
indefinitely until it is deleted (value of 0) or only once (all
other values)
return value (integer): returns a value of 0 on successful widget
addition; otherwise returns a value of -1
*/
{
int widget; /* current widget's ID */
/* if no timer group for update interval exists, create one */
if (!timer_group_exists(interval)) {
/* creation of new timer group failed, so signal failure by
returning a value of -1 */
if (timer_add_group(interval) != 0)
return -1;
}
/* try to minimize memory usage by looping through the widget
slots and looking for an inactive widget slot */
for (widget = 0; widget < nTimerGroupWidgets; widget++) {
if (TimerGroupWidgets[widget].active == 0) {
/* we've just found one, so let's reuse it ("widget" holds its
ID) by breaking the loop */
break;
}
}
/* no inactive widget slots (or none at all) found, so we have to
add a new widget slot */
if (widget >= nTimerGroupWidgets) {
/* increment number of widget slots and (re-)allocate memory used
for storing the widget slots */
nTimerGroupWidgets++;
TimerGroupWidgets = realloc(TimerGroupWidgets, nTimerGroupWidgets * sizeof(*TimerGroupWidgets));
/* make sure "widget" points to valid memory */
widget = nTimerGroupWidgets - 1;
/* realloc() has failed */
if (TimerGroupWidgets == NULL) {
/* restore old number of widget slots */
nTimerGroupWidgets--;
/* signal unsuccessful creation of widget slot */
return -1;
}
}
/* initialize widget slot */
TimerGroupWidgets[widget].callback = callback;
TimerGroupWidgets[widget].data = data;
TimerGroupWidgets[widget].interval = interval;
TimerGroupWidgets[widget].one_shot = one_shot;
/* set widget slot to active so that it is processed and not
overwritten by the memory optimization routine above */
TimerGroupWidgets[widget].active = 1;
/* signal successful addition of widget slot */
return 0;
}
int timer_remove_widget(void (*callback) (void *data), void *data)
/* Remove widget from the timer group with the specified update
interval (also removes corresponding timer group if empty).
callback (void pointer): function of type void func(void *data);
here, it will be used to identify a specific widget
data (void pointer): data which will be passed to the callback
function; here, it will be used to identify a specific widget
return value (integer): returns a value of 0 on successful widget
removal; otherwise returns a value of -1
*/
{
int widget; /* current widget's ID */
int interval = -1; /* specified widget's triggering interval in
milliseconds */
/* loop through the widget slots and try to find the specified
widget slot by looking for its settings */
for (widget = 0; widget < nTimerGroupWidgets; widget++) {
/* skip inactive (i.e. deleted) widget slots */
if (TimerGroupWidgets[widget].active == 0)
continue;
if (TimerGroupWidgets[widget].callback == callback && TimerGroupWidgets[widget].data == data) {
/* we have found the widget slot, so mark it as being
inactive; we will not actually delete the slot, so its
allocated memory may be re-used */
TimerGroupWidgets[widget].active = 0;
/* store the widget's triggering interval for later use and
break the loop */
interval = TimerGroupWidgets[widget].interval;
break;
}
}
/* if no matching widget was found, signal an error by returning
a value of -1 */
if (interval < 0)
return -1;
/* if no other widgets with specified update interval exist,
remove corresponding timer group and signal success or
failure */
return timer_remove_empty_group(interval);
}
void timer_exit_group(void)
/* Release all timer groups and widgets and free the associated
memory blocks.
return value: void
*/
{
int group;
int group; /* current timer group's ID */
/* remove generic timer and free memory for callback data */
for (group = 0; group < nGroupTimers; group++) {
timer_remove(GroupTimers[group].callback, GroupTimers[group].interval);
free(GroupTimers[group].interval);
/* loop through all timer groups and remove them one by one */
for (group = 0; group < nTimerGroups; group++) {
/* remove generic timer */
timer_remove(timer_process_group, TimerGroups[group].interval);
/* free memory allocated for callback data (i.e. the group's
triggering interval in milliseconds) */
free(TimerGroups[group].interval);
}
/* free memory for groups */
nGroupTimers = 0;
/* reset number of allocated timer groups */
nTimerGroups = 0;
if (GroupTimers != NULL) {
free(GroupTimers);;
GroupTimers = NULL;
/* free allocated memory containing the timer group slots */
if (TimerGroups != NULL) {
free(TimerGroups);
TimerGroups = NULL;
}
/* free memory for widget callback data */
nSingleTimers = 0;
/* reset number of allocated widget slots */
nTimerGroupWidgets = 0;
if (SingleTimers != NULL) {
free(SingleTimers);;
SingleTimers = NULL;
/* free allocated memory containing the widget slots */
if (TimerGroupWidgets != NULL) {
free(TimerGroupWidgets);
TimerGroupWidgets = NULL;
}
}
timer_group.h
+3 -2
View File
@@ -29,12 +29,13 @@
#ifndef _TIMER_GROUP_H_
#define _TIMER_GROUP_H_
int timer_add_group(void (*callback) (void *data), const int interval);
int timer_remove_group(void (*callback) (void *data), const int interval);
void timer_process_group(void *data);
void timer_exit_group(void);
int timer_add_widget(void (*callback) (void *data), void *data, const int interval, const int one_shot);
int timer_remove_widget(void (*callback) (void *data), void *data);
#endif