Mabox/tint2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*add* more task states (normal, active, iconified, urgent), with each an own background, font and asb

Browse Source 
*fix* two memleaks
*fix* some code beautification



git-svn-id: http://tint2.googlecode.com/svn/trunk@327 121b4492-b84c-0410-8b4c-0d4edfb3f3cc
This commit is contained in:
Andreas.Fink85
2010-01-09 00:11:01 +00:00
parent 8042047cd4
commit 739af13714
24 changed files with 518 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
src/util/timer.c
View File

@@ -24,31 +24,41 @@
GSList* timeout_list = 0;
struct timeval next_timeout;
void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(void*), void* arg, struct timeout* t);
// functions and structs for multi timeouts
typedef struct {
int current_count;
int count_to_expiration;
} multi_timeout;
typedef struct {
GSList* timeout_list;
timeout* parent_timeout;
} multi_timeout_handler;
struct _timeout {
int interval_msec;
struct timespec timeout_expires;
void (*_callback)(void*);
void* arg;
multi_timeout* multi_timeout;
};
void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(void*), void* arg, timeout* t);
gint compare_timeouts(gconstpointer t1, gconstpointer t2);
gint compare_timespecs(const struct timespec* t1, const struct timespec* t2);
int timespec_subtract(struct timespec* result, struct timespec* x, struct timespec* y);
struct timespec add_msec_to_timespec(struct timespec ts, int msec);
// functions and structs for multi timeouts
struct multi_timeout {
int current_count;
int count_to_expiration;
};
struct multi_timeout_handler {
GSList* timeout_list;
struct timeout* parent_timeout;
};
int align_with_existing_timeouts(struct timeout* t);
void create_multi_timeout(struct timeout* t1, struct timeout* t2);
void append_multi_timeout(struct timeout* t1, struct timeout* t2);
int calc_multi_timeout_interval(struct multi_timeout_handler* mth);
void update_multi_timeout_values(struct multi_timeout_handler* mth);
int align_with_existing_timeouts(timeout* t);
void create_multi_timeout(timeout* t1, timeout* t2);
void append_multi_timeout(timeout* t1, timeout* t2);
int calc_multi_timeout_interval(multi_timeout_handler* mth);
void update_multi_timeout_values(multi_timeout_handler* mth);
void callback_multi_timeout(void* mth);
void remove_from_multi_timeout(struct timeout* t);
void stop_multi_timeout(struct timeout* t);
void remove_from_multi_timeout(timeout* t);
void stop_multi_timeout(timeout* t);
GHashTable* multi_timeouts = 0;
@@ -64,25 +74,25 @@ GHashTable* multi_timeouts = 0;
* however it's save to call it.
**/
const struct timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg)
timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg)
{
struct timeout* t = malloc(sizeof(struct timeout));
timeout* t = malloc(sizeof(timeout));
t->multi_timeout = 0;
add_timeout_intern(value_msec, interval_msec, _callback, arg, t);
return t;
}
void change_timeout(const struct timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg)
void change_timeout(timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg)
{
if ( g_slist_find(timeout_list, t) == 0 && g_hash_table_lookup(multi_timeouts, t) == 0)
printf("programming error: timeout already deleted...");
else {
if (t->multi_timeout)
remove_from_multi_timeout((struct timeout*)t);
remove_from_multi_timeout((timeout*)t);
else
timeout_list = g_slist_remove(timeout_list, t);
add_timeout_intern(value_msec, interval_msec, _callback, arg, (struct timeout*)t);
add_timeout_intern(value_msec, interval_msec, _callback, arg, (timeout*)t);
}
}
@@ -90,7 +100,7 @@ void change_timeout(const struct timeout *t, int value_msec, int interval_msec,
void update_next_timeout()
{
if (timeout_list) {
struct timeout* t = timeout_list->data;
timeout* t = timeout_list->data;
struct timespec cur_time;
struct timespec next_timeout2 = { .tv_sec=next_timeout.tv_sec, .tv_nsec=next_timeout.tv_usec*1000 };
clock_gettime(CLOCK_MONOTONIC, &cur_time);
@@ -111,7 +121,7 @@ void update_next_timeout()
void callback_timeout_expired()
{
struct timespec cur_time;
struct timeout* t;
timeout* t;
while (timeout_list) {
clock_gettime(CLOCK_MONOTONIC, &cur_time);
t = timeout_list->data;
@@ -133,12 +143,12 @@ void callback_timeout_expired()
}
void stop_timeout(const struct timeout* t)
void stop_timeout(timeout* t)
{
// if not in the list, it was deleted in callback_timeout_expired
if (g_slist_find(timeout_list, t) || g_hash_table_lookup(multi_timeouts, t)) {
if (t->multi_timeout)
remove_from_multi_timeout((struct timeout*)t);
remove_from_multi_timeout((timeout*)t);
timeout_list = g_slist_remove(timeout_list, t);
free((void*)t);
}
@@ -148,7 +158,7 @@ void stop_timeout(const struct timeout* t)
void stop_all_timeouts()
{
while (timeout_list) {
struct timeout* t = timeout_list->data;
timeout* t = timeout_list->data;
if (t->multi_timeout)
stop_multi_timeout(t);
free(t);
@@ -157,7 +167,7 @@ void stop_all_timeouts()
}
void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), void* arg, struct timeout *t)
void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), void* arg, timeout *t)
{
t->interval_msec = interval_msec;
t->_callback = _callback;
@@ -176,8 +186,8 @@ void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), v
gint compare_timeouts(gconstpointer t1, gconstpointer t2)
{
return compare_timespecs(&((const struct timeout*)t1)->timeout_expires,
&((const struct timeout*)t2)->timeout_expires);
return compare_timespecs(&((timeout*)t1)->timeout_expires,
&((timeout*)t2)->timeout_expires);
}
@@ -232,11 +242,11 @@ struct timespec add_msec_to_timespec(struct timespec ts, int msec)
}
int align_with_existing_timeouts(struct timeout *t)
int align_with_existing_timeouts(timeout *t)
{
GSList* it = timeout_list;
while (it) {
struct timeout* t2 = it->data;
timeout* t2 = it->data;
if (t2->interval_msec > 0) {
if (t->interval_msec % t2->interval_msec == 0 || t2->interval_msec % t->interval_msec == 0) {
if (multi_timeouts == 0)
@@ -256,10 +266,10 @@ int align_with_existing_timeouts(struct timeout *t)
}
int calc_multi_timeout_interval(struct multi_timeout_handler* mth)
int calc_multi_timeout_interval(multi_timeout_handler* mth)
{
GSList* it = mth->timeout_list;
struct timeout* t = it->data;
timeout* t = it->data;
int min_interval = t->interval_msec;
it = it->next;
while (it) {
@@ -272,12 +282,12 @@ int calc_multi_timeout_interval(struct multi_timeout_handler* mth)
}
void create_multi_timeout(struct timeout* t1, struct timeout* t2)
void create_multi_timeout(timeout* t1, timeout* t2)
{
struct multi_timeout* mt1 = malloc(sizeof(struct multi_timeout));
struct multi_timeout* mt2 = malloc(sizeof(struct multi_timeout));
struct multi_timeout_handler* mth = malloc(sizeof(struct multi_timeout_handler));
struct timeout* real_timeout = malloc(sizeof(struct timeout));
multi_timeout* mt1 = malloc(sizeof(multi_timeout));
multi_timeout* mt2 = malloc(sizeof(multi_timeout));
multi_timeout_handler* mth = malloc(sizeof(multi_timeout_handler));
timeout* real_timeout = malloc(sizeof(timeout));
mth->timeout_list = 0;
mth->timeout_list = g_slist_prepend(mth->timeout_list, t1);
@@ -299,17 +309,17 @@ void create_multi_timeout(struct timeout* t1, struct timeout* t2)
}
void append_multi_timeout(struct timeout* t1, struct timeout* t2)
void append_multi_timeout(timeout* t1, timeout* t2)
{
if (t2->multi_timeout) {
// swap t1 and t2 such that t1 is the multi timeout
struct timeout* tmp = t2;
timeout* tmp = t2;
t2 = t1;
t1 = tmp;
}
struct multi_timeout* mt = malloc(sizeof(struct multi_timeout));
struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t1);
multi_timeout* mt = malloc(sizeof(multi_timeout));
multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t1);
mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
g_hash_table_insert(multi_timeouts, t2, mth);
@@ -320,7 +330,7 @@ void append_multi_timeout(struct timeout* t1, struct timeout* t2)
}
void update_multi_timeout_values(struct multi_timeout_handler* mth)
void update_multi_timeout_values(multi_timeout_handler* mth)
{
int interval = calc_multi_timeout_interval(mth);
int next_timeout_msec = interval;
@@ -331,13 +341,12 @@ void update_multi_timeout_values(struct multi_timeout_handler* mth)
GSList* it = mth->timeout_list;
struct timespec diff_time;
while (it) {
struct timeout* t = it->data;
struct multi_timeout* mt = t->multi_timeout;
mt->count_to_expiration = t->interval_msec / interval;
timeout* t = it->data;
t->multi_timeout->count_to_expiration = t->interval_msec / interval;
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000;
int count_left = msec_to_expiration / interval + (msec_to_expiration%interval != 0);
mt->current_count = mt->count_to_expiration - count_left;
t->multi_timeout->current_count = t->multi_timeout->count_to_expiration - count_left;
if (msec_to_expiration < next_timeout_msec)
next_timeout_msec = msec_to_expiration;
it = it->next;
@@ -351,16 +360,15 @@ void update_multi_timeout_values(struct multi_timeout_handler* mth)
void callback_multi_timeout(void* arg)
{
struct multi_timeout_handler* mth = arg;
multi_timeout_handler* mth = arg;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
GSList* it = mth->timeout_list;
while (it) {
struct timeout* t = it->data;
struct multi_timeout* mt = t->multi_timeout;
if (++mt->current_count >= mt->count_to_expiration) {
timeout* t = it->data;
if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) {
t->_callback(t->arg);
mt->current_count = 0;
t->multi_timeout->current_count = 0;
t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec);
}
it = it->next;
@@ -368,9 +376,9 @@ void callback_multi_timeout(void* arg)
}
void remove_from_multi_timeout(struct timeout* t)
void remove_from_multi_timeout(timeout* t)
{
struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, t);
mth->timeout_list = g_slist_remove(mth->timeout_list, t);
@@ -378,7 +386,7 @@ void remove_from_multi_timeout(struct timeout* t)
t->multi_timeout = 0;
if (g_slist_length(mth->timeout_list) == 1) {
struct timeout* last_timeout = mth->timeout_list->data;
timeout* last_timeout = mth->timeout_list->data;
free(last_timeout->multi_timeout);
last_timeout->multi_timeout = 0;
g_hash_table_remove(multi_timeouts, last_timeout);
@@ -398,12 +406,12 @@ void remove_from_multi_timeout(struct timeout* t)
}
void stop_multi_timeout(struct timeout* t)
void stop_multi_timeout(timeout* t)
{
struct multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
while (mth->timeout_list) {
struct timeout* t = mth->timeout_list->data;
timeout* t = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, t);
g_hash_table_remove(multi_timeouts, t);
free(t);