X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Futil%2Farea.c;h=e5804335442eb454e0a53e60097f790c0cbd1168;hb=30ea5428a1a0080d01247458e0b2a8fc63ef582b;hp=dd50c9e10e9e6a933c421c0bc9940bdc377bc07a;hpb=c803db3d16c62949428b4e0e2fcd85b8889a7ff3;p=chaz%2Ftint2 diff --git a/src/util/area.c b/src/util/area.c index dd50c9e..e580433 100644 --- a/src/util/area.c +++ b/src/util/area.c @@ -32,27 +32,158 @@ /************************************************************ - * Layering & drawing loop of tint2 + * !!! This design is experimental and not yet fully implemented !!!!!!!!!!!!! * + * DATA ORGANISATION : * Areas in tint2 are similar to widgets in a GUI. - * Areas (task, clock, systray, taskbar,...) are nodes in a tree. - * The position of each Area is defined by parent's position and brothers on the left. + * All graphical objects (panel, taskbar, task, systray, clock, ...) 'inherit' an abstract class 'Area'. + * This class 'Area' manage the background, border, size, position and padding. + * Area is at the begining of each object (&object == &area). * - * !!! This design is experimental and not yet complete !!!!!!!!!!!!! + * tint2 define one panel per monitor. And each panel have a tree of Area. + * The root of the tree is Panel.Area. And task, clock, systray, taskbar,... are nodes. * - * 1) browse tree and resize SIZE_BY_CONTENT node - * - children node are resized before its parent + * The tree give the localisation of each object : + * - tree's root is in the background while tree's leafe are foreground objects + * - position of a node/Area depend on the layout : parent's position (posx, posy), size of previous brothers and parent's padding + * - size of a node/Area depend on the content (SIZE_BY_CONTENT objects) or on the layout (SIZE_BY_LAYOUT objects) + * + * DRAWING AND LAYERING ENGINE : + * Redrawing an object (like the clock) could come from an 'external event' (date change) + * or from a 'layering event' (position change). + * The following 'drawing engine' take care of : + * - posx/posy of all Area + * - 'layering event' propagation between object + * 1) browse tree SIZE_BY_CONTENT + * - resize SIZE_BY_CONTENT node : children are resized before parent * - if 'size' changed then 'resize = 1' on the parent - * 2) browse tree and resize SIZE_BY_LAYOUT node - * - parent node is resized before its children + * 2) browse tree SIZE_BY_LAYOUT and POSITION + * - resize SIZE_BY_LAYOUT node : parent is resized before children * - if 'size' changed then 'resize = 1' on childs with SIZE_BY_LAYOUT - * 3) calculate posx of all objects - * - parent's position is calculated before children's position - * 4) redraw needed objects + * - calculate position (posx,posy) : parent is calculated before children + * - if 'position' changed then 'redraw = 1' + * 3) browse tree REDRAW + * - redraw needed objects : parent is drawn before children + * + * CONFIGURE PANEL'S LAYOUT : + * 'panel_items' parameter (in config) define the list and the order of nodes in tree's panel. + * 'panel_items = SC' define a panel with just Systray and Clock. + * So the tree 'Panel.Area' will have 2 childs (Systray and Clock). + * ************************************************************/ -void size_by_content (Area *a); -void size_by_layout (Area *a); +void init_rendering(void *obj, int pos) +{ + Area *a = (Area*)obj; + + // initialize fixed position/size + GSList *l; + for (l = a->list; l ; l = l->next) { + Area *child = ((Area*)l->data); + if (panel_horizontal) { + child->posy = pos + a->bg->border.width + a->paddingy; + child->height = a->height - (2 * (a->bg->border.width + a->paddingy)); + init_rendering(child, child->posy); + } + else { + child->posx = pos + a->bg->border.width + a->paddingy; + child->width = a->width - (2 * (a->bg->border.width + a->paddingy)); + init_rendering(child, child->posx); + } + } +} + + +void rendering(void *obj) +{ + Panel *panel = (Panel*)obj; + + size_by_content(&panel->area); + size_by_layout(&panel->area, 0, 0); + + refresh(&panel->area); +} + + +void size_by_content (Area *a) +{ + // don't resize hiden objects + if (!a->on_screen) return; + + // children node are resized before its parent + GSList *l; + for (l = a->list; l ; l = l->next) + size_by_content(l->data); + + // calculate area's size + if (a->resize && a->size_mode == SIZE_BY_CONTENT) { + a->resize = 0; + + if (a->_resize) { + if (a->_resize(a)) { + // 'size' changed => 'resize = 1' on the parent and redraw object + ((Area*)a->parent)->resize = 1; + } + a->redraw = 1; + } + } +} + + +void size_by_layout (Area *a, int pos, int level) +{ + // don't resize hiden objects + if (!a->on_screen) return; + + // parent node is resized before its children + // calculate area's size + GSList *l; + if (a->resize && a->size_mode == SIZE_BY_LAYOUT) { + a->resize = 0; + + if (a->_resize) { + if (a->_resize(a)) { + // if 'size' changed then 'resize = 1' on childs with SIZE_BY_LAYOUT + for (l = a->list; l ; l = l->next) { + if (((Area*)l->data)->size_mode == SIZE_BY_LAYOUT) + ((Area*)l->data)->resize = 1; + } + } + } + } + + // update position of childs + pos += a->paddingxlr + a->bg->border.width; + int i=0; + for (l = a->list; l ; l = l->next) { + Area *child = ((Area*)l->data); + if (!child->on_screen) continue; + i++; + + if (panel_horizontal) { + if (pos != child->posx) { + // pos changed => redraw + child->posx = pos; + child->redraw = 1; + } + } + else { + if (pos != child->posy) { + // pos changed => redraw + child->posy = pos; + child->redraw = 1; + } + } + //printf("level %d, object %d, pos %d\n", level, i, pos); + + size_by_layout(child, pos, level+1); + + if (panel_horizontal) + pos += child->width + a->paddingx; + else + pos += child->height + a->paddingx; + } +} void refresh (Area *a) @@ -60,17 +191,14 @@ void refresh (Area *a) // don't draw and resize hide objects if (!a->on_screen) return; - //size(a); - size_by_content(a); - size_by_layout(a); - // don't draw transparent objects (without foreground and without background) if (a->redraw) { a->redraw = 0; // force redraw of child GSList *l; for (l = a->list ; l ; l = l->next) - set_redraw(l->data); + ((Area*)l->data)->redraw = 1; +// set_redraw(l->data); //printf("draw area posx %d, width %d\n", a->posx, a->width); draw(a); @@ -87,66 +215,96 @@ void refresh (Area *a) } -void size (Area *a) +int resize_by_layout(void *obj) { + Taskbar *taskbar = (Taskbar*)obj; + Panel *panel = (Panel*)taskbar->area.panel; + Task *tsk; GSList *l; + int task_count, border_width; - if (a->resize) { - a->resize = 0; - // force the resize of childs - for (l = a->list; l ; l = l->next) { - Area *area = (Area*)l->data; - area->resize = 1; - size(area); - } + //printf("resize_taskbar : posx et width des taches\n"); + taskbar->area.redraw = 1; - // resize can generate a redraw - if (a->_resize) - a->_resize(a); - } -} + border_width = taskbar->area.bg->border.width; + if (panel_horizontal) { + int pixel_width, modulo_width=0; + int taskbar_width; -void size_by_content (Area *a) -{ - // children node are resized before its parent - GSList *l; - for (l = a->list; l ; l = l->next) - size_by_content(l->data); - - // calculate current area's size - if (a->resize && a->size_mode == SIZE_BY_CONTENT) { - a->resize = 0; + // new task width for 'desktop' + task_count = g_slist_length(taskbar->area.list); + if (!task_count) pixel_width = panel->g_task.maximum_width; + else { + taskbar_width = taskbar->area.width - (2 * border_width) - (2 * panel->g_taskbar.area.paddingxlr); + if (task_count>1) taskbar_width -= ((task_count-1) * panel->g_taskbar.area.paddingx); - // if 'size' changed then 'resize = 1' on the parent - if (a->_resize) { - a->_resize(a); - ((Area*)a->parent)->resize = 1; + pixel_width = taskbar_width / task_count; + if (pixel_width > panel->g_task.maximum_width) + pixel_width = panel->g_task.maximum_width; + else + modulo_width = taskbar_width % task_count; } - } -} - -void size_by_layout (Area *a) -{ - // parent node is resized before its children - // calculate current area's size - GSList *l; - if (a->resize && a->size_mode == SIZE_BY_LAYOUT) { - a->resize = 0; - - // if 'size' changed then 'resize = 1' on childs with SIZE_BY_LAYOUT - if (a->_resize) { - a->_resize(a); - for (l = a->list; l ; l = l->next) { - if (((Area*)l->data)->size_mode == SIZE_BY_LAYOUT) - ((Area*)l->data)->resize = 1; + taskbar->task_width = pixel_width; + taskbar->task_modulo = modulo_width; + taskbar->text_width = pixel_width - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingx; + + // change pos_x and width for all tasks + for (l = taskbar->area.list; l ; l = l->next) { + tsk = l->data; + if (!tsk->area.on_screen) continue; + set_task_redraw(tsk); // always redraw task, because the background could have changed (taskbar_active_id) + tsk->area.width = pixel_width; +// TODO : move later (when posx is known) +// long value[] = { panel->posx+x, panel->posy, pixel_width, panel->area.height }; +// XChangeProperty (server.dsp, tsk->win, server.atom._NET_WM_ICON_GEOMETRY, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)value, 4); + + if (modulo_width) { + tsk->area.width++; + modulo_width--; } } } + else { + int pixel_height, modulo_height=0; + int taskbar_height; + + // new task width for 'desktop' + task_count = g_slist_length(taskbar->area.list); + if (!task_count) pixel_height = panel->g_task.maximum_height; + else { + taskbar_height = taskbar->area.height - (2 * border_width) - (2 * panel->g_taskbar.area.paddingxlr); + if (task_count>1) taskbar_height -= ((task_count-1) * panel->g_taskbar.area.paddingx); + + pixel_height = taskbar_height / task_count; + if (pixel_height > panel->g_task.maximum_height) + pixel_height = panel->g_task.maximum_height; + else + modulo_height = taskbar_height % task_count; + } - for (l = a->list; l ; l = l->next) - size_by_layout(l->data); + taskbar->task_width = pixel_height; + taskbar->task_modulo = modulo_height; + taskbar->text_width = taskbar->area.width - (2 * panel->g_taskbar.area.paddingy) - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingx; + + // change pos_y and height for all tasks + for (l = taskbar->area.list; l ; l = l->next) { + tsk = l->data; + if (!tsk->area.on_screen) continue; + set_task_redraw(tsk); // always redraw task, because the background could have changed (taskbar_active_id) + tsk->area.height = pixel_height; +// TODO : move later (when posy is known) +// long value[] = { panel->posx, panel->posy+y, panel->area.width, pixel_height }; +// XChangeProperty (server.dsp, tsk->win, server.atom._NET_WM_ICON_GEOMETRY, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)value, 4); + + if (modulo_height) { + tsk->area.height++; + modulo_height--; + } + } + } + return 0; } @@ -159,6 +317,26 @@ void set_redraw (Area *a) set_redraw(l->data); } +void hide(Area *a) +{ + Area *parent = (Area*)a->parent; + + a->on_screen = 0; + parent->resize = 1; + if (panel_horizontal) + a->width = 0; + else + a->height = 0; +} + +void show(Area *a) +{ + Area *parent = (Area*)a->parent; + + a->on_screen = 1; + parent->resize = 1; + a->resize = 1; +} void draw (Area *a) {