1 /*
2 * Copyright (C) 2000-2019 the xine project
3 *
4 * This file is part of xine, a unix video player.
5 *
6 * xine is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * xine 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 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * Unique public header file for xitk �TK.
21 *
22 */
23
24 #ifndef _XITK_H_
25 #define _XITK_H_
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #include <stdlib.h>
32 #include <limits.h>
33 #include <X11/Xlib.h>
34 #include <pthread.h>
35 #include <stdarg.h>
36 #include "xitk/Imlib-light/Imlib.h"
37
38 #ifdef HAVE_ICONV
39 #include <iconv.h>
40 #endif
41
42 #ifdef NEED_MRLBROWSER
43 #include <xine.h>
44 #endif
45
46 #define XITK_MAJOR_VERSION (0)
47 #define XITK_MINOR_VERSION (10)
48 #define XITK_SUB_VERSION (7)
49 #define XITK_VERSION "0.10.7"
50
51 #define XITK_CHECK_VERSION(major, minor, sub) \
52 (XITK_MAJOR_VERSION > (major) || \
53 (XITK_MAJOR_VERSION == (major) && \
54 XITK_MINOR_VERSION > (minor)) || \
55 (XITK_MAJOR_VERSION == (major) && \
56 XITK_MINOR_VERSION == (minor) && \
57 XITK_SUB_VERSION >= (sub)))
58
59 #define XITK_WIDGET_MAGIC 0x7869746b
60
61 #ifndef NAME_MAX
62 #define XITK_NAME_MAX 256
63 #else
64 #define XITK_NAME_MAX NAME_MAX
65 #endif
66
67 #ifndef PATH_MAX
68 #define XITK_PATH_MAX 768
69 #else
70 #define XITK_PATH_MAX PATH_MAX
71 #endif
72
73 #define INPUT_MOTION (ExposureMask | ButtonPressMask | ButtonReleaseMask | \
74 KeyPressMask | KeyReleaseMask | ButtonMotionMask | \
75 StructureNotifyMask | PropertyChangeMask | \
76 LeaveWindowMask | EnterWindowMask | PointerMotionMask)
77
78 #define WINDOW_INFO_ZERO(w) do { \
79 free((w)->name); \
80 (w)->window = None; \
81 (w)->name = NULL; \
82 (w)->x = 0; \
83 (w)->y = 0; \
84 (w)->height = 0; \
85 (w)->width = 0; \
86 } while(0)
87
88 typedef struct xitk_dnode_st {
89 struct xitk_dnode_st *next, *prev;
90 } xitk_dnode_t;
91
92 typedef struct {
93 xitk_dnode_t head, tail;
94 } xitk_dlist_t;
95
xitk_dlist_init(xitk_dlist_t * list)96 static inline void xitk_dlist_init (xitk_dlist_t *list) {
97 list->head.next = &list->tail;
98 list->head.prev = NULL;
99 list->tail.next = NULL;
100 list->tail.prev = &list->head;
101 }
102
xitk_dnode_init(xitk_dnode_t * node)103 static inline void xitk_dnode_init (xitk_dnode_t *node) {
104 node->next = node->prev = NULL;
105 }
106
xitk_dnode_remove(xitk_dnode_t * node)107 static inline void xitk_dnode_remove (xitk_dnode_t *node) {
108 if (node->next) {
109 node->prev->next = node->next;
110 node->next->prev = node->prev;
111 node->next = node->prev = NULL;
112 }
113 }
114
xitk_dlist_add_tail(xitk_dlist_t * list,xitk_dnode_t * node)115 static inline void xitk_dlist_add_tail (xitk_dlist_t *list, xitk_dnode_t *node) {
116 #ifdef XITK_DEBUG
117 if (node->next)
118 printf ("xitk_dlist_add_tail: node %p already added (next = %p, prev = %p).\n",
119 (void *)node, (void *)node->next, (void *)node->prev);
120 #endif
121 node->prev = list->tail.prev;
122 list->tail.prev->next = node;
123 list->tail.prev = node;
124 node->next = &list->tail;
125 }
126
xitk_dlist_clear(xitk_dlist_t * list)127 static inline int xitk_dlist_clear (xitk_dlist_t *list) {
128 int n = 0;
129 xitk_dnode_t *node = list->head.next;
130 list->head.next = &list->tail;
131 list->head.prev = NULL;
132 list->tail.next = NULL;
133 list->tail.prev = &list->head;
134 while (1) {
135 xitk_dnode_t *next = node->next;
136 if (!next)
137 break;
138 node->next = node->prev = NULL;
139 node = next;
140 n++;
141 }
142 return n;
143 }
144
145 #if 0 /* yet unused */
146
147 static inline int xitk_dlist_is_empty (xitk_dlist_t *list) {
148 return list->tail.prev == &list->head;
149 }
150
151 static inline xitk_dnode_t *xitk_dlist_remove_head (xitk_dlist_t *list) {
152 xitk_dnode_t *node = list->head.next;
153 if (!node->next)
154 return NULL;
155 node->prev->next = node->next;
156 node->next->prev = node->prev;
157 node->next = node->prev = NULL;
158 return node;
159 }
160
161 static inline xitk_dnode_t *xitk_dlist_remove_tail (xitk_dlist_t *list) {
162 xitk_dnode_t *node = list->tail.prev;
163 if (!node->prev)
164 return NULL;
165 node->prev->next = node->next;
166 node->next->prev = node->prev;
167 node->next = node->prev = NULL;
168 return node;
169 }
170
171 static inline void xitk_dlist_add_head (xitk_dlist_t *list, xitk_dnode_t *node) {
172 node->next = list->head.next;
173 list->head.next->prev = node;
174 list->head.next = node;
175 node->prev = &list->head;
176 }
177
178 #endif
179
180 typedef struct xitk_s xitk_t;
181
182 typedef struct xitk_widget_s xitk_widget_t;
183 typedef struct xitk_menu_entry_s xitk_menu_entry_t;
184 typedef struct xitk_widget_list_s xitk_widget_list_t;
185 typedef struct xitk_skin_config_s xitk_skin_config_t;
186 typedef struct xitk_font_s xitk_font_t;
187 typedef struct xitk_pixmap_s xitk_pixmap_t;
188 typedef struct xitk_window_s xitk_window_t;
189
190 void xitk_add_widget (xitk_widget_list_t *wl, xitk_widget_t *wi);
191
192 typedef void (*xitk_startup_callback_t)(void *);
193 typedef void (*xitk_simple_callback_t)(xitk_widget_t *, void *);
194 typedef void (*xitk_menu_callback_t)(xitk_widget_t *, xitk_menu_entry_t *, void *);
195 typedef void (*xitk_state_callback_t)(xitk_widget_t *, void *, int);
196 typedef void (*xitk_state_double_callback_t)(xitk_widget_t *, void *, double);
197 typedef void (*xitk_string_callback_t)(xitk_widget_t *, void *, const char *);
198 typedef void (*xitk_dnd_callback_t) (const char *filename);
199 typedef void (*xitk_pixmap_destroyer_t)(xitk_pixmap_t *);
200 #ifdef NEED_MRLBROWSER
201 typedef void (*xitk_mrl_callback_t)(xitk_widget_t *, void *, xine_mrl_t *);
202 #endif
203
204 /*
205 * Event callback function type.
206 * Thefunction will be called on every xevent.
207 * If the window match with that one specified at
208 * register time, only event for this window
209 * will be send to this function.
210 */
211 typedef void (*widget_event_callback_t)(XEvent *event, void *data);
212
213 /*
214 * New positioning window callback function.
215 * This callback will be called when the window
216 * moving will be done (at button release time),
217 * and, of course, only if there was a window
218 * specified at register time.
219 */
220 typedef void (*widget_newpos_callback_t)(void *data, int x, int y, int width, int height);
221
222 /*
223 * Signal handler callback function.
224 * Xitk will call this function when a signal happen.
225 */
226 typedef void (*xitk_signal_callback_t)(int, void *);
227
228 /*
229 * A unique key returned by register function.
230 * It is necessary to store it at program side,
231 * because it will be necessary to pass it for
232 * identification of caller.
233 */
234 typedef int xitk_register_key_t;
235
236
237 typedef struct {
238 int x, y;
239 } xitk_point_t;
240
241 typedef struct {
242 int first, last;
243 } xitk_range_t;
244
245 struct xitk_pixmap_s {
246 ImlibData *imlibdata;
247 XImage *xim;
248 Pixmap pixmap;
249 GC gc;
250 XGCValues gcv;
251 int width;
252 int height;
253 int shm;
254 #ifdef HAVE_SHM
255 XShmSegmentInfo *shminfo;
256 #endif
257 xitk_pixmap_destroyer_t destroy;
258 };
259
260 typedef struct {
261 int width;
262 int height;
263 int chars_per_row;
264 int chars_total;
265 int char_width;
266 int char_height;
267 xitk_point_t space;
268 xitk_point_t asterisk;
269 xitk_point_t unknown;
270 #define XITK_MAX_UNICODE_RANGES 16
271 xitk_range_t unicode_ranges[XITK_MAX_UNICODE_RANGES + 1];
272 } xitk_pix_font_t;
273
274 typedef struct {
275 xitk_pixmap_t *image;
276 xitk_pixmap_t *mask;
277 xitk_pix_font_t *pix_font;
278 int width;
279 int height;
280 } xitk_image_t;
281
282 typedef struct {
283 int red;
284 int green;
285 int blue;
286 char colorname[20];
287 } xitk_color_names_t;
288
289 #define MWM_HINTS_DECORATIONS (1L << 1)
290 #define PROP_MWM_HINTS_ELEMENTS 5
291 typedef struct _mwmhints {
292 unsigned long flags;
293 unsigned long functions;
294 unsigned long decorations;
295 long input_mode;
296 unsigned long status;
297 } MWMHints;
298
299 typedef struct {
300 int enabled;
301 int offset_x;
302 int offset_y;
303 } xitk_move_t;
304
305 typedef struct {
306 Window window;
307 char *name;
308 int x;
309 int y;
310 int height;
311 int width;
312 } window_info_t;
313
314 typedef struct {
315 /* all */
316 int x, y;
317 int visibility, enability;
318 char *pixmap_name;
319 xitk_image_t *pixmap_img;
320 /* button list */
321 int max_buttons, direction;
322 /* browser */
323 int browser_entries;
324 /* label */
325 int label_length, label_alignment, label_printable, label_staticity;
326 int label_animation, label_animation_step;
327 unsigned long int label_animation_timer;
328 char *label_color, *label_color_focus, *label_color_click, *label_fontname;
329 char *label_pixmap_font_name;
330 char *label_pixmap_font_format;
331 xitk_image_t *label_pixmap_font_img;
332 /* slider */
333 int slider_type, slider_radius;
334 char *slider_pixmap_pad_name;
335 xitk_image_t *slider_pixmap_pad_img;
336 } xitk_skin_element_info_t;
337
338 /*
339 * 1 <widget group >
340 * 1 <The groupped widget>
341 * 1 <focusable>
342 * 1 <clickable>
343 * 1 <support key events>
344 * 0 <reserved, not used yet>
345 * 1111111111111 <group types> <13 types>
346 * 1111111111111 <widget> <13 types>
347 */
348 /* Group of widgets widget */
349 #define WIDGET_GROUP 0x80000000
350 /* Grouped widget, itself */
351 #define WIDGET_GROUP_WIDGET 0x40000000
352 /* Is widget focusable */
353 #define WIDGET_FOCUSABLE 0x20000000
354 /* Is widget clickable */
355 #define WIDGET_CLICKABLE 0x10000000
356 /* Widget support key events */
357 #define WIDGET_KEYABLE 0x08000000
358
359 /* Grouped widgets */
360 #define WIDGET_GROUP_MASK 0x03FFE000
361 #define WIDGET_GROUP_BROWSER 0x00002000
362 #define WIDGET_GROUP_MRLBROWSER 0x00004000
363 #define WIDGET_GROUP_COMBO 0x00008000
364 #define WIDGET_GROUP_TABS 0x00010000
365 #define WIDGET_GROUP_INTBOX 0x00020000
366 #define WIDGET_GROUP_DOUBLEBOX 0x00040000
367 #define WIDGET_GROUP_MENU 0x00080000
368
369 /* Real widgets. */
370 #define WIDGET_TYPE_MASK 0x00001FFF
371 #define WIDGET_TYPE_BUTTON 0x00000001
372 #define WIDGET_TYPE_LABELBUTTON 0x00000002
373 #define WIDGET_TYPE_LABEL 0x00000003
374 #define WIDGET_TYPE_SLIDER 0x00000004
375 #define WIDGET_TYPE_CHECKBOX 0x00000005
376 #define WIDGET_TYPE_IMAGE 0x00000006
377 #define WIDGET_TYPE_INPUTTEXT 0x00000007
378
379 /* See */
380 #define ALIGN_LEFT 1
381 #define ALIGN_CENTER 2
382 #define ALIGN_RIGHT 3
383 #define ALIGN_DEFAULT (ALIGN_LEFT)
384
385 /*
386 * Slider type
387 */
388 #define XITK_VSLIDER 1
389 #define XITK_HSLIDER 2
390 #define XITK_RSLIDER 3
391
392 /*
393 * Label button type
394 */
395 #define CLICK_BUTTON 1
396 #define RADIO_BUTTON 2
397
398 /*
399 * See xitk_get_modifier_key()
400 */
401 #define MODIFIER_NOMOD 0x00000000
402 #define MODIFIER_SHIFT 0x00000001
403 #define MODIFIER_LOCK 0x00000002
404 #define MODIFIER_CTRL 0x00000004
405 #define MODIFIER_META 0x00000008
406 #define MODIFIER_NUML 0x00000010
407 #define MODIFIER_MOD3 0x00000020
408 #define MODIFIER_MOD4 0x00000040
409 #define MODIFIER_MOD5 0x00000080
410
411 /*
412 * See
413 */
414 #define DIRECTION_UP 1
415 #define DIRECTION_DOWN 2
416 #define DIRECTION_LEFT 3
417 #define DIRECTION_RIGHT 4
418
419 /*
420 * Result of dialog window
421 */
422 #define XITK_WINDOW_ANSWER_UNKNOWN 0
423 #define XITK_WINDOW_ANSWER_OK 1
424 #define XITK_WINDOW_ANSWER_YES 2
425 #define XITK_WINDOW_ANSWER_NO 3
426 #define XITK_WINDOW_ANSWER_CANCEL 4
427
428 /*
429 * See xitk_get_wm_type()
430 */
431 #define WM_TYPE_COMP_MASK 0x00007FFF
432 #define WM_TYPE_UNKNOWN 0x00000000
433 #define WM_TYPE_GNOME_COMP 0x80000000
434 #define WM_TYPE_EWMH_COMP 0x40000000
435 #define WM_TYPE_KWIN 0x00000001
436 #define WM_TYPE_E 0x00000002
437 #define WM_TYPE_ICE 0x00000003
438 #define WM_TYPE_WINDOWMAKER 0x00000004
439 #define WM_TYPE_MOTIF 0x00000005
440 #define WM_TYPE_XFCE 0x00000006
441 #define WM_TYPE_SAWFISH 0x00000007
442 #define WM_TYPE_METACITY 0x00000008
443 #define WM_TYPE_AFTERSTEP 0x00000009
444 #define WM_TYPE_BLACKBOX 0x0000000A
445 #define WM_TYPE_LARSWM 0x0000000B
446 #define WM_TYPE_DTWM 0x0000000C
447
448 typedef enum {
449 WINDOW_TYPE_DESKTOP = 1,
450 WINDOW_TYPE_DOCK,
451 WINDOW_TYPE_TOOLBAR,
452 WINDOW_TYPE_MENU,
453 WINDOW_TYPE_UTILITY,
454 WINDOW_TYPE_SPLASH,
455 WINDOW_TYPE_DIALOG,
456 WINDOW_TYPE_DROPDOWN_MENU,
457 WINDOW_TYPE_POPUP_MENU,
458 WINDOW_TYPE_TOOLTIP,
459 WINDOW_TYPE_NOTIFICATION,
460 WINDOW_TYPE_COMBO,
461 WINDOW_TYPE_DND,
462 WINDOW_TYPE_NORMAL
463 } xitk_wm_window_type_t;
464
465 void xitk_set_wm_window_type(Window window, xitk_wm_window_type_t type);
466 void xitk_unset_wm_window_type(Window window, xitk_wm_window_type_t type);
467
468 typedef enum {
469 xitk_cursor_invisible,
470 xitk_cursor_X_cursor,
471 xitk_cursor_arrow,
472 xitk_cursor_based_arrow_down,
473 xitk_cursor_based_arrow_up,
474 xitk_cursor_boat,
475 xitk_cursor_bogosity,
476 xitk_cursor_bottom_left_corner,
477 xitk_cursor_bottom_right_corner,
478 xitk_cursor_bottom_side,
479 xitk_cursor_bottom_tee,
480 xitk_cursor_box_spiral,
481 xitk_cursor_center_ptr,
482 xitk_cursor_circle,
483 xitk_cursor_clock,
484 xitk_cursor_coffee_mug,
485 xitk_cursor_cross,
486 xitk_cursor_cross_reverse,
487 xitk_cursor_crosshair,
488 xitk_cursor_diamond_cross,
489 xitk_cursor_dot,
490 xitk_cursor_dotbox,
491 xitk_cursor_double_arrow,
492 xitk_cursor_draft_large,
493 xitk_cursor_draft_small,
494 xitk_cursor_draped_box,
495 xitk_cursor_exchange,
496 xitk_cursor_fleur,
497 xitk_cursor_gobbler,
498 xitk_cursor_gumby,
499 xitk_cursor_hand1,
500 xitk_cursor_hand2,
501 xitk_cursor_heart,
502 xitk_cursor_icon,
503 xitk_cursor_iron_cross,
504 xitk_cursor_left_ptr,
505 xitk_cursor_left_side,
506 xitk_cursor_left_tee,
507 xitk_cursor_leftbutton,
508 xitk_cursor_ll_angle,
509 xitk_cursor_lr_angle,
510 xitk_cursor_man,
511 xitk_cursor_middlebutton,
512 xitk_cursor_mouse,
513 xitk_cursor_pencil,
514 xitk_cursor_pirate,
515 xitk_cursor_plus,
516 xitk_cursor_question_arrow,
517 xitk_cursor_right_ptr,
518 xitk_cursor_right_side,
519 xitk_cursor_right_tee,
520 xitk_cursor_rightbutton,
521 xitk_cursor_rtl_logo,
522 xitk_cursor_sailboat,
523 xitk_cursor_sb_down_arrow,
524 xitk_cursor_sb_h_double_arrow,
525 xitk_cursor_sb_left_arrow,
526 xitk_cursor_sb_right_arrow,
527 xitk_cursor_sb_up_arrow,
528 xitk_cursor_sb_v_double_arrow,
529 xitk_cursor_shuttle,
530 xitk_cursor_sizing,
531 xitk_cursor_spider,
532 xitk_cursor_spraycan,
533 xitk_cursor_star,
534 xitk_cursor_target,
535 xitk_cursor_tcross,
536 xitk_cursor_top_left_arrow,
537 xitk_cursor_top_left_corner,
538 xitk_cursor_top_right_corner,
539 xitk_cursor_top_side,
540 xitk_cursor_top_tee,
541 xitk_cursor_trek,
542 xitk_cursor_ul_angle,
543 xitk_cursor_umbrella,
544 xitk_cursor_ur_angle,
545 xitk_cursor_watch,
546 xitk_cursor_xterm,
547 xitk_cursor_num_glyphs
548 } xitk_cursors_t;
549
550 /*
551 * See xitk_widget_list_[set/get]()
552 */
553 #define WIDGET_LIST_GC 1
554 #define WIDGET_LIST_WINDOW 2
555 #define XITK_WIDGET_LIST_WINDOW(wl) (Window) xitk_widget_list_get(wl, WIDGET_LIST_WINDOW)
556 #define XITK_WIDGET_LIST_GC(wl) (GC) xitk_widget_list_get(wl, WIDGET_LIST_GC)
557 #define XITK_WIDGET_LIST_FREE(wl) xitk_widget_list_defferred_destroy(wl)
558
559 #define XITK_WIDGET_INIT(X, I) do { \
560 (X)->magic = XITK_WIDGET_MAGIC; \
561 (X)->imlibdata = I; \
562 } while(0)
563
564 /**
565 * Widget struct
566 */
567
568 typedef struct {
569 int magic;
570 ImlibData *imlibdata;
571 int min;
572 int max;
573 int step;
574 char *skin_element_name;
575 xitk_state_callback_t callback;
576 void *userdata;
577 xitk_state_callback_t motion_callback;
578 void *motion_userdata;
579 } xitk_slider_widget_t;
580
581 typedef struct {
582 int magic;
583 ImlibData *imlibdata;
584 int button_type;
585 int align;
586 const char *label;
587 xitk_simple_callback_t callback;
588 xitk_state_callback_t state_callback;
589 void *userdata;
590 char *skin_element_name;
591 } xitk_labelbutton_widget_t;
592
593 typedef struct {
594 int magic;
595 ImlibData *imlibdata;
596 Window window;
597 GC gc;
598 const char *label;
599 char *skin_element_name;
600 xitk_simple_callback_t callback;
601 void *userdata;
602 } xitk_label_widget_t;
603
604 typedef struct {
605 int magic;
606 ImlibData *imlibdata;
607 char *skin_element_name;
608 } xitk_image_widget_t;
609
610 typedef struct {
611 int magic;
612 ImlibData *imlibdata;
613 xitk_state_callback_t callback;
614 void *userdata;
615 char *skin_element_name;
616 } xitk_checkbox_widget_t;
617
618 typedef struct {
619 int magic;
620 ImlibData *imlibdata;
621 char *skin_element_name;
622 xitk_simple_callback_t callback;
623 void *userdata;
624 } xitk_button_widget_t;
625
626 typedef struct {
627 int magic;
628 ImlibData *imlibdata;
629
630 struct {
631 char *skin_element_name;
632 } arrow_up;
633
634 struct {
635 char *skin_element_name;
636 } slider;
637
638 struct {
639 char *skin_element_name;
640 } arrow_dn;
641
642 struct {
643 char *skin_element_name;
644 } arrow_left;
645
646 struct {
647 char *skin_element_name;
648 } slider_h;
649
650 struct {
651 char *skin_element_name;
652 } arrow_right;
653
654 struct {
655 char *skin_element_name;
656 int max_displayed_entries;
657 int num_entries;
658 const char *const *entries;
659 } browser;
660
661 xitk_state_callback_t dbl_click_callback;
662
663 xitk_state_callback_t callback;
664 void *userdata;
665
666 xitk_widget_list_t *parent_wlist;
667 } xitk_browser_widget_t;
668
669 #ifdef NEED_MRLBROWSER
670
671 typedef struct {
672 char *name;
673 char *ending;
674 } xitk_mrlbrowser_filter_t;
675
676 typedef struct {
677 int magic;
678 ImlibData *imlibdata;
679 char *skin_element_name;
680 Window window_trans;
681 int layer_above;
682 Pixmap *icon;
683 int set_wm_window_normal;
684
685 int x;
686 int y;
687 char *window_title;
688 char *resource_name;
689 char *resource_class;
690
691 struct {
692 char *cur_origin;
693 char *skin_element_name;
694 } origin;
695
696 xitk_dnd_callback_t dndcallback;
697 void *dnddata;
698
699 struct {
700 char *caption;
701 char *skin_element_name;
702 xitk_mrl_callback_t callback;
703 void *data;
704 } select;
705
706 struct {
707 char *skin_element_name;
708 xitk_mrl_callback_t callback;
709 void *data;
710 } play;
711
712 struct {
713 char *caption;
714 char *skin_element_name;
715 } dismiss;
716
717 struct {
718 xitk_simple_callback_t callback;
719 void *data;
720 } kill;
721
722 const char *const *ip_availables;
723
724 struct {
725
726 struct {
727 char *skin_element_name;
728 } button;
729
730 struct {
731 const char *label_str;
732 char *skin_element_name;
733 } label;
734
735 } ip_name;
736
737 xine_t *xine;
738
739 xitk_browser_widget_t browser;
740
741 xitk_mrlbrowser_filter_t **mrl_filters;
742
743 struct {
744 char *skin_element_name;
745 } combo;
746
747 } xitk_mrlbrowser_widget_t;
748
749 #endif
750
751 typedef struct {
752 int magic;
753 ImlibData *imlibdata;
754 char *text;
755 int max_length;
756 xitk_string_callback_t callback;
757 void *userdata;
758 char *skin_element_name;
759 } xitk_inputtext_widget_t;
760
761 typedef struct {
762 int magic;
763 ImlibData *imlibdata;
764 char *skin_element_name;
765 xitk_widget_list_t *parent_wlist;
766 const char **entries;
767 int layer_above;
768 xitk_state_callback_t callback;
769 void *userdata;
770 xitk_register_key_t *parent_wkey;
771 } xitk_combo_widget_t;
772
773 typedef struct {
774 int magic;
775 ImlibData *imlibdata;
776 char *skin_element_name;
777 int num_entries;
778 char **entries;
779 xitk_widget_list_t *parent_wlist;
780 xitk_state_callback_t callback;
781 void *userdata;
782 } xitk_tabs_widget_t;
783
784 typedef struct {
785 int magic;
786 ImlibData *imlibdata;
787
788 char *skin_element_name;
789
790 int value;
791 int step;
792
793 xitk_widget_list_t *parent_wlist;
794
795 xitk_state_callback_t callback;
796 void *userdata;
797 } xitk_intbox_widget_t;
798
799 typedef struct {
800 int magic;
801 ImlibData *imlibdata;
802
803 char *skin_element_name;
804
805 double value;
806 double step;
807
808 xitk_widget_list_t *parent_wlist;
809
810 xitk_state_double_callback_t callback;
811 void *userdata;
812 } xitk_doublebox_widget_t;
813
814 struct xitk_menu_entry_s {
815 char *menu;
816 char *shortcut; /* displayed (can be NULL) */
817 char *type; /* NULL, <separator>, <branch>, <check>, <checked> */
818 xitk_menu_callback_t cb;
819 void *user_data;
820 int user_id;
821 };
822
823 typedef struct {
824 int magic;
825 ImlibData *imlibdata;
826
827 char *skin_element_name;
828
829 xitk_widget_list_t *parent_wlist;
830
831 xitk_menu_entry_t *menu_tree; /* NULL terminated */
832
833 } xitk_menu_widget_t;
834
835
836 /* *******
837 * INIT: widget lib initialization and friends
838 */
839 /*
840 * Create a new widget list, store it internaly,
841 * then return the pointer to app.
842 */
843 xitk_widget_list_t *xitk_widget_list_new (void);
844
845 /*
846 * Humm, this should be probably removed soon.
847 */
848 void xitk_change_window_for_event_handler (xitk_register_key_t key, Window window);
849
850 /*
851 * Register a callback function called when a signal heppen.
852 */
853 void xitk_register_signal_handler(xitk_signal_callback_t sigcb, void *user_data);
854
855 /*
856 * Register function:
857 * name: temporary name about debug stuff, can be NULL.
858 * window: desired window for event callback calls, can be None.
859 * cb: callback for xevent, can be NULL.
860 * pos_cb; callback for window moving.
861 * dnd_cb: callback for dnd event.
862 * wl: widget_list handled internaly for xevent reactions.
863 */
864 xitk_register_key_t xitk_register_event_handler(const char *name, Window window,
865 widget_event_callback_t cb,
866 widget_newpos_callback_t pos_cb,
867 xitk_dnd_callback_t dnd_cb,
868 xitk_widget_list_t *wl, void *user_data);
869
870 /*
871 * Remove widgetkey_t entry in internal table.
872 */
873 void xitk_unregister_event_handler(xitk_register_key_t *key);
874
875 /*
876 * Helper function to free widget list inside callbacks.
877 */
878 void xitk_widget_list_defferred_destroy(xitk_widget_list_t *wl);
879
880 /*
881 * Copy window information matching with key in passed window_info_t struct.
882 */
883
884 int xitk_get_window_info(xitk_register_key_t key, window_info_t *winf);
885
886 /*
887 * Initialization function, should be the first call to widget lib.
888 */
889 void xitk_init(Display *display, XColor black, void (*x_lock_display) (Display *display),
890 void (*x_unlock_display) (Display *display), int verbosity);
891
892 /*
893 *
894 */
895 const char *xitk_set_locale(void);
896
897 /*
898 *
899 */
900 long int xitk_get_last_keypressed_time(void);
901
902 /*
903 *
904 */
905 int xitk_get_layer_level(void);
906
907 /*
908 * Return WM_TYPE_*
909 */
910 uint32_t xitk_get_wm_type(void);
911
912 /*
913 *
914 */
915 void xitk_set_layer_above(Window window);
916
917 /*
918 *
919 */
920 void xitk_set_window_layer(Window window, int layer);
921
922 /*
923 *
924 */
925 void xitk_set_ewmh_fullscreen(Window window);
926 void xitk_unset_ewmh_fullscreen(Window window);
927
928 /*
929 * This function start the widget live. It's a block function,
930 * it will only return after a widget_stop() call.
931 */
932 void xitk_run(xitk_startup_callback_t cb, void *data);
933
934 /*
935 * This function terminate the widget lib loop event.
936 * Other functions of the lib shouldn't be called after this
937 * one.
938 */
939 void xitk_stop(void);
940
941 /*
942 * Some user settings values.
943 */
944 const char *xitk_get_system_font(void);
945 const char *xitk_get_default_font(void);
946 int xitk_get_xmb_enability(void);
947 void xitk_set_xmb_enability(int value);
948 int xitk_get_black_color(void);
949 int xitk_get_white_color(void);
950 int xitk_get_background_color(void);
951 int xitk_get_focus_color(void);
952 int xitk_get_select_color(void);
953 char *xitk_filter_filename(const char *name);
954 unsigned long xitk_get_timer_label_animation(void);
955 long int xitk_get_timer_dbl_click(void);
956 int xitk_get_barstyle_feature(void);
957 unsigned long xitk_get_warning_foreground(void);
958 unsigned long xitk_get_warning_background(void);
959 int xitk_get_menu_shortcuts_enability(void);
960
961
962 /*
963 *
964 ****** */
965
966 /**
967 * Allocate an clean memory of "size" bytes.
968 */
969 void *xitk_xmalloc(size_t);
970
971 /**
972 *
973 */
974 int xitk_is_cursor_out_mask(Display *display, xitk_widget_t *w, Pixmap mask, int x, int y);
975
976 /**
977 *
978 */
979 xitk_color_names_t *xitk_get_color_name(const char *color);
980
981 /**
982 * return pointer to the xitk_color_names struct.
983 */
984 xitk_color_names_t *xitk_get_color_names(void);
985
986 /**
987 * Free color object.
988 */
989 void xitk_free_color_name(xitk_color_names_t *color);
990
991 /**
992 * (re)Paint a widget list.
993 */
994 int xitk_paint_widget_list (xitk_widget_list_t *wl) ;
995
996 /**
997 *
998 */
999 void xitk_change_skins_widget_list(xitk_widget_list_t *wl, xitk_skin_config_t *skonfig);
1000
1001 /**
1002 * Boolean function, if x and y coords is in widget.
1003 */
1004 int xitk_is_inside_widget (xitk_widget_t *widget, int x, int y);
1005
1006 /**
1007 * Return widget from widget list 'wl' localted at x,y coords.
1008 */
1009 xitk_widget_t *xitk_get_widget_at (xitk_widget_list_t *wl, int x, int y);
1010
1011 /**
1012 * Notify widget (if enabled) if motion happend at x, y coords.
1013 */
1014 void xitk_motion_notify_widget_list (xitk_widget_list_t *wl, int x, int y, unsigned int state);
1015
1016 /**
1017 * Notify widget (if enabled) if click event happend at x, y coords.
1018 */
1019 int xitk_click_notify_widget_list (xitk_widget_list_t *wl, int x, int y, int button, int bUp);
1020
1021 /**
1022 *
1023 */
1024 void xitk_send_key_event(xitk_widget_t *, XEvent *);
1025
1026 /**
1027 * Return the focused widget.
1028 */
1029 xitk_widget_t *xitk_get_focused_widget(xitk_widget_list_t *);
1030
1031 /**
1032 * Force the focus to given widget.
1033 */
1034 void xitk_set_focus_to_widget(xitk_widget_t *);
1035
1036 /**
1037 * Return the pressed widget.
1038 */
1039 xitk_widget_t *xitk_get_pressed_widget(xitk_widget_list_t *);
1040
1041 /**
1042 * Return width (in pixel) of widget.
1043 */
1044 int xitk_get_widget_width(xitk_widget_t *);
1045
1046 /**
1047 * Return height (in pixel) of widget.
1048 */
1049 int xitk_get_widget_height(xitk_widget_t *);
1050
1051 /**
1052 * Set position of a widget.
1053 */
1054 int xitk_set_widget_pos(xitk_widget_t *w, int x, int y);
1055
1056 /**
1057 * Get position of a widget.
1058 */
1059 int xitk_get_widget_pos(xitk_widget_t *w, int *x, int *y);
1060
1061 /**
1062 *
1063 */
1064 uint32_t xitk_get_widget_type(xitk_widget_t *w);
1065
1066 /**
1067 * Boolean, return 1 if widget 'w' have focus.
1068 */
1069 int xitk_is_widget_focused(xitk_widget_t *);
1070
1071 /**
1072 * Boolean, enable state of widget.
1073 */
1074 int xitk_is_widget_enabled(xitk_widget_t *);
1075
1076 /**
1077 * Enable widget.
1078 */
1079 void xitk_enable_widget(xitk_widget_t *);
1080
1081 /**
1082 * Disable widget.
1083 */
1084 void xitk_disable_widget(xitk_widget_t *);
1085
1086 /**
1087 *
1088 */
1089 void xitk_free_widget(xitk_widget_t *w);
1090
1091 /**
1092 * Destroy and free widget.
1093 */
1094 void xitk_destroy_widget(xitk_widget_t *w);
1095
1096 /**
1097 * Destroy widgets from widget list.
1098 */
1099 void xitk_destroy_widgets(xitk_widget_list_t *wl);
1100
1101 /**
1102 *
1103 */
1104 void xitk_stop_widget(xitk_widget_t *w);
1105
1106 /**
1107 * Stop each (if widget handle it) widgets of widget list.
1108 */
1109 void xitk_stop_widgets(xitk_widget_list_t *wl);
1110
1111 /**
1112 * Start widget.
1113 */
1114 void xitk_start_widget(xitk_widget_t *w);
1115
1116 /**
1117 * Set widgets of widget list visible.
1118 */
1119 void xitk_show_widgets(xitk_widget_list_t *);
1120
1121 /**
1122 * Set widget visible
1123 */
1124 void xitk_show_widget(xitk_widget_t *);
1125
1126 /**
1127 *
1128 */
1129 void xitk_enable_and_show_widget(xitk_widget_t *w);
1130
1131 /**
1132 * Set widgets of widget list not visible.
1133 */
1134 void xitk_hide_widgets(xitk_widget_list_t *);
1135
1136 /**
1137 * Hide a widget.
1138 */
1139 void xitk_hide_widget(xitk_widget_t *);
1140
1141 /**
1142 *
1143 */
1144 void xitk_disable_and_hide_widget(xitk_widget_t *w);
1145
1146 /**
1147 *
1148 */
1149 xitk_image_t *xitk_get_widget_foreground_skin(xitk_widget_t *w);
1150
1151 /**
1152 *
1153 */
1154 xitk_image_t *xitk_get_widget_background_skin(xitk_widget_t *w);
1155
1156 /**
1157 *
1158 */
1159 void xitk_set_widget_tips(xitk_widget_t *w, const char *str);
1160
1161 /**
1162 *
1163 */
1164 void xitk_set_widget_tips_default(xitk_widget_t *w, const char *str);
1165
1166 /**
1167 *
1168 */
1169 void xitk_set_widget_tips_and_timeout(xitk_widget_t *w, const char *str, unsigned long timeout);
1170
1171 /**
1172 *
1173 */
1174 unsigned long xitk_get_widget_tips_timeout(xitk_widget_t *w);
1175
1176 /**
1177 *
1178 */
1179 void xitk_set_widgets_tips_timeout(xitk_widget_list_t *wl, unsigned long timeout);
1180
1181 /**
1182 *
1183 */
1184 int xitk_is_mouse_over_widget(Display *display, Window window, xitk_widget_t *w);
1185
1186 /**
1187 *
1188 */
1189 int xitk_get_mouse_coords(Display *display, Window window, int *x, int *y, int *rx, int *ry);
1190
1191 /**
1192 *
1193 */
1194 void xitk_enable_widget_tips(xitk_widget_t *w);
1195
1196 /**
1197 *
1198 */
1199 void xitk_disable_widget_tips(xitk_widget_t *w);
1200
1201 /**
1202 *
1203 */
1204 void xitk_disable_widgets_tips(xitk_widget_list_t *wl);
1205
1206 /**
1207 *
1208 */
1209 void xitk_enable_widgets_tips(xitk_widget_list_t *wl);
1210
1211 /**
1212 *
1213 */
1214 void xitk_set_widget_tips_timeout(xitk_widget_t *w, unsigned long timeout);
1215
1216 /**
1217 * Pass events to UI
1218 */
1219 void xitk_xevent_notify(XEvent *event);
1220
1221 /*
1222 * *** Sliders ***
1223 */
1224
1225 /**
1226 * Create a slider
1227 */
1228 xitk_widget_t *xitk_slider_create(xitk_widget_list_t *wl,
1229 xitk_skin_config_t *skonfig, xitk_slider_widget_t *sl);
1230
1231 /**
1232 *
1233 */
1234 xitk_widget_t *xitk_noskin_slider_create (xitk_widget_list_t *wl,
1235 xitk_slider_widget_t *s,
1236 int x, int y, int width, int height, int type);
1237
1238 /**
1239 * Get current position of paddle.
1240 */
1241 int xitk_slider_get_pos(xitk_widget_t *);
1242
1243 /**
1244 * Set position of paddle.
1245 */
1246 void xitk_slider_set_pos(xitk_widget_t *, int);
1247
1248 /**
1249 * Set min value of slider.
1250 */
1251 void xitk_slider_set_min(xitk_widget_t *, int);
1252
1253 /**
1254 * Set max value of slider.
1255 */
1256 void xitk_slider_set_max(xitk_widget_t *, int);
1257
1258 /**
1259 * Get min value of slider.
1260 */
1261 int xitk_slider_get_min(xitk_widget_t *);
1262
1263 /**
1264 * Get max value of slider.
1265 */
1266 int xitk_slider_get_max(xitk_widget_t *);
1267
1268 /**
1269 * Set position to 0 and redraw the widget.
1270 */
1271 void xitk_slider_reset(xitk_widget_t *);
1272
1273 /**
1274 * Set position to max and redraw the widget.
1275 */
1276 void xitk_slider_set_to_max(xitk_widget_t *);
1277
1278 /**
1279 * Increment by step the paddle position
1280 */
1281 void xitk_slider_make_step(xitk_widget_t *);
1282
1283 /**
1284 * Decrement by step the paddle position.
1285 */
1286 void xitk_slider_make_backstep(xitk_widget_t *);
1287
1288 /**
1289 * Call callback for current position
1290 */
1291 void xitk_slider_callback_exec(xitk_widget_t *);
1292
1293 /*
1294 * *** Label Buttons
1295 */
1296 /**
1297 * Create a labeled button.
1298 */
1299 xitk_widget_t *xitk_labelbutton_create (xitk_widget_list_t *wl,
1300 xitk_skin_config_t *skonfig, const xitk_labelbutton_widget_t *b);
1301
1302 /**
1303 *
1304 */
1305 xitk_widget_t *xitk_info_labelbutton_create (xitk_widget_list_t *wl,
1306 const xitk_labelbutton_widget_t *b, const xitk_skin_element_info_t *info);
1307
1308 /**
1309 *
1310 */
1311 xitk_widget_t *xitk_noskin_labelbutton_create (xitk_widget_list_t *wl,
1312 const xitk_labelbutton_widget_t *b,
1313 int x, int y, int width, int height,
1314 const char *ncolor, const char *fcolor, const char *ccolor,
1315 const char *fname);
1316
1317 /**
1318 * Change label of button 'widget'.
1319 */
1320 int xitk_labelbutton_change_label (xitk_widget_t *, const char *new_label);
1321 int xitk_labelbutton_change_shortcut_label(xitk_widget_t *, const char *, int, const char *);
1322
1323 /**
1324 * Return label of button 'widget'.
1325 */
1326 const char *xitk_labelbutton_get_label(xitk_widget_t *);
1327 const char *xitk_labelbutton_get_shortcut_label(xitk_widget_t *);
1328
1329 /**
1330 * Get state of button 'widget'.
1331 */
1332 int xitk_labelbutton_get_state(xitk_widget_t *);
1333
1334 /**
1335 * Set state of button 'widget'.
1336 */
1337 void xitk_labelbutton_set_state(xitk_widget_t *, int);
1338
1339 /*
1340 * Return used font name
1341 */
1342 char *xitk_labelbutton_get_fontname(xitk_widget_t *);
1343
1344 /**
1345 * Set label button alignment
1346 */
1347 void xitk_labelbutton_set_alignment(xitk_widget_t *, int);
1348
1349 /**
1350 * Get label button alignment
1351 */
1352 int xitk_labelbutton_get_alignment(xitk_widget_t *);
1353
1354 /**
1355 *
1356 */
1357 void xitk_labelbutton_set_label_offset(xitk_widget_t *, int);
1358 int xitk_labelbutton_get_label_offset(xitk_widget_t *);
1359
1360 void xitk_labelbutton_callback_exec(xitk_widget_t *w);
1361
1362 /*
1363 * *** Labels
1364 */
1365 /**
1366 * Create a label widget.
1367 */
1368 xitk_widget_t *xitk_label_create (xitk_widget_list_t *wl,
1369 xitk_skin_config_t *skonfig, const xitk_label_widget_t *l);
1370
1371 /**
1372 *
1373 */
1374 xitk_widget_t *xitk_noskin_label_create (xitk_widget_list_t *wl,
1375 const xitk_label_widget_t *l, int x, int y, int width, int height,
1376 const char *fontname);
1377
1378 /**
1379 * Change label of widget 'widget'.
1380 */
1381 int xitk_label_change_label(xitk_widget_t *l, const char *newlabel);
1382
1383 /**
1384 * Get label.
1385 */
1386 const char *xitk_label_get_label(xitk_widget_t *w);
1387
1388 /*
1389 * *** Image
1390 */
1391
1392 /**
1393 * Load image and return a xitk_image_t data type.
1394 */
1395 xitk_image_t *xitk_image_load_image(ImlibData *idata, const char *image);
1396 void xitk_image_set_pix_font (xitk_image_t *image, const char *format);
1397
1398 /**
1399 * Create an image widget type.
1400 */
1401 xitk_widget_t *xitk_image_create(xitk_widget_list_t *wl,
1402 xitk_skin_config_t *skonfig, xitk_image_widget_t *im);
1403
1404 /**
1405 * Same as above, without skin.
1406 */
1407 xitk_widget_t *xitk_noskin_image_create (xitk_widget_list_t *wl,
1408 xitk_image_widget_t *im,
1409 xitk_image_t *image, int x, int y);
1410
1411 /**
1412 *
1413 */
1414 void xitk_image_change_image(ImlibData *im,
1415 xitk_image_t *src, xitk_image_t *dest, int width, int height);
1416
1417 /*
1418 * *** Checkbox
1419 */
1420 /**
1421 * Create a checkbox.
1422 */
1423 xitk_widget_t *xitk_checkbox_create (xitk_widget_list_t *wl,
1424 xitk_skin_config_t *skonfig, xitk_checkbox_widget_t *cp);
1425
1426 /*
1427 * Same as above, without skinable feature.
1428 */
1429 xitk_widget_t *xitk_noskin_checkbox_create(xitk_widget_list_t *wl,
1430 xitk_checkbox_widget_t *cb,
1431 int x, int y, int width, int height);
1432
1433
1434 /**
1435 * get state of checkbox "widget".
1436 */
1437 int xitk_checkbox_get_state(xitk_widget_t *);
1438
1439 /**
1440 * Set state of checkbox .
1441 */
1442 void xitk_checkbox_set_state(xitk_widget_t *, int);
1443
1444 /**
1445 * Call callback
1446 */
1447 void xitk_checkbox_callback_exec(xitk_widget_t *w);
1448
1449 /*
1450 * ** Buttons
1451 */
1452 /**
1453 * Create a button
1454 */
1455 /**
1456 *
1457 */
1458 xitk_widget_t *xitk_button_create (xitk_widget_list_t *wl,
1459 xitk_skin_config_t *skonfig, xitk_button_widget_t *b);
1460
1461 /**
1462 *
1463 */
1464 xitk_widget_t *xitk_noskin_button_create (xitk_widget_list_t *wl,
1465 xitk_button_widget_t *b,
1466 int x, int y, int width, int height);
1467
1468
1469 /*
1470 * *** Browser
1471 */
1472 /**
1473 * Create the list browser
1474 */
1475 /**
1476 *
1477 */
1478 xitk_widget_t *xitk_browser_create(xitk_widget_list_t *wl,
1479 xitk_skin_config_t *skonfig, xitk_browser_widget_t *b);
1480
1481 /**
1482 *
1483 */
1484 xitk_widget_t *xitk_noskin_browser_create(xitk_widget_list_t *wl,
1485 xitk_browser_widget_t *br, GC gc,
1486 int x, int y,
1487 int itemw, int itemh, int slidw, const char *fontname);
1488
1489 /**
1490 * Redraw buttons/slider
1491 */
1492 void xitk_browser_rebuild_browser(xitk_widget_t *w, int start);
1493
1494 /**
1495 * Update the list, and rebuild button list
1496 */
1497 void xitk_browser_update_list(xitk_widget_t *w, const char *const *list, const char *const *shortcut, int len, int start);
1498
1499 /**
1500 * slide up.
1501 */
1502 void xitk_browser_step_up(xitk_widget_t *w, void *data);
1503
1504 /**
1505 * slide Down.
1506 */
1507 void xitk_browser_step_down(xitk_widget_t *w, void *data);
1508
1509 /**
1510 * slide left.
1511 */
1512 void xitk_browser_step_left(xitk_widget_t *w, void *data);
1513
1514 /**
1515 * slide right.
1516 */
1517 void xitk_browser_step_right(xitk_widget_t *w, void *data);
1518
1519 /**
1520 * Page Up.
1521 */
1522 void xitk_browser_page_up(xitk_widget_t *w, void *data);
1523
1524 /**
1525 * Page Down.
1526 */
1527 void xitk_browser_page_down(xitk_widget_t *w, void *data);
1528
1529 /**
1530 * Return the current selected button (if not, return -1)
1531 */
1532 int xitk_browser_get_current_selected(xitk_widget_t *w);
1533
1534 /**
1535 * Select the item 'select' in list
1536 */
1537 void xitk_browser_set_select(xitk_widget_t *w, int select);
1538
1539 /**
1540 * Release all enabled buttons
1541 */
1542 void xitk_browser_release_all_buttons(xitk_widget_t *w);
1543
1544 /**
1545 * Return the number of displayed entries
1546 */
1547 int xitk_browser_get_num_entries(xitk_widget_t *w);
1548
1549 /**
1550 * Return the real number of first displayed in list
1551 */
1552 int xitk_browser_get_current_start(xitk_widget_t *w);
1553
1554 /**
1555 * Change browser labels alignment
1556 */
1557 void xitk_browser_set_alignment(xitk_widget_t *w, int align);
1558
1559 /*
1560 * Jump to entry in list which match with the alphanum char key.
1561 */
1562 void xitk_browser_warp_jump(xitk_widget_t *w, const char *key, int modifier);
1563
1564 xitk_widget_t *xitk_browser_get_browser(xitk_widget_t *w);
1565
1566 #ifdef NEED_MRLBROWSER
1567 /**
1568 *
1569 */
1570 xitk_widget_t *xitk_mrlbrowser_create(xitk_widget_list_t *wl,
1571 xitk_skin_config_t *skonfig, xitk_mrlbrowser_widget_t *mb);
1572
1573 /**
1574 *
1575 */
1576 void xitk_mrlbrowser_change_skins(xitk_widget_t *w, xitk_skin_config_t *skonfig);
1577
1578 /**
1579 *
1580 */
1581 int xitk_mrlbrowser_is_running(xitk_widget_t *w);
1582
1583 /**
1584 *
1585 */
1586 int xitk_mrlbrowser_is_visible(xitk_widget_t *w);
1587
1588 /**
1589 *
1590 */
1591 void xitk_mrlbrowser_hide(xitk_widget_t *w);
1592
1593 /**
1594 *
1595 */
1596 void xitk_mrlbrowser_show(xitk_widget_t *w);
1597
1598 /**
1599 *
1600 */
1601 void xitk_mrlbrowser_set_transient(xitk_widget_t *w, Window window);
1602
1603 /**
1604 *
1605 */
1606 void xitk_mrlbrowser_destroy(xitk_widget_t *w);
1607
1608 /**
1609 *
1610 */
1611 int xitk_mrlbrowser_get_window_info(xitk_widget_t *w, window_info_t *inf);
1612
1613 /**
1614 *
1615 */
1616 Window xitk_mrlbrowser_get_window_id(xitk_widget_t *w);
1617
1618 /**
1619 *
1620 */
1621 void xitk_mrlbrowser_set_tips_timeout(xitk_widget_t *w, int enabled, unsigned long timeout);
1622
1623 #endif
1624
1625 /*
1626 * return len of keystring (stored in kbuf)
1627 * define ksym
1628 * kbuf should be large enought (256 usually)
1629 */
1630 int xitk_get_keysym_and_buf(XEvent *event, KeySym *ksym, char kbuf[], int kblen);
1631
1632 /**
1633 * return keypressed
1634 */
1635 KeySym xitk_get_key_pressed(XEvent *event);
1636
1637 /**
1638 * All states of modifiers (see xitk_get_key_modifier() bellow).
1639 */
1640 /**
1641 * return 1 if a modifier key has been pressed (extracted from XEvent *)
1642 * modifier pointer will contain the modifier(s) bits (MODIFIER_*)
1643 */
1644 int xitk_get_key_modifier(XEvent *xev, int *modifier);
1645
1646 /**
1647 * Create an input text box.
1648 */
1649 xitk_widget_t *xitk_inputtext_create (xitk_widget_list_t *wl,
1650 xitk_skin_config_t *skonfig, xitk_inputtext_widget_t *it);
1651
1652 /**
1653 *
1654 */
1655 xitk_widget_t *xitk_noskin_inputtext_create (xitk_widget_list_t *wl,
1656 xitk_inputtext_widget_t *it,
1657 int x, int y, int width, int height,
1658 const char *ncolor, const char *fcolor, const char *fontname);
1659 /**
1660 * Return the text of widget.
1661 */
1662 char *xitk_inputtext_get_text(xitk_widget_t *it);
1663
1664 /**
1665 * Change and redisplay the text of widget.
1666 */
1667 void xitk_inputtext_change_text(xitk_widget_t *it, const char *text);
1668
1669
1670 /*
1671 * *** skin
1672 */
1673
1674 /*
1675 * Alloc a xitk_skin_config_t* memory area, nullify pointers.
1676 */
1677 xitk_skin_config_t *xitk_skin_init_config(ImlibData *);
1678
1679 /*
1680 * Release all allocated memory of a xitk_skin_config_t* variable (element chained struct too).
1681 */
1682 void xitk_skin_free_config(xitk_skin_config_t *);
1683
1684 /*
1685 * Load the skin configfile.
1686 */
1687 int xitk_skin_load_config(xitk_skin_config_t *, const char *, const char *);
1688
1689 /*
1690 * Check skin version.
1691 * return: 0 if version found < min_version
1692 * 1 if version found == min_version
1693 * 2 if version found > min_version
1694 * -1 if no version found
1695 */
1696 int xitk_skin_check_version(xitk_skin_config_t *, int);
1697
1698 /*
1699 * Unload (free) xitk_skin_config_t object.
1700 */
1701 void xitk_skin_unload_config(xitk_skin_config_t *);
1702
1703 /*
1704 *
1705 */
1706 int xitk_skin_get_direction(xitk_skin_config_t *skonfig, const char *str);
1707
1708 /*
1709 *
1710 */
1711 int xitk_skin_get_visibility(xitk_skin_config_t *, const char *);
1712
1713 /*
1714 *
1715 */
1716 int xitk_skin_get_printability(xitk_skin_config_t *, const char *);
1717
1718 /*
1719 *
1720 */
1721 int xitk_skin_get_enability(xitk_skin_config_t *, const char *);
1722
1723 /*
1724 *
1725 */
1726 int xitk_skin_get_coord_x(xitk_skin_config_t *, const char *);
1727
1728 /*
1729 *
1730 */
1731 int xitk_skin_get_coord_y(xitk_skin_config_t *, const char *);
1732
1733 /*
1734 *
1735 */
1736 const char *xitk_skin_get_label_color(xitk_skin_config_t *, const char *);
1737
1738 /*
1739 *
1740 */
1741 const char *xitk_skin_get_label_color_focus(xitk_skin_config_t *, const char *);
1742
1743 /*
1744 *
1745 */
1746 const char *xitk_skin_get_label_color_click(xitk_skin_config_t *, const char *);
1747
1748 /*
1749 *
1750 */
1751 int xitk_skin_get_label_length(xitk_skin_config_t *, const char *);
1752
1753 /*
1754 *
1755 */
1756 int xitk_skin_get_label_animation(xitk_skin_config_t *, const char *);
1757
1758 /*
1759 *
1760 */
1761 int xitk_skin_get_label_animation_step(xitk_skin_config_t *, const char *);
1762
1763 /*
1764 *
1765 */
1766 unsigned long xitk_skin_get_label_animation_timer(xitk_skin_config_t *, const char *);
1767
1768 /*
1769 *
1770 */
1771 int xitk_skin_get_label_alignment(xitk_skin_config_t *, const char *);
1772
1773 /*
1774 *
1775 */
1776 const char *xitk_skin_get_label_fontname(xitk_skin_config_t *, const char *);
1777
1778 /*
1779 *
1780 */
1781 int xitk_skin_get_label_printable(xitk_skin_config_t *, const char *);
1782
1783 /*
1784 *
1785 */
1786 int xitk_skin_get_label_staticity(xitk_skin_config_t *, const char *);
1787
1788 /*
1789 *
1790 */
1791 const char *xitk_skin_get_skin_filename(xitk_skin_config_t *, const char *);
1792
1793 /*
1794 *
1795 */
1796 const char *xitk_skin_get_slider_skin_filename(xitk_skin_config_t *, const char *);
1797
1798 /*
1799 *
1800 */
1801 int xitk_skin_get_slider_type(xitk_skin_config_t *, const char *);
1802
1803 /*
1804 *
1805 */
1806 int xitk_skin_get_slider_radius(xitk_skin_config_t *, const char *);
1807
1808 /*
1809 *
1810 */
1811 const char *xitk_skin_get_logo(xitk_skin_config_t *);
1812
1813 /*
1814 *
1815 */
1816 const char *xitk_skin_get_animation(xitk_skin_config_t *);
1817
1818 /*
1819 *
1820 */
1821 int xitk_skin_get_browser_entries(xitk_skin_config_t *, const char *);
1822
1823 /*
1824 *
1825 */
1826 xitk_image_t *xitk_skin_get_image(xitk_skin_config_t *, const char *);
1827
1828 /*
1829 *
1830 */
1831 int xitk_skin_get_max_buttons(xitk_skin_config_t *, const char *);
1832
1833 /*
1834 *
1835 */
1836 void xitk_skin_lock(xitk_skin_config_t *);
1837
1838 /*
1839 *
1840 */
1841 void xitk_skin_unlock(xitk_skin_config_t *);
1842
1843
1844 /**
1845 * Font manipulations.
1846 */
1847 /*
1848 *
1849 */
1850 xitk_font_t *xitk_font_load_font(Display *display, const char *font);
1851
1852 /*
1853 *
1854 */
1855 void xitk_font_unload_font(xitk_font_t *xtfs);
1856
1857 /*
1858 *
1859 */
1860 void xitk_font_draw_string(xitk_font_t *xtfs, Pixmap pix, GC gc,
1861 int x, int y, const char *text,
1862 size_t nbytes);
1863
1864 /*
1865 *
1866 */
1867 int xitk_font_get_text_width(xitk_font_t *xtfs, const char *c, int nbytes);
1868
1869 /*
1870 *
1871 */
1872 int xitk_font_get_string_length(xitk_font_t *xtfs, const char *c);
1873
1874 /*
1875 *
1876 */
1877 int xitk_font_get_char_width(xitk_font_t *xtfs, const char *c, int maxnbytes, int *nbytes);
1878
1879 /*
1880 *
1881 */
1882 int xitk_font_get_text_height(xitk_font_t *xtfs, const char *c, int nbytes);
1883
1884 /*
1885 *
1886 */
1887 int xitk_font_get_string_height(xitk_font_t *xtfs, const char *c);
1888
1889 /*
1890 *
1891 */
1892 int xitk_font_get_char_height(xitk_font_t *xtfs, const char *c, int maxnbytes, int *nbytes);
1893
1894 /*
1895 *
1896 */
1897 void xitk_font_text_extent(xitk_font_t *xtfs, const char *c, int nbytes,
1898 int *lbearing, int *rbearing, int *width, int *ascent, int *descent);
1899
1900 /*
1901 *
1902 */
1903 void xitk_font_string_extent(xitk_font_t *xtfs, const char *c,
1904 int *lbearing, int *rbearing, int *width, int *ascent, int *descent);
1905
1906 /*
1907 *
1908 */
1909 int xitk_font_get_ascent(xitk_font_t *xtfs, const char *c);
1910
1911 /*
1912 *
1913 */
1914 int xitk_font_get_descent(xitk_font_t *xtfs, const char *c);
1915
1916 /*
1917 *
1918 */
1919 void xitk_font_set_font(xitk_font_t *xtfs, GC gc);
1920
1921 /**
1922 *
1923 */
1924 xitk_widget_t *xitk_combo_create(xitk_widget_list_t *wl,
1925 xitk_skin_config_t *skonfig, xitk_combo_widget_t *c,
1926 xitk_widget_t **lw, xitk_widget_t **bw);
1927
1928 /**
1929 *
1930 */
1931 xitk_widget_t *xitk_noskin_combo_create(xitk_widget_list_t *wl,
1932 xitk_combo_widget_t *c, int x, int y, int width,
1933 xitk_widget_t **lw, xitk_widget_t **bw);
1934
1935 /**
1936 *
1937 */
1938 int xitk_combo_get_current_selected(xitk_widget_t *w);
1939
1940 /**
1941 *
1942 */
1943 const char *xitk_combo_get_current_entry_selected(xitk_widget_t *w);
1944
1945 /**
1946 *
1947 */
1948 void xitk_combo_set_select(xitk_widget_t *w, int select);
1949
1950 /**
1951 *
1952 */
1953 void xitk_combo_update_list(xitk_widget_t *w, const char *const *const list, int len);
1954
1955 /**
1956 *
1957 */
1958 void xitk_combo_update_pos(xitk_widget_t *w);
1959
1960 /**
1961 *
1962 */
1963 void xitk_combo_rollunroll(xitk_widget_t *w);
1964
1965 /**
1966 *
1967 */
1968 int xitk_combo_is_same_parent(xitk_widget_t *w1, xitk_widget_t *w2);
1969
1970 /**
1971 *
1972 */
1973 void xitk_combo_callback_exec(xitk_widget_t *w);
1974
1975 /**
1976 *
1977 */
1978 xitk_widget_t *xitk_combo_get_label_widget(xitk_widget_t *w);
1979
1980 /**
1981 *
1982 */
1983 unsigned int xitk_get_pixel_color_from_rgb(ImlibData *im, int r, int g, int b);
1984
1985 /**
1986 *
1987 */
1988 unsigned int xitk_get_pixel_color_black(ImlibData *im);
1989
1990 /**
1991 *
1992 */
1993 unsigned int xitk_get_pixel_color_white(ImlibData *im);
1994
1995 /**
1996 *
1997 */
1998 unsigned int xitk_get_pixel_color_lightgray(ImlibData *im);
1999
2000 /**
2001 *
2002 */
2003 unsigned int xitk_get_pixel_color_gray(ImlibData *im);
2004
2005 /**
2006 *
2007 */
2008 unsigned int xitk_get_pixel_color_darkgray(ImlibData *im);
2009
2010 /**
2011 *
2012 */
2013 unsigned int xitk_get_pixel_color_warning_foreground(ImlibData *im);
2014
2015 /**
2016 *
2017 */
2018 unsigned int xitk_get_pixel_color_warning_background(ImlibData *im);
2019
2020 /**
2021 *
2022 */
2023 xitk_image_t *xitk_image_create_image_with_colors_from_string(ImlibData *im,
2024 const char *fontname,
2025 int width, int align, const char *str,
2026 unsigned int foreground,
2027 unsigned int background);
2028 xitk_image_t *xitk_image_create_image_from_string(ImlibData *im,
2029 const char *fontname,
2030 int width, int align, const char *str);
2031 xitk_image_t *xitk_image_create_image(ImlibData *im, int width, int height);
2032
2033 xitk_pixmap_t *xitk_image_create_xitk_pixmap_with_depth(ImlibData *im, int width, int height, int depth);
2034
2035 xitk_pixmap_t *xitk_image_create_xitk_pixmap(ImlibData *im, int width, int height);
2036
2037 xitk_pixmap_t *xitk_image_create_xitk_mask_pixmap(ImlibData *im, int width, int height);
2038
2039 void xitk_image_destroy_xitk_pixmap(xitk_pixmap_t *p);
2040
2041 /**
2042 * Free an image object.
2043 */
2044 void xitk_image_free_image(ImlibData *im, xitk_image_t **src);
2045 /**
2046 *
2047 */
2048 void xitk_image_add_mask(ImlibData *im, xitk_image_t *dest);
2049
2050 /**
2051 *
2052 */
2053 Pixmap xitk_image_create_pixmap(ImlibData *idata, int width, int height);
2054
2055 /**
2056 *
2057 */
2058 void draw_flat_three_state(ImlibData *im, xitk_image_t *p);
2059
2060 /**
2061 *
2062 */
2063 void draw_bevel_three_state(ImlibData *im, xitk_image_t *p);
2064
2065 /**
2066 *
2067 */
2068 void draw_bevel_two_state(ImlibData *im, xitk_image_t *p);
2069
2070 void draw_three_state_round_style(ImlibData *im, xitk_image_t *p, int x, int y, int d, int w, int checked);
2071 void draw_three_state_check_style(ImlibData *im, xitk_image_t *p, int x, int y, int d, int w, int checked);
2072
2073
2074 void draw_paddle_three_state_vertical(ImlibData *im, xitk_image_t *p);
2075 void draw_paddle_three_state_horizontal(ImlibData *im, xitk_image_t *p);
2076
2077 /**
2078 *
2079 */
2080 void draw_inner(ImlibData *im, xitk_pixmap_t *p, int w, int h);
2081 void draw_inner_light(ImlibData *im, xitk_pixmap_t *p, int w, int h);
2082
2083 /**
2084 *
2085 */
2086 void draw_outter(ImlibData *im, xitk_pixmap_t *p, int w, int h);
2087 void draw_outter_light(ImlibData *im, xitk_pixmap_t *p, int w, int h);
2088
2089 void draw_flat_with_color(ImlibData *im, xitk_pixmap_t *p, int w, int h, unsigned int color);
2090 /**
2091 *
2092 */
2093 void draw_flat(ImlibData *im, xitk_pixmap_t *p, int w, int h);
2094
2095 /**
2096 *
2097 */
2098 void draw_arrow_up(ImlibData *im, xitk_image_t *p);
2099
2100 /**
2101 *
2102 */
2103 void draw_arrow_down(ImlibData *im, xitk_image_t *p);
2104
2105 /*
2106 * Draw and arrow (direction is LEFT).
2107 */
2108 void draw_arrow_left(ImlibData *im, xitk_image_t *p);
2109
2110 /*
2111 * Draw and arrow (direction is RIGHT).
2112 */
2113 void draw_arrow_right(ImlibData *im, xitk_image_t *p);
2114
2115 /**
2116 *
2117 */
2118 void draw_rectangular_inner_box(ImlibData *im, xitk_pixmap_t *p,
2119 int x, int y, int width, int height);
2120
2121 /**
2122 *
2123 */
2124 void draw_rectangular_outter_box(ImlibData *im, xitk_pixmap_t *p,
2125 int x, int y, int width, int height);
2126
2127 /**
2128 *
2129 */
2130 void draw_rectangular_inner_box_light(ImlibData *im, xitk_pixmap_t *p,
2131 int x, int y, int width, int height);
2132
2133 /**
2134 *
2135 */
2136 void draw_rectangular_outter_box_light(ImlibData *im, xitk_pixmap_t *p,
2137 int x, int y, int width, int height);
2138
2139 /**
2140 *
2141 */
2142 void draw_inner_frame(ImlibData *im, xitk_pixmap_t *p, const char *title, const char *fontname,
2143 int x, int y, int w, int h);
2144 void draw_outter_frame(ImlibData *im, xitk_pixmap_t *p, const char *title, const char *fontname,
2145 int x, int y, int w, int h);
2146
2147 void draw_tab(ImlibData *im, xitk_image_t *p);
2148
2149 void draw_paddle_rotate(ImlibData *im, xitk_image_t *p);
2150 void draw_rotate_button(ImlibData *im, xitk_image_t *p);
2151
2152 void draw_button_plus(ImlibData *im, xitk_image_t *p);
2153 void draw_button_minus(ImlibData *im, xitk_image_t *p);
2154
2155 void menu_draw_check(ImlibData *im, xitk_image_t *p, int checked);
2156 void menu_draw_arrow_branch(ImlibData *im, xitk_image_t *p);
2157
2158 /*
2159 * Windows
2160 */
2161
2162 /**
2163 *
2164 */
2165 xitk_window_t *xitk_window_create_window(ImlibData *im, int x, int y, int width, int height);
2166
2167 /**
2168 *
2169 */
2170 xitk_window_t *xitk_window_create_simple_window(ImlibData *im, int x, int y, int width, int height);
2171
2172 /**
2173 *
2174 */
2175 xitk_window_t *xitk_window_create_dialog_window(ImlibData *im, const char *title, int x, int y, int width, int height);
2176
2177
2178 /**
2179 *
2180 */
2181 void xitk_window_dialog_destroy(xitk_window_t *w);
2182
2183 /**
2184 *
2185 */
2186 void xitk_window_destroy_window(ImlibData *im, xitk_window_t *w);
2187
2188 /**
2189 *
2190 */
2191 void xitk_window_move_window(ImlibData *im, xitk_window_t *w, int x, int y);
2192
2193 /**
2194 *
2195 */
2196 void xitk_window_center_window(ImlibData *im, xitk_window_t *w);
2197
2198 /**
2199 *
2200 */
2201 Window xitk_window_get_window(xitk_window_t *w);
2202
2203 /**
2204 *
2205 */
2206 Pixmap xitk_window_get_background(xitk_window_t *w);
2207
2208 /**
2209 *
2210 */
2211 Pixmap xitk_window_get_background_mask(xitk_window_t *w);
2212
2213 /**
2214 *
2215 */
2216 void xitk_window_apply_background(ImlibData *im, xitk_window_t *w);
2217
2218 /**
2219 *
2220 */
2221 int xitk_window_change_background(ImlibData *im, xitk_window_t *w, Pixmap bg, int width, int height);
2222
2223 /**
2224 *
2225 */
2226 int xitk_window_change_background_with_image(ImlibData *im, xitk_window_t *w, xitk_image_t *img, int width, int height);
2227
2228 /**
2229 *
2230 */
2231 void xitk_window_get_window_size(xitk_window_t *w, int *width, int *height);
2232
2233 /*
2234 *
2235 */
2236 void xitk_get_window_position(Display *display, Window window,
2237 int *x, int *y, int *width, int *height);
2238
2239 /*
2240 *
2241 */
2242 void xitk_window_get_window_position(ImlibData *im, xitk_window_t *w,
2243 int *x, int *y, int *width, int *height);
2244
2245 /*
2246 *
2247 */
2248 void xitk_set_window_title(Display *display, Window window, const char *title);
2249
2250 /*
2251 *
2252 */
2253 void xitk_window_set_window_title(ImlibData *im, xitk_window_t *w, const char *title);
2254
2255 /*
2256 *
2257 */
2258 int xitk_is_window_iconified(Display *display, Window window);
2259
2260 /*
2261 *
2262 */
2263 int xitk_is_window_visible(Display *display, Window window);
2264
2265 /*
2266 *
2267 */
2268 Window xitk_get_desktop_root_window(Display *display, int screen, Window *clientparent);
2269
2270 /*
2271 *
2272 */
2273 int xitk_is_window_size(Display *display, Window window, int width, int height);
2274
2275 xitk_window_t *xitk_window_dialog_button_free_with_width(ImlibData *im, const char *title,
2276 int window_width, int align, const char *message, ...)
2277 __attribute__ ((format (printf, 5, 6)));
2278
2279 /*
2280 *
2281 */
2282 xitk_window_t *xitk_window_dialog_one_button_with_width(ImlibData *im, const char *title, const char *button_label,
2283 xitk_state_callback_t cb, void *userdata,
2284 int window_width, int align, const char *message, ...)
2285 __attribute__ ((format (printf, 8, 9)));
2286
2287 /**
2288 *
2289 */
2290 xitk_window_t *xitk_window_dialog_ok_with_width(ImlibData *im, const char *title,
2291 xitk_state_callback_t cb, void *userdata,
2292 int window_width, int align, const char *message, ...)
2293 __attribute__ ((format (printf, 7, 8)));
2294
2295 /**
2296 *
2297 */
2298 xitk_window_t *xitk_window_dialog_ok(ImlibData *im, const char *title,
2299 xitk_state_callback_t cb, void *userdata, int align, const char *message, ...)
2300 __attribute__ ((format (printf, 6, 7)));
2301
2302
2303 #ifdef __GNUC__
2304 #define xitk_window_dialog_ok(im, title, cb, userdata, align, message, args...) \
2305 xitk_window_dialog_ok_with_width(im, title, cb, userdata, 400, align, message, ##args)
2306
2307 #define xitk_window_dialog_error(im, message, args...) \
2308 xitk_window_dialog_ok_with_width(im, _("Error"), NULL, NULL, 400, ALIGN_CENTER, message, ##args)
2309
2310 #define xitk_window_dialog_info(im, message, args...) \
2311 xitk_window_dialog_ok_with_width(im, _("Information"), NULL, NULL, 400, ALIGN_CENTER, message, ##args)
2312 #else
2313 #define xitk_window_dialog_ok(im, title, cb, userdata, align, ...) \
2314 xitk_window_dialog_ok_with_width(im, title, cb, userdata, 400, align, __VA_ARGS__)
2315
2316 #define xitk_window_dialog_error(im, ...) \
2317 xitk_window_dialog_ok_with_width(im, _("Error"), NULL, NULL, 400, ALIGN_CENTER, __VA_ARGS__)
2318
2319 #define xitk_window_dialog_info(im, ...) \
2320 xitk_window_dialog_ok_with_width(im, _("Information"), NULL, NULL, 400, ALIGN_CENTER, __VA_ARGS__)
2321 #endif
2322 /*
2323 *
2324 */
2325 xitk_window_t *xitk_window_dialog_three_buttons_with_width(ImlibData *im, const char *title,
2326 const char *button1_label,
2327 const char *button2_label,
2328 const char *button3_label,
2329 xitk_state_callback_t cb1,
2330 xitk_state_callback_t cb2,
2331 xitk_state_callback_t cb3,
2332 void *userdata,
2333 int window_width, int align, const char *message, ...)
2334 __attribute__ ((format (printf, 12, 13)));
2335 /**
2336 *
2337 */
2338 xitk_window_t *xitk_window_dialog_yesnocancel_with_width(ImlibData *im, const char *title,
2339 xitk_state_callback_t ycb,
2340 xitk_state_callback_t ncb,
2341 xitk_state_callback_t ccb,
2342 void *userdata,
2343 int window_width, int align, const char *message, ...)
2344 __attribute__ ((format (printf, 9, 10)));
2345
2346 /**
2347 *
2348 */
2349 xitk_window_t *xitk_window_dialog_yesnocancel(ImlibData *im, const char *title,
2350 xitk_state_callback_t ycb,
2351 xitk_state_callback_t ncb,
2352 xitk_state_callback_t ccb,
2353 void *userdata, int align, const char *message, ...)
2354 __attribute__ ((format (printf, 8, 9)));
2355
2356 #ifdef __GNUC__
2357 #define xitk_window_dialog_yesnocancel(im, title, ycb, ncb, ccb, userdata, align, message, args...) \
2358 xitk_window_dialog_yesnocancel_with_width(im, title, ycb, ncb, ccb, userdata, 400, align, message, ##args)
2359 #else
2360 #define xitk_window_dialog_yesnocancel(im, title, ycb, ncb, ccb, userdata, align, ...) \
2361 xitk_window_dialog_yesnocancel_with_width(im, title, ycb, ncb, ccb, userdata, 400, align, __VA_ARGS__)
2362 #endif
2363
2364 /*
2365 *
2366 */
2367 xitk_window_t *xitk_window_dialog_checkbox_two_buttons_with_width(ImlibData *im, const char *title,
2368 const char *button1_label,
2369 const char *button2_label,
2370 xitk_state_callback_t cb1,
2371 xitk_state_callback_t cb2,
2372 const char *checkbox_label, int checkbox_state,
2373 xitk_state_callback_t cb3,
2374 void *userdata,
2375 int window_width, int align, const char *message, ...)
2376 __attribute__((__format__(__printf__, 13, 14)));
2377
2378 #ifdef __GNUC__
2379 #define xitk_window_dialog_two_buttons_with_width(im, title, bl1, bl2, cb1, cb2, userdata, window_width, align, message, args...) \
2380 xitk_window_dialog_checkbox_two_buttons_with_width(im, title, bl1, bl2, cb1, cb2, NULL, 0, NULL, userdata, window_width, align, message, ##args)
2381 #else
2382 #define xitk_window_dialog_two_buttons_with_width(im, title, bl1, bl2, cb1, cb2, userdata, window_width, align, ...) \
2383 xitk_window_dialog_checkbox_two_buttons_with_width(im, title, bl1, bl2, cb1, cb2, NULL, 0, NULL, userdata, window_width, align, __VA_ARGS__)
2384 #endif
2385
2386 /**
2387 *
2388 */
2389 xitk_window_t *xitk_window_dialog_yesno_with_width(ImlibData *im, const char *title,
2390 xitk_state_callback_t ycb,
2391 xitk_state_callback_t ncb,
2392 void *userdata,
2393 int window_width, int align, const char *message, ...)
2394 __attribute__ ((format (printf, 8, 9)));
2395
2396 /**
2397 *
2398 */
2399 xitk_window_t *xitk_window_dialog_yesno(ImlibData *im, const char *title,
2400 xitk_state_callback_t ycb,
2401 xitk_state_callback_t ncb,
2402 void *userdata, int align, const char *message, ...)
2403 __attribute__ ((format (printf, 7, 8)));
2404 #ifdef __GNUC__
2405 #define xitk_window_dialog_yesno(im, title, ycb, ncb, userdata, align, message, args...) \
2406 xitk_window_dialog_yesno_with_width(im, title, ycb, ncb, userdata, 400, align, message, ##args)
2407 #else
2408 #define xitk_window_dialog_yesno(im, title, ycb, ncb, userdata, align, ...) \
2409 xitk_window_dialog_yesno_with_width(im, title, ycb, ncb, userdata, 400, align, __VA_ARGS__)
2410 #endif
2411
2412 void xitk_window_set_parent_window(xitk_window_t *xwin, Window parent);
2413
2414 void xitk_window_set_modal(xitk_window_t *w);
2415 void xitk_window_dialog_set_modal(xitk_window_t *w);
2416
2417 xitk_widget_t *xitk_noskin_tabs_create(xitk_widget_list_t *wl,
2418 xitk_tabs_widget_t *t,
2419 int x, int y, int width, const char *fontname);
2420 int xitk_tabs_get_current_selected(xitk_widget_t *w);
2421 const char *xitk_tabs_get_current_tab_selected(xitk_widget_t *w);
2422 void xitk_tabs_set_current_selected(xitk_widget_t *w, int select);
2423
2424 xitk_widget_t *xitk_noskin_intbox_create(xitk_widget_list_t *wl,
2425 xitk_intbox_widget_t *ib,
2426 int x, int y, int width, int height,
2427 xitk_widget_t **iw, xitk_widget_t **mw, xitk_widget_t **lw);
2428 void xitk_intbox_set_value(xitk_widget_t *, int);
2429 int xitk_intbox_get_value(xitk_widget_t *);
2430 xitk_widget_t *xitk_intbox_get_input_widget(xitk_widget_t *w);
2431
2432 xitk_widget_t *xitk_noskin_doublebox_create(xitk_widget_list_t *wl,
2433 xitk_doublebox_widget_t *ib,
2434 int x, int y, int width, int height,
2435 xitk_widget_t **iw, xitk_widget_t **mw, xitk_widget_t **lw);
2436 void xitk_doublebox_set_value(xitk_widget_t *, double);
2437 double xitk_doublebox_get_value(xitk_widget_t *);
2438 xitk_widget_t *xitk_doublebox_get_input_widget(xitk_widget_t *w);
2439
2440 int xitk_widget_list_set(xitk_widget_list_t *wl, int param, void *data);
2441 void *xitk_widget_list_get(xitk_widget_list_t *wl, int param);
2442 void xitk_widget_keyable(xitk_widget_t *w, int keyable);
2443
2444 xitk_widget_t *xitk_noskin_menu_create(xitk_widget_list_t *wl,
2445 xitk_menu_widget_t *m, int x, int y);
2446 void xitk_menu_show_menu(xitk_widget_t *w);
2447 void xitk_menu_add_entry(xitk_widget_t *w, xitk_menu_entry_t *me);
2448 xitk_widget_t *xitk_menu_get_menu(xitk_widget_t *w);
2449 void xitk_menu_destroy_sub_branchs(xitk_widget_t *w);
2450 void xitk_menu_destroy_branch(xitk_widget_t *w);
2451 void xitk_menu_destroy(xitk_widget_t *w);
2452 int xitk_menu_show_sub_branchs(xitk_widget_t *w);
2453
2454
2455 void xitk_cursors_define_window_cursor(Display *display, Window window, xitk_cursors_t cursor);
2456 void xitk_cursors_restore_window_cursor(Display *display, Window window);
2457
2458 #endif
2459