]> Dogcows Code - chaz/tint2/blob - src/util/area.c
update my contribution to the company
[chaz/tint2] / src / util / area.c
1 /**************************************************************************
2 *
3 * Tint2 : area
4 *
5 * Copyright (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr) from Omega distribution
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version 2
9 * as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 **************************************************************************/
19
20 #include <X11/Xlib.h>
21 #include <X11/Xutil.h>
22 #include <X11/Xatom.h>
23 #include <X11/extensions/Xrender.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <pango/pangocairo.h>
28
29 #include "area.h"
30 #include "server.h"
31 #include "panel.h"
32
33
34 /************************************************************
35 * !!! This design is experimental and not yet fully implemented !!!!!!!!!!!!!
36 *
37 * DATA ORGANISATION :
38 * Areas in tint2 are similar to widgets in a GUI.
39 * All graphical objects (panel, taskbar, task, systray, clock, ...) 'inherit' an abstract class 'Area'.
40 * This class 'Area' manage the background, border, size, position and padding.
41 * Area is at the begining of each object (&object == &area).
42 *
43 * tint2 define one panel per monitor. And each panel have a tree of Area.
44 * The root of the tree is Panel.Area. And task, clock, systray, taskbar,... are nodes.
45 *
46 * The tree give the localisation of each object :
47 * - tree's root is in the background while tree's leafe are foreground objects
48 * - position of a node/Area depend on the layout : parent's position (posx, posy), size of previous brothers and parent's padding
49 * - size of a node/Area depend on the content (SIZE_BY_CONTENT objects) or on the layout (SIZE_BY_LAYOUT objects)
50 *
51 * DRAWING AND LAYERING ENGINE :
52 * Redrawing an object (like the clock) could come from an 'external event' (date change)
53 * or from a 'layering event' (position change).
54 * The following 'drawing engine' take care of :
55 * - posx/posy of all Area
56 * - 'layering event' propagation between object
57 * 1) browse tree SIZE_BY_CONTENT
58 * - resize SIZE_BY_CONTENT node : children are resized before parent
59 * - if 'size' changed then 'resize = 1' on the parent
60 * 2) browse tree SIZE_BY_LAYOUT and POSITION
61 * - resize SIZE_BY_LAYOUT node : parent is resized before children
62 * - calculate position (posx,posy) : parent is calculated before children
63 * - if 'position' changed then 'redraw = 1'
64 * 3) browse tree REDRAW
65 * - redraw needed objects : parent is drawn before children
66 *
67 * CONFIGURE PANEL'S LAYOUT :
68 * 'panel_items' parameter (in config) define the list and the order of nodes in tree's panel.
69 * 'panel_items = SC' define a panel with just Systray and Clock.
70 * So the tree 'Panel.Area' will have 2 childs (Systray and Clock).
71 *
72 ************************************************************/
73
74 void init_rendering(void *obj, int pos)
75 {
76 Area *a = (Area*)obj;
77
78 // initialize fixed position/size
79 GSList *l;
80 for (l = a->list; l ; l = l->next) {
81 Area *child = ((Area*)l->data);
82 if (panel_horizontal) {
83 child->posy = pos + a->bg->border.width + a->paddingy;
84 child->height = a->height - (2 * (a->bg->border.width + a->paddingy));
85 init_rendering(child, child->posy);
86 }
87 else {
88 child->posx = pos + a->bg->border.width + a->paddingy;
89 child->width = a->width - (2 * (a->bg->border.width + a->paddingy));
90 init_rendering(child, child->posx);
91 }
92 }
93 }
94
95
96 void rendering(void *obj)
97 {
98 Panel *panel = (Panel*)obj;
99
100 size_by_content(&panel->area);
101 size_by_layout(&panel->area, 0, 0);
102
103 refresh(&panel->area);
104 }
105
106
107 void size_by_content (Area *a)
108 {
109 // don't resize hiden objects
110 if (!a->on_screen) return;
111
112 // children node are resized before its parent
113 GSList *l;
114 for (l = a->list; l ; l = l->next)
115 size_by_content(l->data);
116
117 // calculate area's size
118 a->on_changed = 0;
119 if (a->resize && a->size_mode == SIZE_BY_CONTENT) {
120 a->resize = 0;
121
122 if (a->_resize) {
123 if (a->_resize(a)) {
124 // 'size' changed => 'resize = 1' on the parent
125 ((Area*)a->parent)->resize = 1;
126 a->on_changed = 1;
127 }
128 }
129 }
130 }
131
132
133 void size_by_layout (Area *a, int pos, int level)
134 {
135 // don't resize hiden objects
136 if (!a->on_screen) return;
137
138 // parent node is resized before its children
139 // calculate area's size
140 GSList *l;
141 if (a->resize && a->size_mode == SIZE_BY_LAYOUT) {
142 a->resize = 0;
143
144 if (a->_resize) {
145 a->_resize(a);
146 // resize childs with SIZE_BY_LAYOUT
147 for (l = a->list; l ; l = l->next) {
148 Area *child = ((Area*)l->data);
149 if (child->size_mode == SIZE_BY_LAYOUT && child->list)
150 child->resize = 1;
151 }
152 }
153 }
154
155 // update position of childs
156 pos += a->paddingxlr + a->bg->border.width;
157 int i=0;
158 for (l = a->list; l ; l = l->next) {
159 Area *child = ((Area*)l->data);
160 if (!child->on_screen) continue;
161 i++;
162
163 if (panel_horizontal) {
164 if (pos != child->posx) {
165 // pos changed => redraw
166 child->posx = pos;
167 child->on_changed = 1;
168 }
169 }
170 else {
171 if (pos != child->posy) {
172 // pos changed => redraw
173 child->posy = pos;
174 child->on_changed = 1;
175 }
176 }
177
178 //printf("level %d, object %d, pos %d\n", level, i, pos);
179 size_by_layout(child, pos, level+1);
180
181 if (panel_horizontal)
182 pos += child->width + a->paddingx;
183 else
184 pos += child->height + a->paddingx;
185 }
186
187 if (a->on_changed) {
188 // pos/size changed
189 a->redraw = 1;
190 if (a->_on_change_layout)
191 a->_on_change_layout (a);
192 }
193 }
194
195
196 void refresh (Area *a)
197 {
198 // don't draw and resize hide objects
199 if (!a->on_screen) return;
200
201 // don't draw transparent objects (without foreground and without background)
202 if (a->redraw) {
203 a->redraw = 0;
204 // force redraw of child
205 //GSList *l;
206 //for (l = a->list ; l ; l = l->next)
207 //((Area*)l->data)->redraw = 1;
208
209 //printf("draw area posx %d, width %d\n", a->posx, a->width);
210 draw(a);
211 }
212
213 // draw current Area
214 if (a->pix == 0) printf("empty area posx %d, width %d\n", a->posx, a->width);
215 XCopyArea (server.dsp, a->pix, ((Panel *)a->panel)->temp_pmap, server.gc, 0, 0, a->width, a->height, a->posx, a->posy);
216
217 // and then refresh child object
218 GSList *l;
219 for (l = a->list; l ; l = l->next)
220 refresh(l->data);
221 }
222
223
224 int resize_by_layout(void *obj, int maximum_size)
225 {
226 Area *child, *a = (Area*)obj;
227 int size, nb_by_content=0, nb_by_layout=0;
228
229 if (panel_horizontal) {
230 // detect free size for SIZE_BY_LAYOUT's Area
231 size = a->width - (2 * (a->paddingxlr + a->bg->border.width));
232 GSList *l;
233 for (l = a->list ; l ; l = l->next) {
234 child = (Area*)l->data;
235 if (child->on_screen && child->size_mode == SIZE_BY_CONTENT) {
236 size -= child->width;
237 nb_by_content++;
238 }
239 if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT)
240 nb_by_layout++;
241 }
242 if (nb_by_content+nb_by_layout)
243 size -= ((nb_by_content+nb_by_layout-1) * a->paddingx);
244 //printf("resize_panel : size_panel %d, size_layout %d\n", panel->area.width, size);
245
246 int width=0, modulo=0, old_width;
247 if (nb_by_layout) {
248 width = size / nb_by_layout;
249 modulo = size % nb_by_layout;
250 if (width > maximum_size && maximum_size != 0) {
251 width = maximum_size;
252 modulo = 0;
253 }
254 }
255
256 // resize SIZE_BY_LAYOUT objects
257 for (l = a->list ; l ; l = l->next) {
258 child = (Area*)l->data;
259 if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT) {
260 old_width = child->width;
261 child->width = width;
262 if (modulo) {
263 child->width++;
264 modulo--;
265 }
266 if (child->width != old_width)
267 child->on_changed = 1;
268 }
269 }
270 }
271 else {
272 // detect free size for SIZE_BY_LAYOUT's Area
273 size = a->height - (2 * (a->paddingxlr + a->bg->border.width));
274 GSList *l;
275 for (l = a->list ; l ; l = l->next) {
276 child = (Area*)l->data;
277 if (child->on_screen && child->size_mode == SIZE_BY_CONTENT) {
278 size -= child->height;
279 nb_by_content++;
280 }
281 if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT)
282 nb_by_layout++;
283 }
284 if (nb_by_content+nb_by_layout)
285 size -= ((nb_by_content+nb_by_layout-1) * a->paddingx);
286
287 int height=0, modulo=0, old_height;
288 if (nb_by_layout) {
289 height = size / nb_by_layout;
290 modulo = size % nb_by_layout;
291 if (height > maximum_size && maximum_size != 0) {
292 height = maximum_size;
293 modulo = 0;
294 }
295 }
296
297 // resize SIZE_BY_LAYOUT objects
298 for (l = a->list ; l ; l = l->next) {
299 child = (Area*)l->data;
300 if (child->on_screen && child->size_mode == SIZE_BY_LAYOUT) {
301 old_height = child->height;
302 child->height = height;
303 if (modulo) {
304 child->height++;
305 modulo--;
306 }
307 if (child->height != old_height)
308 child->on_changed = 1;
309 }
310 }
311 }
312 return 0;
313 }
314
315
316 void set_redraw (Area *a)
317 {
318 a->redraw = 1;
319
320 GSList *l;
321 for (l = a->list ; l ; l = l->next)
322 set_redraw(l->data);
323 }
324
325 void hide(Area *a)
326 {
327 Area *parent = (Area*)a->parent;
328
329 a->on_screen = 0;
330 parent->resize = 1;
331 if (panel_horizontal)
332 a->width = 0;
333 else
334 a->height = 0;
335 }
336
337 void show(Area *a)
338 {
339 Area *parent = (Area*)a->parent;
340
341 a->on_screen = 1;
342 parent->resize = 1;
343 a->resize = 1;
344 }
345
346 void draw (Area *a)
347 {
348 if (a->pix) XFreePixmap (server.dsp, a->pix);
349 a->pix = XCreatePixmap (server.dsp, server.root_win, a->width, a->height, server.depth);
350
351 // add layer of root pixmap (or clear pixmap if real_transparency==true)
352 if (server.real_transparency)
353 clear_pixmap(a->pix, 0 ,0, a->width, a->height);
354 XCopyArea (server.dsp, ((Panel *)a->panel)->temp_pmap, a->pix, server.gc, a->posx, a->posy, a->width, a->height, 0, 0);
355
356 cairo_surface_t *cs;
357 cairo_t *c;
358
359 cs = cairo_xlib_surface_create (server.dsp, a->pix, server.visual, a->width, a->height);
360 c = cairo_create (cs);
361
362 draw_background (a, c);
363
364 if (a->_draw_foreground)
365 a->_draw_foreground(a, c);
366
367 cairo_destroy (c);
368 cairo_surface_destroy (cs);
369 }
370
371
372 void draw_background (Area *a, cairo_t *c)
373 {
374 if (a->bg->back.alpha > 0.0) {
375 //printf(" draw_background (%d %d) RGBA (%lf, %lf, %lf, %lf)\n", a->posx, a->posy, pix->back.color[0], pix->back.color[1], pix->back.color[2], pix->back.alpha);
376 draw_rect(c, a->bg->border.width, a->bg->border.width, a->width-(2.0 * a->bg->border.width), a->height-(2.0*a->bg->border.width), a->bg->border.rounded - a->bg->border.width/1.571);
377 cairo_set_source_rgba(c, a->bg->back.color[0], a->bg->back.color[1], a->bg->back.color[2], a->bg->back.alpha);
378 cairo_fill(c);
379 }
380
381 if (a->bg->border.width > 0 && a->bg->border.alpha > 0.0) {
382 cairo_set_line_width (c, a->bg->border.width);
383
384 // draw border inside (x, y, width, height)
385 draw_rect(c, a->bg->border.width/2.0, a->bg->border.width/2.0, a->width - a->bg->border.width, a->height - a->bg->border.width, a->bg->border.rounded);
386 /*
387 // convert : radian = degre * M_PI/180
388 // definir le degrade dans un carre de (0,0) (100,100)
389 // ensuite ce degrade est extrapoler selon le ratio width/height
390 // dans repere (0, 0) (100, 100)
391 double X0, Y0, X1, Y1, degre;
392 // x = X * (a->width / 100), y = Y * (a->height / 100)
393 double x0, y0, x1, y1;
394 X0 = 0;
395 Y0 = 100;
396 X1 = 100;
397 Y1 = 0;
398 degre = 45;
399 // et ensuite faire la changement d'unite du repere
400 // car ce qui doit reste inchangee est les traits et pas la direction
401
402 // il faut d'abord appliquer une rotation de 90 (et -180 si l'angle est superieur a 180)
403 // ceci peut etre applique une fois pour toute au depart
404 // ensuite calculer l'angle dans le nouveau repare
405 // puis faire une rotation de 90
406 x0 = X0 * ((double)a->width / 100);
407 x1 = X1 * ((double)a->width / 100);
408 y0 = Y0 * ((double)a->height / 100);
409 y1 = Y1 * ((double)a->height / 100);
410
411 x0 = X0 * ((double)a->height / 100);
412 x1 = X1 * ((double)a->height / 100);
413 y0 = Y0 * ((double)a->width / 100);
414 y1 = Y1 * ((double)a->width / 100);
415
416 cairo_pattern_t *linpat;
417 linpat = cairo_pattern_create_linear (x0, y0, x1, y1);
418 cairo_pattern_add_color_stop_rgba (linpat, 0, a->border.color[0], a->border.color[1], a->border.color[2], a->border.alpha);
419 cairo_pattern_add_color_stop_rgba (linpat, 1, a->border.color[0], a->border.color[1], a->border.color[2], 0);
420 cairo_set_source (c, linpat);
421 */
422 cairo_set_source_rgba (c, a->bg->border.color[0], a->bg->border.color[1], a->bg->border.color[2], a->bg->border.alpha);
423
424 cairo_stroke (c);
425 //cairo_pattern_destroy (linpat);
426 }
427 }
428
429
430 void remove_area (Area *a)
431 {
432 Area *parent = (Area*)a->parent;
433
434 parent->list = g_slist_remove(parent->list, a);
435 set_redraw (parent);
436
437 }
438
439
440 void add_area (Area *a)
441 {
442 Area *parent = (Area*)a->parent;
443
444 parent->list = g_slist_remove(parent->list, a);
445 set_redraw (parent);
446
447 }
448
449
450 void free_area (Area *a)
451 {
452 GSList *l0;
453 for (l0 = a->list; l0 ; l0 = l0->next)
454 free_area (l0->data);
455
456 if (a->list) {
457 g_slist_free(a->list);
458 a->list = 0;
459 }
460 if (a->pix) {
461 XFreePixmap (server.dsp, a->pix);
462 a->pix = 0;
463 }
464 }
465
466
467 void draw_rect(cairo_t *c, double x, double y, double w, double h, double r)
468 {
469 if (r > 0.0) {
470 double c1 = 0.55228475 * r;
471
472 cairo_move_to(c, x+r, y);
473 cairo_rel_line_to(c, w-2*r, 0);
474 cairo_rel_curve_to(c, c1, 0.0, r, c1, r, r);
475 cairo_rel_line_to(c, 0, h-2*r);
476 cairo_rel_curve_to(c, 0.0, c1, c1-r, r, -r, r);
477 cairo_rel_line_to (c, -w +2*r, 0);
478 cairo_rel_curve_to (c, -c1, 0, -r, -c1, -r, -r);
479 cairo_rel_line_to (c, 0, -h + 2 * r);
480 cairo_rel_curve_to (c, 0, -c1, r - c1, -r, r, -r);
481 }
482 else
483 cairo_rectangle(c, x, y, w, h);
484 }
485
486
487 void clear_pixmap(Pixmap p, int x, int y, int w, int h)
488 {
489 Picture pict = XRenderCreatePicture(server.dsp, p, XRenderFindVisualFormat(server.dsp, server.visual), 0, 0);
490 XRenderColor col = { .red=0, .green=0, .blue=0, .alpha=0 };
491 XRenderFillRectangle(server.dsp, PictOpSrc, pict, &col, x, y, w, h);
492 XRenderFreePicture(server.dsp, pict);
493 }
This page took 0.06585 seconds and 5 git commands to generate.