From 367bf8f76227dea6e7e10e974967ae1d60cfe38e Mon Sep 17 00:00:00 2001 From: Andreas Fink Date: Thu, 7 Jan 2010 19:51:00 +0000 Subject: [PATCH] *add* interval timeouts are aligned to each other --- src/systray/systraybar.c | 9 +- src/tint.c | 1 + src/util/timer.c | 255 ++++++++++++++++++++++++++++++++++++--- src/util/timer.h | 3 +- 4 files changed, 246 insertions(+), 22 deletions(-) diff --git a/src/systray/systraybar.c b/src/systray/systraybar.c index 454245a..e9b6c50 100644 --- a/src/systray/systraybar.c +++ b/src/systray/systraybar.c @@ -423,7 +423,7 @@ gboolean add_icon(Window id) // watch for the icon trying to resize itself! XSelectInput(server.dsp, traywin->tray_id, StructureNotifyMask); if (real_transparency || systray.alpha != 100 || systray.brightness != 0 || systray.saturation != 0) { - traywin->damage = XDamageCreate(server.dsp, traywin->id, XDamageReportRawRectangles); + traywin->damage = XDamageCreate(server.dsp, traywin->id, XDamageReportNonEmpty); XCompositeRedirectWindow(server.dsp, traywin->id, CompositeRedirectManual); } @@ -498,8 +498,9 @@ void net_message(XClientMessageEvent *e) } } -void systray_render_icon_now(TrayWindow* traywin) +void systray_render_icon_now(void* t) { + TrayWindow* traywin = t; traywin->render_timeout = 0; // good systray icons support 32 bit depth, but some icons are still 24 bit. @@ -531,6 +532,7 @@ void systray_render_icon_now(TrayWindow* traywin) XCopyArea(server.dsp, systray.area.pix.pmap, panel->main_win, server.gc, traywin->x-systray.area.posx, traywin->y-systray.area.posy, traywin->width, traywin->height, traywin->x, traywin->y); imlib_free_image_and_decache(); + XDamageSubtract(server.dsp, traywin->damage, None, None); XFlush(server.dsp); } @@ -554,7 +556,4 @@ void refresh_systray_icon() else XClearArea(server.dsp, traywin->id, 0, 0, traywin->width, traywin->height, True); } -// -// if (real_transparency || systray.alpha != 100 || systray.brightness != 0 || systray.saturation != 0) -// XFlush(server.dsp); } diff --git a/src/tint.c b/src/tint.c index 0d78657..5c4ee16 100644 --- a/src/tint.c +++ b/src/tint.c @@ -139,6 +139,7 @@ void init_X11() void cleanup() { + stop_all_timeouts(); cleanup_systray(); stop_net(); cleanup_panel(); diff --git a/src/util/timer.c b/src/util/timer.c index 6bb7578..3ccec7c 100644 --- a/src/util/timer.c +++ b/src/util/timer.c @@ -17,6 +17,7 @@ #include #include +#include #include "timer.h" @@ -27,7 +28,29 @@ void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(void 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); +void callback_multi_timeout(void* mth); +void remove_from_multi_timeout(struct timeout* t); +void stop_multi_timeout(struct timeout* t); + +GHashTable* multi_timeouts = 0; /** Implementation notes for timeouts: The timeouts are kept in a GSList sorted by their * expiration time. @@ -44,6 +67,7 @@ int timespec_subtract(struct timespec* result, struct timespec* x, struct timesp const struct timeout* add_timeout(int value_msec, int interval_msec, void (*_callback)(void*), void* arg) { struct timeout* t = malloc(sizeof(struct timeout)); + t->multi_timeout = 0; add_timeout_intern(value_msec, interval_msec, _callback, arg, t); return t; } @@ -51,10 +75,13 @@ const struct timeout* add_timeout(int value_msec, int interval_msec, void (*_cal void change_timeout(const struct timeout *t, int value_msec, int interval_msec, void(*_callback)(), void* arg) { - if ( g_slist_find(timeout_list, t) == 0 ) - printf("timeout already deleted..."); + if ( g_slist_find(timeout_list, t) == 0 && g_hash_table_lookup(multi_timeouts, t) == 0) + printf("programming error: timeout already deleted..."); else { - timeout_list = g_slist_remove(timeout_list, t); + if (t->multi_timeout) + remove_from_multi_timeout((struct timeout*)t); + else + timeout_list = g_slist_remove(timeout_list, t); add_timeout_intern(value_msec, interval_msec, _callback, arg, (struct timeout*)t); } } @@ -109,7 +136,9 @@ void callback_timeout_expired() void stop_timeout(const struct timeout* t) { // if not in the list, it was deleted in callback_timeout_expired - if (g_slist_find(timeout_list, t)) { + 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); timeout_list = g_slist_remove(timeout_list, t); free((void*)t); } @@ -119,8 +148,11 @@ void stop_timeout(const struct timeout* t) void stop_all_timeouts() { while (timeout_list) { - free(timeout_list->data); - timeout_list = g_slist_remove(timeout_list, timeout_list->data); + struct timeout* t = timeout_list->data; + if (t->multi_timeout) + stop_multi_timeout(t); + free(t); + timeout_list = g_slist_remove(timeout_list, t); } } @@ -130,16 +162,15 @@ void add_timeout_intern(int value_msec, int interval_msec, void(*_callback)(), v t->interval_msec = interval_msec; t->_callback = _callback; t->arg = arg; - struct timespec expire; - clock_gettime(CLOCK_MONOTONIC, &expire); - expire.tv_sec += value_msec / 1000; - expire.tv_nsec += (value_msec % 1000)*1000000; - if (expire.tv_nsec >= 1000000000) { // 10^9 - expire.tv_sec++; - expire.tv_nsec -= 1000000000; - } - t->timeout_expires = expire; - timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts); + struct timespec cur_time; + clock_gettime(CLOCK_MONOTONIC, &cur_time); + t->timeout_expires = add_msec_to_timespec(cur_time, value_msec); + + int can_align = 0; + if (interval_msec > 0 && !t->multi_timeout) + can_align = align_with_existing_timeouts(t); + if (!can_align) + timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts); } @@ -187,3 +218,195 @@ int timespec_subtract(struct timespec* result, struct timespec* x, struct timesp /* Return 1 if result is negative. */ return x->tv_sec < y->tv_sec; } + + +struct timespec add_msec_to_timespec(struct timespec ts, int msec) +{ + ts.tv_sec += msec / 1000; + ts.tv_nsec += (msec % 1000)*1000000; + if (ts.tv_nsec >= 1000000000) { // 10^9 + ts.tv_sec++; + ts.tv_nsec -= 1000000000; + } + return ts; +} + + +int align_with_existing_timeouts(struct timeout *t) +{ + GSList* it = timeout_list; + while (it) { + struct 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) + multi_timeouts = g_hash_table_new(0, 0); + if (!t->multi_timeout && !t2->multi_timeout) + // both timeouts can be aligned, but there is no multi timeout for them + create_multi_timeout(t, t2); + else + // there is already a multi timeout, so we append the new timeout to the multi timeout + append_multi_timeout(t, t2); + return 1; + } + } + it = it->next; + } + return 0; +} + + +int calc_multi_timeout_interval(struct multi_timeout_handler* mth) +{ + GSList* it = mth->timeout_list; + struct timeout* t = it->data; + int min_interval = t->interval_msec; + it = it->next; + while (it) { + t = it->data; + if (t->interval_msec < min_interval) + min_interval = t->interval_msec; + it = it->next; + } + return min_interval; +} + + +void create_multi_timeout(struct timeout* t1, struct 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)); + + mth->timeout_list = 0; + mth->timeout_list = g_slist_prepend(mth->timeout_list, t1); + mth->timeout_list = g_slist_prepend(mth->timeout_list, t2); + mth->parent_timeout = real_timeout; + + g_hash_table_insert(multi_timeouts, t1, mth); + g_hash_table_insert(multi_timeouts, t2, mth); + g_hash_table_insert(multi_timeouts, real_timeout, mth); + + t1->multi_timeout = mt1; + t2->multi_timeout = mt2; + real_timeout->multi_timeout = real_timeout; + + timeout_list = g_slist_remove(timeout_list, t1); + timeout_list = g_slist_remove(timeout_list, t2); + + update_multi_timeout_values(mth); +} + + +void append_multi_timeout(struct timeout* t1, struct timeout* t2) +{ + if (t2->multi_timeout) { + // swap t1 and t2 such that t1 is the multi timeout + struct 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); + + mth->timeout_list = g_slist_prepend(mth->timeout_list, t2); + g_hash_table_insert(multi_timeouts, t2, mth); + + t2->multi_timeout = mt; + + update_multi_timeout_values(mth); +} + + +void update_multi_timeout_values(struct multi_timeout_handler* mth) +{ + int interval = calc_multi_timeout_interval(mth); + int next_timeout_msec = interval; + + struct timespec cur_time; + clock_gettime(CLOCK_MONOTONIC, &cur_time); + + 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; + 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; + if (msec_to_expiration < next_timeout_msec) + next_timeout_msec = msec_to_expiration; + it = it->next; + } + + mth->parent_timeout->interval_msec = interval; + timeout_list = g_slist_remove(timeout_list, mth->parent_timeout); + add_timeout_intern(next_timeout_msec, interval, callback_multi_timeout, mth, mth->parent_timeout); +} + + +void callback_multi_timeout(void* arg) +{ + struct 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) { + t->_callback(t->arg); + mt->current_count = 0; + t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec); + } + it = it->next; + } +} + + +void remove_from_multi_timeout(struct timeout* t) +{ + struct 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); + free(t->multi_timeout); + t->multi_timeout = 0; + + if (g_slist_length(mth->timeout_list) == 1) { + struct 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); + g_hash_table_remove(multi_timeouts, mth->parent_timeout); + mth->parent_timeout->multi_timeout = 0; + stop_timeout(mth->parent_timeout); + free(mth); + + struct timespec cur_time, diff_time; + clock_gettime(CLOCK_MONOTONIC, &cur_time); + timespec_subtract(&diff_time, &t->timeout_expires, &cur_time); + int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000; + add_timeout_intern(msec_to_expiration, last_timeout->interval_msec, last_timeout->_callback, last_timeout->arg, last_timeout); + } + else + update_multi_timeout_values(mth); +} + + +void stop_multi_timeout(struct timeout* t) +{ + struct 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; + mth->timeout_list = g_slist_remove(mth->timeout_list, t); + g_hash_table_remove(multi_timeouts, t); + free(t); + } + free(mth); +} diff --git a/src/util/timer.h b/src/util/timer.h index b816918..df06fc3 100644 --- a/src/util/timer.h +++ b/src/util/timer.h @@ -28,8 +28,9 @@ extern struct timeval next_timeout; struct timeout { int interval_msec; struct timespec timeout_expires; - void (*_callback)(); + void (*_callback)(void*); void* arg; + void* multi_timeout; }; -- 2.44.0