Mercurial > pidgin
annotate finch/libgnt/gntbox.c @ 18045:08e93462f189
Update the irssi WM to allow tiling the conversation windows.
author | Sadrul Habib Chowdhury <imadil@gmail.com> |
---|---|
date | Wed, 06 Jun 2007 14:34:58 +0000 |
parents | 05d7fe2320a9 |
children | 1cedd520cd18 |
rev | line source |
---|---|
15817 | 1 #include "gntbox.h" |
2 #include "gntutils.h" | |
3 | |
4 #include <string.h> | |
5 | |
6 enum | |
7 { | |
8 SIGS = 1, | |
9 }; | |
10 | |
11 static GntWidgetClass *parent_class = NULL; | |
12 | |
13 static GntWidget * find_focusable_widget(GntBox *box); | |
14 | |
15 static void | |
16 add_to_focus(gpointer value, gpointer data) | |
17 { | |
18 GntBox *box = GNT_BOX(data); | |
19 GntWidget *w = GNT_WIDGET(value); | |
20 | |
21 if (GNT_IS_BOX(w)) | |
22 g_list_foreach(GNT_BOX(w)->list, add_to_focus, box); | |
23 else if (GNT_WIDGET_IS_FLAG_SET(w, GNT_WIDGET_CAN_TAKE_FOCUS)) | |
24 box->focus = g_list_append(box->focus, w); | |
25 } | |
26 | |
27 static void | |
28 get_title_thingies(GntBox *box, char *title, int *p, int *r) | |
29 { | |
30 GntWidget *widget = GNT_WIDGET(box); | |
31 int len; | |
32 char *end = (char*)gnt_util_onscreen_width_to_pointer(title, widget->priv.width - 4, &len); | |
33 | |
34 if (p) | |
35 *p = (widget->priv.width - len) / 2; | |
36 if (r) | |
37 *r = (widget->priv.width + len) / 2; | |
38 *end = '\0'; | |
39 } | |
40 | |
41 static void | |
42 gnt_box_draw(GntWidget *widget) | |
43 { | |
44 GntBox *box = GNT_BOX(widget); | |
45 | |
46 if (box->focus == NULL && widget->parent == NULL) | |
47 g_list_foreach(box->list, add_to_focus, box); | |
48 | |
49 g_list_foreach(box->list, (GFunc)gnt_widget_draw, NULL); | |
50 | |
51 gnt_box_sync_children(box); | |
52 | |
53 if (box->title && !GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_NO_BORDER)) | |
54 { | |
55 int pos, right; | |
56 char *title = g_strdup(box->title); | |
57 | |
58 get_title_thingies(box, title, &pos, &right); | |
59 | |
60 if (gnt_widget_has_focus(widget)) | |
61 wbkgdset(widget->window, '\0' | COLOR_PAIR(GNT_COLOR_TITLE)); | |
62 else | |
63 wbkgdset(widget->window, '\0' | COLOR_PAIR(GNT_COLOR_TITLE_D)); | |
64 mvwaddch(widget->window, 0, pos-1, ACS_RTEE | COLOR_PAIR(GNT_COLOR_NORMAL)); | |
65 mvwaddstr(widget->window, 0, pos, title); | |
66 mvwaddch(widget->window, 0, right, ACS_LTEE | COLOR_PAIR(GNT_COLOR_NORMAL)); | |
67 g_free(title); | |
68 } | |
69 | |
70 GNTDEBUG; | |
71 } | |
72 | |
73 static void | |
74 reposition_children(GntWidget *widget) | |
75 { | |
76 GList *iter; | |
77 GntBox *box = GNT_BOX(widget); | |
78 int w, h, curx, cury, max; | |
79 gboolean has_border = FALSE; | |
80 | |
81 w = h = 0; | |
82 max = 0; | |
83 curx = widget->priv.x; | |
84 cury = widget->priv.y; | |
85 if (!(GNT_WIDGET_FLAGS(widget) & GNT_WIDGET_NO_BORDER)) | |
86 { | |
87 has_border = TRUE; | |
88 curx += 1; | |
89 cury += 1; | |
90 } | |
91 | |
92 for (iter = box->list; iter; iter = iter->next) | |
93 { | |
94 if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(iter->data), GNT_WIDGET_INVISIBLE)) | |
95 continue; | |
96 gnt_widget_set_position(GNT_WIDGET(iter->data), curx, cury); | |
97 gnt_widget_get_size(GNT_WIDGET(iter->data), &w, &h); | |
98 if (box->vertical) | |
99 { | |
100 if (h) | |
101 { | |
102 cury += h + box->pad; | |
103 if (max < w) | |
104 max = w; | |
105 } | |
106 } | |
107 else | |
108 { | |
109 if (w) | |
110 { | |
111 curx += w + box->pad; | |
112 if (max < h) | |
113 max = h; | |
114 } | |
115 } | |
116 } | |
117 | |
118 if (has_border) | |
119 { | |
120 curx += 1; | |
121 cury += 1; | |
122 max += 2; | |
123 } | |
124 | |
125 if (box->list) | |
126 { | |
127 if (box->vertical) | |
128 cury -= box->pad; | |
129 else | |
130 curx -= box->pad; | |
131 } | |
132 | |
133 if (box->vertical) | |
134 { | |
135 widget->priv.width = max; | |
136 widget->priv.height = cury - widget->priv.y; | |
137 } | |
138 else | |
139 { | |
140 widget->priv.width = curx - widget->priv.x; | |
141 widget->priv.height = max; | |
142 } | |
143 } | |
144 | |
145 static void | |
146 gnt_box_set_position(GntWidget *widget, int x, int y) | |
147 { | |
148 GList *iter; | |
149 int changex, changey; | |
150 | |
151 changex = widget->priv.x - x; | |
152 changey = widget->priv.y - y; | |
153 | |
154 for (iter = GNT_BOX(widget)->list; iter; iter = iter->next) | |
155 { | |
156 GntWidget *w = GNT_WIDGET(iter->data); | |
157 gnt_widget_set_position(w, w->priv.x - changex, | |
158 w->priv.y - changey); | |
159 } | |
160 } | |
161 | |
162 static void | |
163 gnt_box_size_request(GntWidget *widget) | |
164 { | |
165 GntBox *box = GNT_BOX(widget); | |
166 GList *iter; | |
167 int maxw = 0, maxh = 0; | |
168 | |
169 g_list_foreach(box->list, (GFunc)gnt_widget_size_request, NULL); | |
170 | |
171 for (iter = box->list; iter; iter = iter->next) | |
172 { | |
173 int w, h; | |
174 gnt_widget_get_size(GNT_WIDGET(iter->data), &w, &h); | |
175 if (maxh < h) | |
176 maxh = h; | |
177 if (maxw < w) | |
178 maxw = w; | |
179 } | |
180 | |
181 for (iter = box->list; iter; iter = iter->next) | |
182 { | |
183 int w, h; | |
184 GntWidget *wid = GNT_WIDGET(iter->data); | |
185 | |
186 gnt_widget_get_size(wid, &w, &h); | |
187 | |
188 if (box->homogeneous) | |
189 { | |
190 if (box->vertical) | |
191 h = maxh; | |
192 else | |
193 w = maxw; | |
194 } | |
195 if (box->fill) | |
196 { | |
197 if (box->vertical) | |
198 w = maxw; | |
199 else | |
200 h = maxh; | |
201 } | |
202 | |
203 gnt_widget_set_size(wid, w, h); | |
204 } | |
205 | |
206 reposition_children(widget); | |
207 } | |
208 | |
209 static void | |
210 gnt_box_map(GntWidget *widget) | |
211 { | |
212 if (widget->priv.width == 0 || widget->priv.height == 0) | |
213 { | |
214 gnt_widget_size_request(widget); | |
215 find_focusable_widget(GNT_BOX(widget)); | |
216 } | |
217 GNTDEBUG; | |
218 } | |
219 | |
220 /* Ensures that the current widget can take focus */ | |
221 static GntWidget * | |
222 find_focusable_widget(GntBox *box) | |
223 { | |
224 /* XXX: Make sure the widget is visible? */ | |
225 if (box->focus == NULL && GNT_WIDGET(box)->parent == NULL) | |
226 g_list_foreach(box->list, add_to_focus, box); | |
227 | |
228 if (box->active == NULL && box->focus) | |
229 box->active = box->focus->data; | |
230 | |
231 return box->active; | |
232 } | |
233 | |
234 static void | |
235 find_next_focus(GntBox *box) | |
236 { | |
237 gpointer last = box->active; | |
238 do | |
239 { | |
240 GList *iter = g_list_find(box->focus, box->active); | |
241 if (iter && iter->next) | |
242 box->active = iter->next->data; | |
243 else if (box->focus) | |
244 box->active = box->focus->data; | |
245 if (!GNT_WIDGET_IS_FLAG_SET(box->active, GNT_WIDGET_INVISIBLE)) | |
246 break; | |
247 } while (box->active != last); | |
248 } | |
249 | |
250 static void | |
251 find_prev_focus(GntBox *box) | |
252 { | |
253 gpointer last = box->active; | |
254 | |
255 if (!box->focus) | |
256 return; | |
257 | |
258 do | |
259 { | |
260 GList *iter = g_list_find(box->focus, box->active); | |
261 if (!iter) | |
262 box->active = box->focus->data; | |
263 else if (!iter->prev) | |
264 box->active = g_list_last(box->focus)->data; | |
265 else | |
266 box->active = iter->prev->data; | |
267 if (!GNT_WIDGET_IS_FLAG_SET(box->active, GNT_WIDGET_INVISIBLE)) | |
268 break; | |
269 } while (box->active != last); | |
270 } | |
271 | |
272 static gboolean | |
273 gnt_box_key_pressed(GntWidget *widget, const char *text) | |
274 { | |
275 GntBox *box = GNT_BOX(widget); | |
276 GntWidget *now; | |
277 | |
278 if (box->active == NULL && !find_focusable_widget(box)) | |
279 return FALSE; | |
280 | |
281 if (gnt_widget_key_pressed(box->active, text)) | |
282 return TRUE; | |
283 | |
284 now = box->active; | |
285 | |
286 if (text[0] == 27) | |
287 { | |
288 if (strcmp(text, GNT_KEY_LEFT) == 0) | |
289 { | |
290 find_prev_focus(box); | |
291 } | |
292 else if (strcmp(text, GNT_KEY_RIGHT) == 0) | |
293 { | |
294 find_next_focus(box); | |
295 } | |
18000
05d7fe2320a9
(16:39:44) rekkanoryo: i have a feature request
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15945
diff
changeset
|
296 else if (strcmp(text, GNT_KEY_BACK_TAB) == 0) |
05d7fe2320a9
(16:39:44) rekkanoryo: i have a feature request
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15945
diff
changeset
|
297 { |
05d7fe2320a9
(16:39:44) rekkanoryo: i have a feature request
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15945
diff
changeset
|
298 find_prev_focus(box); |
05d7fe2320a9
(16:39:44) rekkanoryo: i have a feature request
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15945
diff
changeset
|
299 } |
15817 | 300 } |
301 else if (text[0] == '\t') | |
302 { | |
303 find_next_focus(box); | |
304 } | |
305 | |
306 if (now && now != box->active) | |
307 { | |
308 gnt_widget_set_focus(now, FALSE); | |
309 gnt_widget_set_focus(box->active, TRUE); | |
310 return TRUE; | |
311 } | |
312 | |
313 return FALSE; | |
314 } | |
315 | |
316 static void | |
317 gnt_box_lost_focus(GntWidget *widget) | |
318 { | |
319 GntWidget *w = GNT_BOX(widget)->active; | |
320 if (w) | |
321 gnt_widget_set_focus(w, FALSE); | |
322 gnt_widget_draw(widget); | |
323 } | |
324 | |
325 static void | |
326 gnt_box_gained_focus(GntWidget *widget) | |
327 { | |
328 GntWidget *w = GNT_BOX(widget)->active; | |
329 if (w) | |
330 gnt_widget_set_focus(w, TRUE); | |
331 gnt_widget_draw(widget); | |
332 } | |
333 | |
334 static void | |
335 gnt_box_destroy(GntWidget *w) | |
336 { | |
337 GntBox *box = GNT_BOX(w); | |
338 | |
339 gnt_box_remove_all(box); | |
340 gnt_screen_release(w); | |
341 } | |
342 | |
343 static void | |
344 gnt_box_expose(GntWidget *widget, int x, int y, int width, int height) | |
345 { | |
346 WINDOW *win = newwin(height, width, widget->priv.y + y, widget->priv.x + x); | |
347 copywin(widget->window, win, y, x, 0, 0, height - 1, width - 1, FALSE); | |
348 wrefresh(win); | |
349 delwin(win); | |
350 } | |
351 | |
352 static gboolean | |
353 gnt_box_confirm_size(GntWidget *widget, int width, int height) | |
354 { | |
355 GList *iter; | |
356 GntBox *box = GNT_BOX(widget); | |
357 int wchange, hchange; | |
358 | |
359 if (!box->list) | |
360 return TRUE; | |
361 | |
362 wchange = widget->priv.width - width; | |
363 hchange = widget->priv.height - height; | |
364 | |
365 if (wchange == 0 && hchange == 0) | |
366 return TRUE; /* Quit playing games */ | |
367 | |
368 /* XXX: Right now, I am trying to just apply all the changes to | |
369 * just one widget. It should be possible to distribute the | |
370 * changes to all the widgets in the box. */ | |
371 for (iter = box->list; iter; iter = iter->next) | |
372 { | |
373 GntWidget *wid = iter->data; | |
374 int w, h; | |
375 | |
376 gnt_widget_get_size(wid, &w, &h); | |
377 | |
378 if (gnt_widget_confirm_size(wid, w - wchange, h - hchange)) | |
379 { | |
380 GList *i; | |
381 | |
382 for (i = box->list; i; i = i->next) | |
383 { | |
384 int tw, th; | |
385 if (i == iter) continue; | |
386 gnt_widget_get_size(GNT_WIDGET(i->data), &tw, &th); | |
387 if (box->vertical) | |
388 { | |
15945
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
389 if (!gnt_widget_confirm_size(i->data, tw - wchange, th)) { |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
390 /* If we are decreasing the size and the widget is going |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
391 * to be too large to fit into the box, then do not allow |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
392 * resizing. */ |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
393 if (wchange > 0 && tw >= widget->priv.width) |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
394 return FALSE; |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
395 } |
15817 | 396 } |
397 else | |
398 { | |
15945
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
399 if (!gnt_widget_confirm_size(i->data, tw, th - hchange)) { |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
400 if (hchange > 0 && th >= widget->priv.height) |
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
401 return FALSE; |
15817 | 402 return FALSE; |
15945
92fa7d6e75b0
A few more fixes for resizing.
Sadrul Habib Chowdhury <imadil@gmail.com>
parents:
15817
diff
changeset
|
403 } |
15817 | 404 } |
405 } | |
406 #if 0 | |
407 gnt_widget_set_size(wid, w - wchange, h - hchange); | |
408 if (box->vertical) | |
409 hchange = 0; | |
410 else | |
411 wchange = 0; | |
412 | |
413 for (i = box->list; i; i = i->next) | |
414 { | |
415 int tw, th; | |
416 if (i == iter) continue; | |
417 gnt_widget_get_size(GNT_WIDGET(i->data), &tw, &th); | |
418 gnt_widget_set_size(i->data, tw - wchange, th - hchange); | |
419 } | |
420 #endif | |
421 g_object_set_data(G_OBJECT(box), "size-queued", wid); | |
422 return TRUE; | |
423 } | |
424 } | |
425 | |
426 return FALSE; | |
427 } | |
428 | |
429 static void | |
430 gnt_box_size_changed(GntWidget *widget, int oldw, int oldh) | |
431 { | |
432 int wchange, hchange; | |
433 GList *i; | |
434 GntBox *box = GNT_BOX(widget); | |
435 GntWidget *wid; | |
436 int tw, th; | |
437 | |
438 wchange = widget->priv.width - oldw; | |
439 hchange = widget->priv.height - oldh; | |
440 | |
441 wid = g_object_get_data(G_OBJECT(box), "size-queued"); | |
442 if (wid) | |
443 { | |
444 gnt_widget_get_size(wid, &tw, &th); | |
445 gnt_widget_set_size(wid, tw + wchange, th + hchange); | |
446 g_object_set_data(G_OBJECT(box), "size-queued", NULL); | |
447 } | |
448 | |
449 if (box->vertical) | |
450 hchange = 0; | |
451 else | |
452 wchange = 0; | |
453 | |
454 for (i = box->list; i; i = i->next) | |
455 { | |
456 if (wid != i->data) | |
457 { | |
458 gnt_widget_get_size(GNT_WIDGET(i->data), &tw, &th); | |
459 gnt_widget_set_size(i->data, tw + wchange, th + hchange); | |
460 } | |
461 } | |
462 | |
463 reposition_children(widget); | |
464 } | |
465 | |
466 static gboolean | |
467 gnt_box_clicked(GntWidget *widget, GntMouseEvent event, int cx, int cy) | |
468 { | |
469 GList *iter; | |
470 for (iter = GNT_BOX(widget)->list; iter; iter = iter->next) { | |
471 int x, y, w, h; | |
472 GntWidget *wid = iter->data; | |
473 | |
474 gnt_widget_get_position(wid, &x, &y); | |
475 gnt_widget_get_size(wid, &w, &h); | |
476 | |
477 if (cx >= x && cx < x + w && cy >= y && cy < y + h) { | |
478 if (event <= GNT_MIDDLE_MOUSE_DOWN && | |
479 GNT_WIDGET_IS_FLAG_SET(wid, GNT_WIDGET_CAN_TAKE_FOCUS)) { | |
480 while (widget->parent) | |
481 widget = widget->parent; | |
482 gnt_box_give_focus_to_child(GNT_BOX(widget), wid); | |
483 } | |
484 return gnt_widget_clicked(wid, event, cx, cy); | |
485 } | |
486 } | |
487 return FALSE; | |
488 } | |
489 | |
490 static void | |
491 gnt_box_class_init(GntBoxClass *klass) | |
492 { | |
493 parent_class = GNT_WIDGET_CLASS(klass); | |
494 parent_class->destroy = gnt_box_destroy; | |
495 parent_class->draw = gnt_box_draw; | |
496 parent_class->expose = gnt_box_expose; | |
497 parent_class->map = gnt_box_map; | |
498 parent_class->size_request = gnt_box_size_request; | |
499 parent_class->set_position = gnt_box_set_position; | |
500 parent_class->key_pressed = gnt_box_key_pressed; | |
501 parent_class->clicked = gnt_box_clicked; | |
502 parent_class->lost_focus = gnt_box_lost_focus; | |
503 parent_class->gained_focus = gnt_box_gained_focus; | |
504 parent_class->confirm_size = gnt_box_confirm_size; | |
505 parent_class->size_changed = gnt_box_size_changed; | |
506 | |
507 GNTDEBUG; | |
508 } | |
509 | |
510 static void | |
511 gnt_box_init(GTypeInstance *instance, gpointer class) | |
512 { | |
513 GntWidget *widget = GNT_WIDGET(instance); | |
514 GntBox *box = GNT_BOX(widget); | |
515 /* Initially make both the height and width resizable. | |
516 * Update the flags as necessary when widgets are added to it. */ | |
517 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_GROW_X | GNT_WIDGET_GROW_Y); | |
518 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_CAN_TAKE_FOCUS); | |
519 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_NO_BORDER | GNT_WIDGET_NO_SHADOW); | |
520 box->pad = 1; | |
521 box->fill = TRUE; | |
522 GNTDEBUG; | |
523 } | |
524 | |
525 /****************************************************************************** | |
526 * GntBox API | |
527 *****************************************************************************/ | |
528 GType | |
529 gnt_box_get_gtype(void) | |
530 { | |
531 static GType type = 0; | |
532 | |
533 if(type == 0) | |
534 { | |
535 static const GTypeInfo info = { | |
536 sizeof(GntBoxClass), | |
537 NULL, /* base_init */ | |
538 NULL, /* base_finalize */ | |
539 (GClassInitFunc)gnt_box_class_init, | |
540 NULL, /* class_finalize */ | |
541 NULL, /* class_data */ | |
542 sizeof(GntBox), | |
543 0, /* n_preallocs */ | |
544 gnt_box_init, /* instance_init */ | |
545 NULL /* value_table */ | |
546 }; | |
547 | |
548 type = g_type_register_static(GNT_TYPE_WIDGET, | |
549 "GntBox", | |
550 &info, 0); | |
551 } | |
552 | |
553 return type; | |
554 } | |
555 | |
556 GntWidget *gnt_box_new(gboolean homo, gboolean vert) | |
557 { | |
558 GntWidget *widget = g_object_new(GNT_TYPE_BOX, NULL); | |
559 GntBox *box = GNT_BOX(widget); | |
560 | |
561 box->homogeneous = homo; | |
562 box->vertical = vert; | |
563 box->alignment = vert ? GNT_ALIGN_LEFT : GNT_ALIGN_MID; | |
564 | |
565 return widget; | |
566 } | |
567 | |
568 void gnt_box_add_widget(GntBox *b, GntWidget *widget) | |
569 { | |
570 b->list = g_list_append(b->list, widget); | |
571 widget->parent = GNT_WIDGET(b); | |
572 } | |
573 | |
574 void gnt_box_set_title(GntBox *b, const char *title) | |
575 { | |
576 char *prev = b->title; | |
577 GntWidget *w = GNT_WIDGET(b); | |
578 b->title = g_strdup(title); | |
579 if (w->window && !GNT_WIDGET_IS_FLAG_SET(w, GNT_WIDGET_NO_BORDER)) { | |
580 /* Erase the old title */ | |
581 int pos, right; | |
582 get_title_thingies(b, prev, &pos, &right); | |
583 mvwhline(w->window, 0, pos - 1, ACS_HLINE | COLOR_PAIR(GNT_COLOR_NORMAL), | |
584 right - pos + 2); | |
585 g_free(prev); | |
586 } | |
587 } | |
588 | |
589 void gnt_box_set_pad(GntBox *box, int pad) | |
590 { | |
591 box->pad = pad; | |
592 /* XXX: Perhaps redraw if already showing? */ | |
593 } | |
594 | |
595 void gnt_box_set_toplevel(GntBox *box, gboolean set) | |
596 { | |
597 GntWidget *widget = GNT_WIDGET(box); | |
598 if (set) | |
599 { | |
600 GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_NO_BORDER | GNT_WIDGET_NO_SHADOW); | |
601 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_CAN_TAKE_FOCUS); | |
602 } | |
603 else | |
604 { | |
605 GNT_WIDGET_SET_FLAGS(widget, GNT_WIDGET_NO_BORDER | GNT_WIDGET_NO_SHADOW); | |
606 GNT_WIDGET_UNSET_FLAGS(widget, GNT_WIDGET_CAN_TAKE_FOCUS); | |
607 } | |
608 } | |
609 | |
610 void gnt_box_sync_children(GntBox *box) | |
611 { | |
612 GList *iter; | |
613 GntWidget *widget = GNT_WIDGET(box); | |
614 int pos = 1; | |
615 | |
616 if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_NO_BORDER)) | |
617 pos = 0; | |
618 | |
619 for (iter = box->list; iter; iter = iter->next) | |
620 { | |
621 GntWidget *w = GNT_WIDGET(iter->data); | |
622 int height, width; | |
623 int x, y; | |
624 | |
625 if (GNT_WIDGET_IS_FLAG_SET(w, GNT_WIDGET_INVISIBLE)) | |
626 continue; | |
627 | |
628 if (GNT_IS_BOX(w)) | |
629 gnt_box_sync_children(GNT_BOX(w)); | |
630 | |
631 gnt_widget_get_size(w, &width, &height); | |
632 | |
633 x = w->priv.x - widget->priv.x; | |
634 y = w->priv.y - widget->priv.y; | |
635 | |
636 if (box->vertical) | |
637 { | |
638 x = pos; | |
639 if (box->alignment == GNT_ALIGN_RIGHT) | |
640 x += widget->priv.width - width; | |
641 else if (box->alignment == GNT_ALIGN_MID) | |
642 x += (widget->priv.width - width)/2; | |
643 if (x + width > widget->priv.width - pos) | |
644 x -= x + width - (widget->priv.width - pos); | |
645 } | |
646 else | |
647 { | |
648 y = pos; | |
649 if (box->alignment == GNT_ALIGN_BOTTOM) | |
650 y += widget->priv.height - height; | |
651 else if (box->alignment == GNT_ALIGN_MID) | |
652 y += (widget->priv.height - height)/2; | |
653 if (y + height >= widget->priv.height - pos) | |
654 y = widget->priv.height - height - pos; | |
655 } | |
656 | |
657 copywin(w->window, widget->window, 0, 0, | |
658 y, x, y + height - 1, x + width - 1, FALSE); | |
659 gnt_widget_set_position(w, x + widget->priv.x, y + widget->priv.y); | |
660 } | |
661 } | |
662 | |
663 void gnt_box_set_alignment(GntBox *box, GntAlignment alignment) | |
664 { | |
665 box->alignment = alignment; | |
666 } | |
667 | |
668 void gnt_box_remove(GntBox *box, GntWidget *widget) | |
669 { | |
670 box->list = g_list_remove(box->list, widget); | |
671 if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_CAN_TAKE_FOCUS) | |
672 && GNT_WIDGET(box)->parent == NULL && box->focus) | |
673 { | |
674 if (widget == box->active) | |
675 { | |
676 find_next_focus(box); | |
677 if (box->active == widget) /* There's only one widget */ | |
678 box->active = NULL; | |
679 } | |
680 box->focus = g_list_remove(box->focus, widget); | |
681 } | |
682 | |
683 if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(box), GNT_WIDGET_MAPPED)) | |
684 gnt_widget_draw(GNT_WIDGET(box)); | |
685 } | |
686 | |
687 void gnt_box_remove_all(GntBox *box) | |
688 { | |
689 g_list_foreach(box->list, (GFunc)gnt_widget_destroy, NULL); | |
690 g_list_free(box->list); | |
691 g_list_free(box->focus); | |
692 box->list = NULL; | |
693 box->focus = NULL; | |
694 GNT_WIDGET(box)->priv.width = 0; | |
695 GNT_WIDGET(box)->priv.height = 0; | |
696 } | |
697 | |
698 void gnt_box_readjust(GntBox *box) | |
699 { | |
700 GList *iter; | |
701 GntWidget *wid; | |
702 int width, height; | |
703 | |
704 if (GNT_WIDGET(box)->parent != NULL) | |
705 return; | |
706 | |
707 for (iter = box->list; iter; iter = iter->next) | |
708 { | |
709 GntWidget *w = iter->data; | |
710 if (GNT_IS_BOX(w)) | |
711 gnt_box_readjust(GNT_BOX(w)); | |
712 else | |
713 { | |
714 GNT_WIDGET_UNSET_FLAGS(w, GNT_WIDGET_MAPPED); | |
715 w->priv.width = 0; | |
716 w->priv.height = 0; | |
717 } | |
718 } | |
719 | |
720 wid = GNT_WIDGET(box); | |
721 GNT_WIDGET_UNSET_FLAGS(wid, GNT_WIDGET_MAPPED); | |
722 wid->priv.width = 0; | |
723 wid->priv.height = 0; | |
724 | |
725 if (wid->parent == NULL) | |
726 { | |
727 g_list_free(box->focus); | |
728 box->focus = NULL; | |
729 box->active = NULL; | |
730 gnt_widget_size_request(wid); | |
731 gnt_widget_get_size(wid, &width, &height); | |
732 gnt_screen_resize_widget(wid, width, height); | |
733 find_focusable_widget(box); | |
734 } | |
735 } | |
736 | |
737 void gnt_box_set_fill(GntBox *box, gboolean fill) | |
738 { | |
739 box->fill = fill; | |
740 } | |
741 | |
742 void gnt_box_move_focus(GntBox *box, int dir) | |
743 { | |
744 GntWidget *now; | |
745 | |
746 if (box->active == NULL) | |
747 { | |
748 find_focusable_widget(box); | |
749 return; | |
750 } | |
751 | |
752 now = box->active; | |
753 | |
754 if (dir == 1) | |
755 find_next_focus(box); | |
756 else if (dir == -1) | |
757 find_prev_focus(box); | |
758 | |
759 if (now && now != box->active) | |
760 { | |
761 gnt_widget_set_focus(now, FALSE); | |
762 gnt_widget_set_focus(box->active, TRUE); | |
763 } | |
764 | |
765 if (GNT_WIDGET(box)->window) | |
766 gnt_widget_draw(GNT_WIDGET(box)); | |
767 } | |
768 | |
769 void gnt_box_give_focus_to_child(GntBox *box, GntWidget *widget) | |
770 { | |
771 GList *find = g_list_find(box->focus, widget); | |
772 gpointer now = box->active; | |
773 if (find) | |
774 box->active = widget; | |
775 if (now && now != box->active) | |
776 { | |
777 gnt_widget_set_focus(now, FALSE); | |
778 gnt_widget_set_focus(box->active, TRUE); | |
779 } | |
780 | |
781 if (GNT_WIDGET(box)->window) | |
782 gnt_widget_draw(GNT_WIDGET(box)); | |
783 } | |
784 |